Mercurial > pub > dyncall > dyncall
annotate doc/disas_examples/x64.sysv.disas @ 663:127b569978cc default tip
- another tweak handling clang trying to be too smart (see last commit)
author | Tassilo Philipp |
---|---|
date | Sun, 24 Mar 2024 13:52:44 +0100 |
parents | f1810b5dbb3b |
children |
rev | line source |
---|---|
327
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
1 ; #include <stdlib.h> |
427 | 2 ; |
327
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
3 ; void leaf_call(int b, int c, int d, int e, int f, int g, int h) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
4 ; { |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
5 ; } |
427 | 6 ; |
327
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
7 ; void nonleaf_call(int a, int b, int c, int d, int e, int f, int g, int h) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
8 ; { |
468
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
9 ; /* use some local data */ |
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
10 ; *(char*)alloca(10) = 'L'; |
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
11 ; leaf_call(b, c, d, e, f, g, h); |
327
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
12 ; } |
427 | 13 ; |
327
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
14 ; int main() |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
15 ; { |
468
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
16 ; nonleaf_call(0, 1, 2, 3, 4, 5, 6, 7); |
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
17 ; return 0; |
327
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
18 ; } |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
19 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
20 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
21 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
22 ; output from freebsd-12.0-x64 w/ clang 6.0.1 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
23 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
24 0000000000000000 <leaf_call>: |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
25 0: 55 push %rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
26 1: 48 89 e5 mov %rsp,%rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
27 4: 8b 45 10 mov 0x10(%rbp),%eax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
28 7: 89 7d fc mov %edi,-0x4(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
29 a: 89 75 f8 mov %esi,-0x8(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
30 d: 89 55 f4 mov %edx,-0xc(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
31 10: 89 4d f0 mov %ecx,-0x10(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
32 13: 44 89 45 ec mov %r8d,-0x14(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
33 17: 44 89 4d e8 mov %r9d,-0x18(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
34 1b: 89 45 e4 mov %eax,-0x1c(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
35 1e: 5d pop %rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
36 1f: c3 retq |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
37 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
38 0000000000000020 <nonleaf_call>: |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
39 20: 55 push %rbp ; | |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
40 21: 48 89 e5 mov %rsp,%rbp ; | prolog |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
41 24: 48 83 ec 40 sub $0x40,%rsp ; | open frame *with* static alloca() size included |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
42 28: 8b 45 18 mov 0x18(%rbp),%eax ; unsure... get stack param from prev frame into some scratch reg... but why? see below @@@ |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
43 2b: 44 8b 55 10 mov 0x10(%rbp),%r10d ; unsure... get stack param from prev frame into some scratch reg... but why? see below @@@ |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
44 2f: 89 7d fc mov %edi,-0x4(%rbp) ; in arg 0 -> local area (as temp store) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
45 32: 89 75 f8 mov %esi,-0x8(%rbp) ; in arg 1 -> local area (as temp store) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
46 35: 89 55 f4 mov %edx,-0xc(%rbp) ; in arg 2 -> local area (as temp store) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
47 38: 89 4d f0 mov %ecx,-0x10(%rbp) ; in arg 3 -> local area (as temp store) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
48 3b: 44 89 45 ec mov %r8d,-0x14(%rbp) ; in arg 4 -> local area (as temp store) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
49 3f: 44 89 4d e8 mov %r9d,-0x18(%rbp) ; in arg 5 -> local area (as temp store) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
50 43: c6 45 d0 4c movb $0x4c,-0x30(%rbp) ; 'L' -> local area (of alloca()'d space) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
51 47: 8b 7d f8 mov -0x8(%rbp),%edi ; arg 0 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
52 4a: 8b 75 f4 mov -0xc(%rbp),%esi ; arg 1 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
53 4d: 8b 55 f0 mov -0x10(%rbp),%edx ; arg 2 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
54 50: 8b 4d ec mov -0x14(%rbp),%ecx ; arg 3 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
55 53: 44 8b 45 e8 mov -0x18(%rbp),%r8d ; arg 4 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
56 57: 44 8b 4d 10 mov 0x10(%rbp),%r9d ; arg 5 (fetched from prev frame's param area - behind return addr on 16b aligned stack) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
57 5b: 44 8b 5d 18 mov 0x18(%rbp),%r11d ; arg 6 (fetched from prev frame's param area), and ... |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
58 5f: 44 89 1c 24 mov %r11d,(%rsp) ; ... "pushed" onto stack |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
59 63: 44 89 55 cc mov %r10d,-0x34(%rbp) ; unsure... write something to local area @@@? |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
60 67: 89 45 c8 mov %eax,-0x38(%rbp) ; unsure... write something to local area @@@? |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
61 6a: e8 91 ff ff ff callq 0 <leaf_call> ; push return addr and call |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
62 6f: 48 83 c4 40 add $0x40,%rsp ; | |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
63 73: 5d pop %rbp ; | epilog |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
64 74: c3 retq ; | |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
65 75: 66 66 2e 0f 1f 84 00 nopw %cs:0x0(%rax,%rax,1) ; garbage data |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
66 7c: 00 00 00 00 ; garbage data |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
67 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
68 0000000000000080 <main>: |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
69 80: 55 push %rbp ; | |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
70 81: 48 89 e5 mov %rsp,%rbp ; | prolog |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
71 84: 48 83 ec 20 sub $0x20,%rsp ; | |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
72 88: 31 ff xor %edi,%edi ; arg 0 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
73 8a: be 01 00 00 00 mov $0x1,%esi ; arg 1 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
74 8f: ba 02 00 00 00 mov $0x2,%edx ; arg 2 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
75 94: b9 03 00 00 00 mov $0x3,%ecx ; arg 3 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
76 99: 41 b8 04 00 00 00 mov $0x4,%r8d ; arg 4 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
77 9f: 41 b9 05 00 00 00 mov $0x5,%r9d ; arg 5 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
78 a5: b8 06 00 00 00 mov $0x6,%eax ; unsure... see below @@@? |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
79 aa: 41 ba 07 00 00 00 mov $0x7,%r10d ; unsure... see below @@@? |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
80 b0: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) ; unsure... write 0 to local area @@@? |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
81 b7: c7 04 24 06 00 00 00 movl $0x6,(%rsp) ; "push" arg6 onto stack |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
82 be: c7 44 24 08 07 00 00 00 movl $0x7,0x8(%rsp) ; "push" arg7 onto stack |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
83 c6: 44 89 55 f8 mov %r10d,-0x8(%rbp) ; unsure... write something to local area @@@? |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
84 ca: 89 45 f4 mov %eax,-0xc(%rbp) ; unsure... write something to local area @@@? |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
85 cd: e8 4e ff ff ff callq 20 <nonleaf_call> ; push return addr and call |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
86 d2: 31 c0 xor %eax,%eax ; return value |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
87 d4: 48 83 c4 20 add $0x20,%rsp ; | |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
88 d8: 5d pop %rbp ; | epilog |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
89 d9: c3 retq ; | |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
90 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
91 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
92 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
93 ; output from arch_linux-2011.08.19-x64 w/ gcc 4.6.1 (w/ alloca(220) instead of 10) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
94 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
95 0000000000000000 <leaf_call>: |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
96 0: 55 push %rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
97 1: 48 89 e5 mov %rsp,%rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
98 4: 89 7d fc mov %edi,-0x4(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
99 7: 89 75 f8 mov %esi,-0x8(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
100 a: 89 55 f4 mov %edx,-0xc(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
101 d: 89 4d f0 mov %ecx,-0x10(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
102 10: 44 89 45 ec mov %r8d,-0x14(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
103 14: 44 89 4d e8 mov %r9d,-0x18(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
104 18: 5d pop %rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
105 19: c3 retq |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
106 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
107 000000000000001a <nonleaf_call>: |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
108 1a: 55 push %rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
109 1b: 48 89 e5 mov %rsp,%rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
110 1e: 48 83 ec 30 sub $0x30,%rsp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
111 22: 89 7d fc mov %edi,-0x4(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
112 25: 89 75 f8 mov %esi,-0x8(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
113 28: 89 55 f4 mov %edx,-0xc(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
114 2b: 89 4d f0 mov %ecx,-0x10(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
115 2e: 44 89 45 ec mov %r8d,-0x14(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
116 32: 44 89 4d e8 mov %r9d,-0x18(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
117 36: b8 10 00 00 00 mov $0x10,%eax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
118 3b: 48 83 e8 01 sub $0x1,%rax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
119 3f: 48 05 eb 00 00 00 add $0xeb,%rax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
120 45: 48 c7 45 e0 10 00 00 00 movq $0x10,-0x20(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
121 4d: ba 00 00 00 00 mov $0x0,%edx |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
122 52: 48 f7 75 e0 divq -0x20(%rbp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
123 56: 48 6b c0 10 imul $0x10,%rax,%rax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
124 5a: 48 29 c4 sub %rax,%rsp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
125 5d: 48 8d 44 24 08 lea 0x8(%rsp),%rax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
126 62: 48 83 c0 0f add $0xf,%rax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
127 66: 48 c1 e8 04 shr $0x4,%rax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
128 6a: 48 c1 e0 04 shl $0x4,%rax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
129 6e: c6 00 4c movb $0x4c,(%rax) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
130 71: 44 8b 45 e8 mov -0x18(%rbp),%r8d |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
131 75: 8b 4d ec mov -0x14(%rbp),%ecx |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
132 78: 8b 55 f0 mov -0x10(%rbp),%edx |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
133 7b: 8b 75 f4 mov -0xc(%rbp),%esi |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
134 7e: 8b 45 f8 mov -0x8(%rbp),%eax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
135 81: 8b 7d 18 mov 0x18(%rbp),%edi |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
136 84: 89 3c 24 mov %edi,(%rsp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
137 87: 44 8b 4d 10 mov 0x10(%rbp),%r9d |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
138 8b: 89 c7 mov %eax,%edi |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
139 8d: e8 00 00 00 00 callq 92 <nonleaf_call+0x78> |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
140 92: c9 leaveq |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
141 93: c3 retq |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
142 |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
143 0000000000000094 <main>: |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
144 94: 55 push %rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
145 95: 48 89 e5 mov %rsp,%rbp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
146 98: 48 83 ec 10 sub $0x10,%rsp |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
147 9c: c7 44 24 08 07 00 00 00 movl $0x7,0x8(%rsp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
148 a4: c7 04 24 06 00 00 00 movl $0x6,(%rsp) |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
149 ab: 41 b9 05 00 00 00 mov $0x5,%r9d |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
150 b1: 41 b8 04 00 00 00 mov $0x4,%r8d |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
151 b7: b9 03 00 00 00 mov $0x3,%ecx |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
152 bc: ba 02 00 00 00 mov $0x2,%edx |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
153 c1: be 01 00 00 00 mov $0x1,%esi |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
154 c6: bf 00 00 00 00 mov $0x0,%edi |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
155 cb: e8 00 00 00 00 callq d0 <main+0x3c> |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
156 d0: b8 00 00 00 00 mov $0x0,%eax |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
157 d5: c9 leaveq |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
158 d6: c3 retq |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
159 |
427 | 160 |
161 | |
162 ; ---------- structs by value, struct in first call on reg arg boundary ----------> | |
163 ; | |
164 ; #include <stdlib.h> | |
165 ; | |
166 ; struct A { int i, j; long long l; }; | |
167 ; | |
168 ; void leaf_call(int b, int c, int d, int e, struct A f, int g, int h) | |
169 ; { | |
170 ; } | |
171 ; | |
172 ; void nonleaf_call(int a, int b, int c, int d, int e, struct A f, int g, int h) | |
173 ; { | |
174 ; /* use some local data */ | |
175 ; *(char*)alloca(220) = 'L'; | |
176 ; leaf_call(b, c, d, e, f, g, h); | |
177 ; } | |
178 ; | |
179 ; int main() | |
180 ; { | |
181 ; nonleaf_call(0, 1, 2, 3, 4, (struct A){5, 6, 7ll}, 8, 9); | |
182 ; return 0; | |
183 ; } | |
184 | |
185 | |
186 | |
187 ; output from freebsd-12.2-x64 w/ clang 10.0.1 | |
188 | |
189 0000000000201920 <leaf_call>: | |
190 201920: 55 push %rbp | |
191 201921: 48 89 e5 mov %rsp,%rbp | |
192 201924: 8b 45 18 mov 0x18(%rbp),%eax | |
193 201927: 44 8b 55 10 mov 0x10(%rbp),%r10d | |
194 20192b: 4c 89 45 f0 mov %r8,-0x10(%rbp) | |
195 20192f: 4c 89 4d f8 mov %r9,-0x8(%rbp) | |
196 201933: 89 7d ec mov %edi,-0x14(%rbp) | |
197 201936: 89 75 e8 mov %esi,-0x18(%rbp) | |
198 201939: 89 55 e4 mov %edx,-0x1c(%rbp) | |
199 20193c: 89 4d e0 mov %ecx,-0x20(%rbp) | |
200 20193f: 5d pop %rbp | |
201 201940: c3 retq | |
202 201941: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1) | |
203 20194b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) | |
204 | |
205 0000000000201950 <nonleaf_call>: | |
206 201950: 55 push %rbp ; | | |
207 201951: 48 89 e5 mov %rsp,%rbp ; | prolog | |
208 201954: 53 push %rbx ; | | |
209 201955: 48 81 ec 18 01 00 00 sub $0x118,%rsp ; | open frame *with* static alloca() size included | |
210 20195c: 8b 45 20 mov 0x20(%rbp),%eax ; unsure... stack param from prev frame into some scratch reg... but why? see below @@@ | |
211 20195f: 4c 8d 55 10 lea 0x10(%rbp),%r10 ; ptr to struct on stack -> r10 | |
212 201963: 89 7d f4 mov %edi,-0xc(%rbp) ; | | |
213 201966: 89 75 f0 mov %esi,-0x10(%rbp) ; | | |
214 201969: 89 55 ec mov %edx,-0x14(%rbp) ; | | |
215 20196c: 89 4d e8 mov %ecx,-0x18(%rbp) ; | in args (regs) -> local area (as temp store, mem order 8,4,3,2,1,0) | |
216 20196f: 44 89 45 e4 mov %r8d,-0x1c(%rbp) ; | | |
217 201973: 44 89 4d e0 mov %r9d,-0x20(%rbp) ; | | |
218 201977: c6 85 00 ff ff ff 4c movb $0x4c,-0x100(%rbp) ; 'L' -> local area (of alloca()'d space) | |
219 20197e: 8b 7d f0 mov -0x10(%rbp),%edi ; arg 0 | |
220 201981: 8b 75 ec mov -0x14(%rbp),%esi ; arg 1 | |
221 201984: 8b 55 e8 mov -0x18(%rbp),%edx ; arg 2 | |
222 201987: 8b 4d e4 mov -0x1c(%rbp),%ecx ; arg 3 | |
618 | 223 20198a: 44 8b 45 e0 mov -0x20(%rbp),%r8d ; in arg 5 (local copy) -> r8 pointless, free regs available and using arg reg as temporary, needs freeing below |
224 20198e: 44 8b 4d 20 mov 0x20(%rbp),%r9d ; in arg 6 (stack) -> r9 pointless, free regs available and using arg reg as temporary, needs freeing below | |
225 201992: 4d 8b 1a mov (%r10),%r11 ; in arg 4 (A.i, A.j) -> hold in scratch reg | |
226 201995: 4d 8b 52 08 mov 0x8(%r10),%r10 ; in arg 4 (A.l) -> hold in scratch reg | |
427 | 227 201999: 44 89 85 fc fe ff ff mov %r8d,-0x104(%rbp) ; 'free' r8, temp store content |
228 2019a0: 4d 89 d8 mov %r11,%r8 ; arg 4 (A.i, A.j) | |
229 2019a3: 44 89 8d f8 fe ff ff mov %r9d,-0x108(%rbp) ; 'free' r9, temp store content | |
230 2019aa: 4d 89 d1 mov %r10,%r9 ; arg 4 (A.l) | |
618 | 231 2019ad: 8b 9d fc fe ff ff mov -0x104(%rbp),%ebx ; | |
427 | 232 2019b3: 89 1c 24 mov %ebx,(%rsp) ; / arg 5 (fetch from temp store, pushed) pointless, could've been pushed, directly |
233 2019b6: 8b 9d f8 fe ff ff mov -0x108(%rbp),%ebx ; \ | |
618 | 234 2019bc: 89 5c 24 08 mov %ebx,0x8(%rsp) ; | arg 6 (fetch from temp store, pushed) pointless, could've been pushed, directly |
427 | 235 2019c0: 89 85 f4 fe ff ff mov %eax,-0x10c(%rbp) ; unsure... write something to local area @@@? |
236 2019c6: e8 55 ff ff ff callq 201920 <leaf_call> ; push return addr and call | |
237 2019cb: 48 81 c4 18 01 00 00 add $0x118,%rsp ; | | |
238 2019d2: 5b pop %rbx ; | | |
239 2019d3: 5d pop %rbp ; | epilog | |
240 2019d4: c3 retq ; | | |
241 2019d5: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1) ; garbage data | |
242 2019df: 90 nop ; garbage data | |
243 | |
244 00000000002019e0 <main>: | |
245 2019e0: 55 push %rbp ; | | |
246 2019e1: 48 89 e5 mov %rsp,%rbp ; | prolog | |
247 2019e4: 48 83 ec 30 sub $0x30,%rsp ; | | |
248 2019e8: 31 ff xor %edi,%edi ; arg 0 | |
249 2019ea: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) ; unsure... write 0 to local area @@@? | |
250 2019f1: c7 45 e8 05 00 00 00 movl $0x5,-0x18(%rbp) ; | field i | |
251 2019f8: c7 45 ec 06 00 00 00 movl $0x6,-0x14(%rbp) ; | fill struct A (local area) field j | |
252 2019ff: 48 c7 45 f0 07 00 00 00 movq $0x7,-0x10(%rbp) ; | field l | |
253 201a07: be 01 00 00 00 mov $0x1,%esi ; arg 1 | |
254 201a0c: ba 02 00 00 00 mov $0x2,%edx ; arg 2 | |
255 201a11: b9 03 00 00 00 mov $0x3,%ecx ; arg 3 | |
256 201a16: 41 b8 04 00 00 00 mov $0x4,%r8d ; arg 4 | |
257 201a1c: 48 8d 45 e8 lea -0x18(%rbp),%rax ; | | |
258 201a20: 4c 8b 08 mov (%rax),%r9 ; | | |
259 201a23: 4c 89 0c 24 mov %r9,(%rsp) ; | arg 5 (struct, pushed onto stack, as not enough regs) | |
260 201a27: 48 8b 40 08 mov 0x8(%rax),%rax ; | | |
261 201a2b: 48 89 44 24 08 mov %rax,0x8(%rsp) ; | | |
262 201a30: 41 b9 08 00 00 00 mov $0x8,%r9d ; arg 6 (in reg) | |
263 201a36: c7 44 24 10 09 00 00 00 movl $0x9,0x10(%rsp) ; arg 7 (pushed) | |
264 201a3e: e8 0d ff ff ff callq 201950 <nonleaf_call> ; push return addr and call | |
265 201a43: 31 c0 xor %eax,%eax ; return value | |
266 201a45: 48 83 c4 30 add $0x30,%rsp ; | | |
267 201a49: 5d pop %rbp ; | epilog | |
268 201a4a: c3 retq ; | | |
269 | |
270 | |
271 ; ---------- structs by value, complex example (multiple structs, partly passed via regs) ----------> | |
272 ; | |
273 ; #include <stdlib.h> | |
274 ; | |
275 ; struct A { int i, j; float f; }; | |
276 ; struct B { double d; long long l; }; | |
277 ; | |
278 ; 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) | |
279 ; { | |
280 ; } | |
281 ; | |
282 ; 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) | |
283 ; { | |
284 ; /* use some local data */ | |
285 ; *(char*)alloca(220) = 'L'; | |
286 ; leaf_call(b, c, d, e, f, g, h, i, j); | |
287 ; } | |
288 ; | |
289 ; int main() | |
290 ; { | |
291 ; 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); | |
292 ; return 0; | |
293 ; } | |
294 | |
295 | |
296 | |
297 ; output from freebsd-12.2-x64 w/ clang 10.0.1 | |
298 | |
299 0000000000201940 <leaf_call>: | |
300 201940: 55 push %rbp | |
301 201941: 48 89 e5 mov %rsp,%rbp | |
302 201944: 8b 45 28 mov 0x28(%rbp),%eax | |
303 201947: 44 8b 55 20 mov 0x20(%rbp),%r10d | |
304 20194b: 48 89 75 e0 mov %rsi,-0x20(%rbp) | |
305 20194f: f3 0f 11 45 e8 movss %xmm0,-0x18(%rbp) | |
306 201954: 48 8b 75 e0 mov -0x20(%rbp),%rsi | |
307 201958: 48 89 75 f0 mov %rsi,-0x10(%rbp) | |
308 20195c: 44 8b 5d e8 mov -0x18(%rbp),%r11d | |
309 201960: 44 89 5d f8 mov %r11d,-0x8(%rbp) | |
310 201964: f2 0f 11 4d d0 movsd %xmm1,-0x30(%rbp) | |
311 201969: 48 89 55 d8 mov %rdx,-0x28(%rbp) | |
312 20196d: 4c 89 4d b0 mov %r9,-0x50(%rbp) | |
313 201971: f3 0f 11 55 b8 movss %xmm2,-0x48(%rbp) | |
314 201976: 48 8b 55 b0 mov -0x50(%rbp),%rdx | |
315 20197a: 48 89 55 c0 mov %rdx,-0x40(%rbp) | |
316 20197e: 44 8b 5d b8 mov -0x48(%rbp),%r11d | |
317 201982: 44 89 5d c8 mov %r11d,-0x38(%rbp) | |
318 201986: 89 7d ac mov %edi,-0x54(%rbp) | |
319 201989: 89 4d a8 mov %ecx,-0x58(%rbp) | |
320 20198c: 44 89 45 a4 mov %r8d,-0x5c(%rbp) | |
321 201990: 5d pop %rbp | |
322 201991: c3 retq | |
323 201992: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1) | |
324 20199c: 0f 1f 40 00 nopl 0x0(%rax) | |
325 | |
326 00000000002019a0 <nonleaf_call>: | |
327 2019a0: 55 push %rbp ; | | |
328 2019a1: 48 89 e5 mov %rsp,%rbp ; | | |
329 2019a4: 41 57 push %r15 ; | | |
330 2019a6: 41 56 push %r14 ; | prolog | |
331 2019a8: 41 54 push %r12 ; | | |
332 2019aa: 53 push %rbx ; | | |
333 2019ab: 48 81 ec 70 01 00 00 sub $0x170,%rsp ; | open frame *with* static alloca() size included | |
334 2019b2: 8b 45 38 mov 0x38(%rbp),%eax ; unsure... get last (15) stack param from prev frame into some scratch reg... but why? see below @@@ | |
335 2019b5: 44 8b 55 30 mov 0x30(%rbp),%r10d ; unsure... get one to last (14) stack param from prev frame into some scratch reg... but why? see below @@@ | |
336 2019b9: 4c 8d 5d 20 lea 0x20(%rbp),%r11 ; ptr to struct B on stack -> rbx | |
337 2019bd: 48 8d 5d 10 lea 0x10(%rbp),%rbx ; ptr to struct A on stack -> r11 | |
338 2019c1: 48 89 55 c0 mov %rdx,-0x40(%rbp) ; | \ i, j | |
339 2019c5: f3 0f 11 45 c8 movss %xmm0,-0x38(%rbp) ; | / reassemble first struct A in mem (local area) f | |
340 2019ca: 48 8b 55 c0 mov -0x40(%rbp),%rdx ; . \ pointless reload of rdx w/ same val from same addr | |
341 2019ce: 48 89 55 d0 mov %rdx,-0x30(%rbp) ; . | | |
342 2019d2: 44 8b 75 c8 mov -0x38(%rbp),%r14d ; . | copy of just reassembled A (local area) @@@ unsure why (@@@ I think we need copies of the structs, all the time) | |
343 2019d6: 44 89 75 d8 mov %r14d,-0x28(%rbp) ; . / | |
344 2019da: f2 0f 11 4d b0 movsd %xmm1,-0x50(%rbp) ; | \ d | |
345 2019df: 48 89 4d b8 mov %rcx,-0x48(%rbp) ; | / reassemble first struct B in mem (local area) l | |
346 2019e3: 89 7d ac mov %edi,-0x54(%rbp) ; | (0) | |
347 2019e6: 89 75 a8 mov %esi,-0x58(%rbp) ; | in args (regs) -> local area (as temp store, mem order 8,7,1,0,B,A,A') (1) | |
348 2019e9: 44 89 45 a4 mov %r8d,-0x5c(%rbp) ; | (7) | |
349 2019ed: 44 89 4d a0 mov %r9d,-0x60(%rbp) ; | (8) | |
350 2019f1: c6 85 a0 fe ff ff 4c movb $0x4c,-0x160(%rbp) ; 'L' -> local area (of alloca()'d space) | |
351 2019f8: 8b 7d a8 mov -0x58(%rbp),%edi ; arg 0 | |
352 2019fb: 8b 4d a4 mov -0x5c(%rbp),%ecx ; arg 3 | |
353 2019fe: 44 8b 45 a0 mov -0x60(%rbp),%r8d ; arg 4 | |
354 201a02: 8b 75 30 mov 0x30(%rbp),%esi ; in arg 9 -> hold in scratch reg | |
355 201a05: 44 8b 4d 38 mov 0x38(%rbp),%r9d ; in arg 8 -> hold in scratch reg | |
356 201a09: 48 8b 55 d0 mov -0x30(%rbp),%rdx ; | again pointless reload of rdx w/ same val from same addr | |
357 201a0d: 48 89 55 90 mov %rdx,-0x70(%rbp) ; | | |
358 201a11: 44 8b 75 d8 mov -0x28(%rbp),%r14d ; | *another* copy of copy of A (local area) @@@ unsure why | |
359 201a15: 44 89 75 98 mov %r14d,-0x68(%rbp) ; | | |
360 201a19: 48 8b 55 90 mov -0x70(%rbp),%rdx ; pointless reload of rdx | |
361 201a1d: f3 0f 10 45 98 movss -0x68(%rbp),%xmm0 ; arg 1 (A.f) @@@ unsure why from copy | |
362 201a22: f2 0f 10 4d b0 movsd -0x50(%rbp),%xmm1 ; arg 2 (B.d) | |
363 201a27: 4c 8b 7d b8 mov -0x48(%rbp),%r15 ; in arg arg 3 (B.l) -> hold in scratch reg | |
364 201a2b: 4c 8b 23 mov (%rbx),%r12 ; | | |
365 201a2e: 4c 89 65 80 mov %r12,-0x80(%rbp) ; | | |
366 201a32: 44 8b 73 08 mov 0x8(%rbx),%r14d ; | copy of in arg 6 (struct A on stack) -> local area | |
367 201a36: 44 89 75 88 mov %r14d,-0x78(%rbp) ; | | |
368 201a3a: 48 8b 5d 80 mov -0x80(%rbp),%rbx ; in arg 6 (A.i, A.j) -> rbx | |
369 201a3e: f3 0f 10 55 88 movss -0x78(%rbp),%xmm2 ; arg 5 (A.f) | |
370 201a43: 89 b5 9c fe ff ff mov %esi,-0x164(%rbp) ; in arg 9 -> temp (at end of frame, a bit pointless as could be pushed directly) | |
371 201a49: 48 89 d6 mov %rdx,%rsi ; arg 1 (A.i, A.j) | |
372 201a4c: 4c 89 fa mov %r15,%rdx ; arg 2 (B.l) | |
373 201a4f: 44 89 8d 98 fe ff ff mov %r9d,-0x168(%rbp) ; in arg 8 -> temp (at end of frame, a bit pointless as could be pushed directly) | |
374 201a56: 49 89 d9 mov %rbx,%r9 ; arg 5 (A.i, A.j) | |
375 201a59: 49 8b 1b mov (%r11),%rbx ; \ | |
376 201a5c: 48 89 1c 24 mov %rbx,(%rsp) ; / arg 6 (B.d) (pushed) | |
377 201a60: 4d 8b 5b 08 mov 0x8(%r11),%r11 ; \ | |
378 201a64: 4c 89 5c 24 08 mov %r11,0x8(%rsp) ; / arg 6 (B.l) (pushed) | |
379 201a69: 44 8b b5 9c fe ff ff mov -0x164(%rbp),%r14d ; \ | |
380 201a70: 44 89 74 24 10 mov %r14d,0x10(%rsp) ; / arg 7 (pushed, aligned) | |
381 201a75: 44 8b b5 98 fe ff ff mov -0x168(%rbp),%r14d ; \ | |
382 201a7c: 44 89 74 24 18 mov %r14d,0x18(%rsp) ; / arg 8 (pushed, aligned) | |
383 201a81: 89 85 94 fe ff ff mov %eax,-0x16c(%rbp) ; unsure... write something to local area @@@? | |
384 201a87: 44 89 95 90 fe ff ff mov %r10d,-0x170(%rbp) ; unsure... write something to local area @@@? | |
385 201a8e: e8 ad fe ff ff callq 201940 <leaf_call> ; push return addr and call | |
386 201a93: 48 81 c4 70 01 00 00 add $0x170,%rsp ; | | |
387 201a9a: 5b pop %rbx ; | | |
388 201a9b: 41 5c pop %r12 ; | | |
389 201a9d: 41 5e pop %r14 ; | epilog | |
390 201a9f: 41 5f pop %r15 ; | | |
391 201aa1: 5d pop %rbp ; | | |
392 201aa2: c3 retq ; | | |
393 201aa3: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1) ; garbage data | |
394 201aad: 0f 1f 00 nopl (%rax) ; garbage data | |
395 | |
396 0000000000201ab0 <main>: | |
397 201ab0: 55 push %rbp ; | | |
398 201ab1: 48 89 e5 mov %rsp,%rbp ; | prolog | |
399 201ab4: 48 81 ec 80 00 00 00 sub $0x80,%rsp ; | | |
400 201abb: 31 ff xor %edi,%edi ; arg 0 | |
401 201abd: f2 0f 10 05 2b ea ff ff movsd -0x15d5(%rip),%xmm0 ; not arg: prep to fill struct B field d (12.0) | |
402 201ac5: f3 0f 10 0d 2f ea ff ff movss -0x15d1(%rip),%xmm1 ; not arg: prep to fill struct A field f (11.f) | |
403 201acd: f2 0f 10 15 13 ea ff ff movsd -0x15ed(%rip),%xmm2 ; not arg: prep to fill struct B field d (5.0) | |
404 201ad5: f3 0f 10 1d 1b ea ff ff movss -0x15e5(%rip),%xmm3 ; not arg: prep to fill struct A field f (4.f) | |
405 201add: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) ; unsure... write 0 to local area @@@? | |
406 201ae4: c7 45 f0 02 00 00 00 movl $0x2,-0x10(%rbp) ; \ field i | |
407 201aeb: c7 45 f4 03 00 00 00 movl $0x3,-0xc(%rbp) ; | fill first struct A (local area) field j | |
408 201af2: f3 0f 11 5d f8 movss %xmm3,-0x8(%rbp) ; / field f | |
409 201af7: f2 0f 11 55 e0 movsd %xmm2,-0x20(%rbp) ; \ field d | |
410 201afc: 48 c7 45 e8 06 00 00 00 movq $0x6,-0x18(%rbp) ; / fill first struct B (local area) field l | |
411 201b04: c7 45 d0 09 00 00 00 movl $0x9,-0x30(%rbp) ; \ field i | |
412 201b0b: c7 45 d4 0a 00 00 00 movl $0xa,-0x2c(%rbp) ; | fill last struct A (local area) field j | |
413 201b12: f3 0f 11 4d d8 movss %xmm1,-0x28(%rbp) ; / field f | |
414 201b17: f2 0f 11 45 c0 movsd %xmm0,-0x40(%rbp) ; \ field d | |
415 201b1c: 48 c7 45 c8 0d 00 00 00 movq $0xd,-0x38(%rbp) ; / fill last struct B (local area) field l | |
416 201b24: 48 8b 45 f0 mov -0x10(%rbp),%rax ; \ | |
417 201b28: 48 89 45 b0 mov %rax,-0x50(%rbp) ; | unsure ... make copy of first struct A (local area) @@@ | |
418 201b2c: 8b 4d f8 mov -0x8(%rbp),%ecx ; | | |
419 201b2f: 89 4d b8 mov %ecx,-0x48(%rbp) ; / | |
420 201b32: 48 8b 55 b0 mov -0x50(%rbp),%rdx ; arg 2 (A.i, A.j) @@@ unsure why from copy made above | |
421 201b36: f3 0f 10 45 b8 movss -0x48(%rbp),%xmm0 ; arg 2 (A.f) @@@ unsure why from copy made above | |
422 201b3b: f2 0f 10 4d e0 movsd -0x20(%rbp),%xmm1 ; arg 3 (B.d) | |
423 201b40: 48 8b 4d e8 mov -0x18(%rbp),%rcx ; arg 3 (B.l) | |
424 201b44: be 01 00 00 00 mov $0x1,%esi ; arg 1 | |
425 201b49: 41 b8 07 00 00 00 mov $0x7,%r8d ; arg 4 | |
426 201b4f: 41 b9 08 00 00 00 mov $0x8,%r9d ; arg 5 | |
427 201b55: 48 8d 45 d0 lea -0x30(%rbp),%rax ; \ \ | |
428 201b59: 4c 8b 10 mov (%rax),%r10 ; | | i, j | |
429 201b5c: 4c 89 14 24 mov %r10,(%rsp) ; | arg 6 (last struct A, *pushed* by value) / | |
430 201b60: 44 8b 58 08 mov 0x8(%rax),%r11d ; | \ f | |
431 201b64: 44 89 5c 24 08 mov %r11d,0x8(%rsp) ; / / | |
432 201b69: 48 8d 45 c0 lea -0x40(%rbp),%rax ; \ \ | |
433 201b6d: 4c 8b 10 mov (%rax),%r10 ; | | d (aligned) | |
434 201b70: 4c 89 54 24 10 mov %r10,0x10(%rsp) ; | arg 7 (last struct B, *pushed* by value) / | |
435 201b75: 48 8b 40 08 mov 0x8(%rax),%rax ; | \ l | |
436 201b79: 48 89 44 24 18 mov %rax,0x18(%rsp) ; / / | |
437 201b7e: c7 44 24 20 0e 00 00 00 movl $0xe,0x20(%rsp) ; arg 8 (pushed, aligned) | |
438 201b86: c7 44 24 28 0f 00 00 00 movl $0xf,0x28(%rsp) ; arg 9 (pushed, aligned) | |
439 201b8e: e8 0d fe ff ff callq 2019a0 <nonleaf_call> ; push return addr and call | |
440 201b93: 31 c0 xor %eax,%eax ; return value | |
441 201b95: 48 81 c4 80 00 00 00 add $0x80,%rsp ; | | |
442 201b9c: 5d pop %rbp ; | epilog | |
443 201b9d: c3 retq ; | | |
444 | |
445 | |
464 | 446 |
447 ; ---------- returning tiny struct by value (passes via regs) ----------> | |
448 ; | |
449 ; struct A { unsigned char a; }; | |
450 ; | |
451 ; struct A call(unsigned char c) | |
452 ; { | |
468
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
453 ; return (struct A){c}; |
464 | 454 ; } |
455 ; | |
456 ; int main() | |
457 ; { | |
468
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
458 ; struct A a = call(123); |
79b95db3d68f
- added (only partly annotated) x64/win64 disas examples
Tassilo Philipp
parents:
464
diff
changeset
|
459 ; return 0; |
464 | 460 ; } |
461 | |
462 | |
463 | |
464 ; output from freebsd-12.2-x64 w/ clang 10.0.1 | |
465 | |
466 00000000002018f0 <call>: | |
467 2018f0: 55 push %rbp ; | | |
468 2018f1: 48 89 e5 mov %rsp,%rbp ; | prolog | |
469 2018f4: 40 88 7d f7 mov %dil,-0x9(%rbp) ; in arg 0 -> local area, ... | a bit pointless, could've been | |
470 2018f8: 8a 45 f7 mov -0x9(%rbp),%al ; ... from local area -> eax, then ... | moved to -0x8(%rbp) directly | |
471 2018fb: 88 45 f8 mov %al,-0x8(%rbp) ; ... to struct in local area | |
472 2018fe: 8a 45 f8 mov -0x8(%rbp),%al ; return value | |
473 201901: 5d pop %rbp ; | epilog | |
474 201902: c3 retq ; | | |
475 201903: 66 2e 0f 1f 84 00 00 00 00 00 nopw %cs:0x0(%rax,%rax,1) ; garbage data | |
476 20190d: 0f 1f 00 nopl (%rax) ; garbage data | |
477 | |
478 0000000000201910 <main>: | |
479 201910: 55 push %rbp ; | | |
480 201911: 48 89 e5 mov %rsp,%rbp ; | prolog | |
481 201914: 48 83 ec 10 sub $0x10,%rsp ; | | |
482 201918: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) ; @@@ unsure, clears dword of local area | |
483 20191f: bf 7b 00 00 00 mov $0x7b,%edi ; arg 0 (123) | |
484 201924: e8 c7 ff ff ff callq 2018f0 <call> ; push return addr and call | |
485 201929: 31 c9 xor %ecx,%ecx ; return value prep (a bit pointless) | |
486 20192b: 88 45 f8 mov %al,-0x8(%rbp) ; write struct data to local area (123) | |
487 20192e: 89 c8 mov %ecx,%eax ; return value | |
488 201930: 48 83 c4 10 add $0x10,%rsp ; | | |
489 201934: 5d pop %rbp ; | epilog | |
490 201935: c3 retq ; | | |
491 | |
492 | |
493 | |
494 ; output from freebsd-12.2-x64 w/ gcc 10.3.0 | |
495 | |
496 00000000004007a5 <call>: | |
497 4007a5: 55 push %rbp ; | | |
498 4007a6: 48 89 e5 mov %rsp,%rbp ; | prolog | |
499 4007a9: 89 f8 mov %edi,%eax ; in arg 0 ... | |
500 4007ab: 88 45 fc mov %al,-0x4(%rbp) ; ... -> struct in local area | |
501 4007ae: 0f b6 45 fc movzbl -0x4(%rbp),%eax ; return value (entire struct in eax) | |
502 4007b2: 5d pop %rbp ; | epilog | |
503 4007b3: c3 retq ; | | |
504 | |
505 00000000004007b4 <main>: | |
506 4007b4: 55 push %rbp ; | | |
507 4007b5: 48 89 e5 mov %rsp,%rbp ; | prolog | |
508 4007b8: 48 83 ec 10 sub $0x10,%rsp ; | | |
509 4007bc: bf 7b 00 00 00 mov $0x7b,%edi ; arg 0 (123) | |
510 4007c1: e8 df ff ff ff callq 4007a5 <call> ; push return addr and call | |
511 4007c6: 88 45 ff mov %al,-0x1(%rbp) ; write struct data to local area (123) | |
512 4007c9: b8 00 00 00 00 mov $0x0,%eax ; return value | |
513 4007ce: c9 leaveq ; | | |
514 4007cf: c3 retq ; | epilog | |
515 | |
516 | |
493
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
517 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
518 ; ---------- C++ trivial and non-trivial aggrs passed to C funcs ----------> |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
519 ; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
520 ; struct Trivial { int a; }; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
521 ; struct NonTrivial { int a; NonTrivial() : a(0) {} NonTrivial(const NonTrivial& rhs) : a(rhs.a) { } }; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
522 ; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
523 ; extern "C" { |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
524 ; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
525 ; void f1(struct Trivial s) { } |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
526 ; void f2(struct NonTrivial s) { } |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
527 ; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
528 ; void f() |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
529 ; { |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
530 ; struct Trivial t; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
531 ; struct NonTrivial n; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
532 ; int a=1; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
533 ; a += 123; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
534 ; f1(t); |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
535 ; a -= 123; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
536 ; f2(n); |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
537 ; a -= 12; |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
538 ; } |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
539 ; } |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
540 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
541 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
542 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
543 ; output from freebsd-12.2-x64 w/ clang 10.0.1 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
544 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
545 0000000000000000 <f1>: |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
546 0: 55 push %rbp ; | prolog |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
547 1: 48 89 e5 mov %rsp,%rbp ; | |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
548 4: 89 7d f8 mov %edi,-0x8(%rbp) ; local copy of trivial struct |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
549 7: 5d pop %rbp ; | |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
550 8: c3 retq ; | epilog |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
551 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
552 0000000000000010 <f2>: |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
553 10: 55 push %rbp ; | prolog |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
554 11: 48 89 e5 mov %rsp,%rbp ; / |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
555 14: 5d pop %rbp ; \ note: no local copy as non-trivial |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
556 15: c3 retq ; | epilog |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
557 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
558 0000000000000020 <f>: |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
559 20: 55 push %rbp ; | |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
560 21: 48 89 e5 mov %rsp,%rbp ; | prolog |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
561 24: 48 83 ec 20 sub $0x20,%rsp ; / |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
562 28: 48 8d 7d f0 lea -0x10(%rbp),%rdi ; \ this ptr (NULL) |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
563 2c: e8 00 00 00 00 callq 31 <f+0x11> ; | NonTrivial::NonTrivial() / ctor |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
564 31: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%rbp) ; a = 1 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
565 38: 8b 45 ec mov -0x14(%rbp),%eax ; | |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
566 3b: 83 c0 7b add $0x7b,%eax ; | a += 123 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
567 3e: 89 45 ec mov %eax,-0x14(%rbp) ; / |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
568 41: 8b 45 f8 mov -0x8(%rbp),%eax ; \ |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
569 44: 89 45 e8 mov %eax,-0x18(%rbp) ; / local copy of t (struct Trivial) |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
570 47: 8b 7d e8 mov -0x18(%rbp),%edi ; f1 arg 0 (struct Trivial), via reg as small struct |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
571 4a: e8 00 00 00 00 callq 4f <f+0x2f> ; call f1(struct Trivial) |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
572 4f: 8b 45 ec mov -0x14(%rbp),%eax ; | |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
573 52: 83 e8 7b sub $0x7b,%eax ; | a -= 123 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
574 55: 89 45 ec mov %eax,-0x14(%rbp) ; / |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
575 58: 48 8d 7d e0 lea -0x20(%rbp),%rdi ; \ ptr to dest of copy of n |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
576 5c: 48 8d 75 f0 lea -0x10(%rbp),%rsi ; | copy n ptr to n |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
577 60: e8 00 00 00 00 callq 65 <f+0x45> ; / NonTrivial::NonTrivial(const NonTrivial&) / copy ctor |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
578 65: 48 8d 7d e0 lea -0x20(%rbp),%rdi ; f2 arg 0 (ptr to copy of struct NonTrivial), via ptr as non-trivial |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
579 69: e8 00 00 00 00 callq 6e <f+0x4e> ; call f2(struct NonTrivial) |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
580 6e: 8b 45 ec mov -0x14(%rbp),%eax ; | |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
581 71: 83 e8 0c sub $0xc,%eax ; | a -= 12 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
582 74: 89 45 ec mov %eax,-0x14(%rbp) ; / |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
583 77: 48 83 c4 20 add $0x20,%rsp ; \ |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
584 7b: 5d pop %rbp ; | epilog |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
585 7c: c3 retq ; | |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
586 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
587 ; ... snip, removed code of ctor and copy ctor ... |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
588 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
589 |
75cb8f79d725
- doc and disas examples update about C++ non-trivial aggregates
Tassilo Philipp
parents:
468
diff
changeset
|
590 |
499
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
591 ; ---------- C++ trivial and non-trivial aggrs as return values ----------> |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
592 ; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
593 ; struct Trivial { int a; }; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
594 ; struct NonTrivial { int a; NonTrivial() : a(0) {} NonTrivial(const NonTrivial& rhs) : a(rhs.a) { } }; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
595 ; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
596 ; extern "C" { |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
597 ; struct Trivial f1() { return Trivial(); } |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
598 ; } |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
599 ; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
600 ; struct NonTrivial f2() { return NonTrivial(); } |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
601 ; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
602 ; extern "C" { |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
603 ; void f() |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
604 ; { |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
605 ; int a=1; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
606 ; a += 123; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
607 ; struct Trivial t = f1(); |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
608 ; a -= 123; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
609 ; struct NonTrivial n = f2(); |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
610 ; a -= 12; |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
611 ; } |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
612 ; } |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
613 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
614 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
615 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
616 ; output from freebsd-12.2-x64 w/ clang 10.0.1 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
617 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
618 00000000002019c0 <f1>: |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
619 2019c0: 55 push %rbp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
620 2019c1: 48 89 e5 mov %rsp,%rbp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
621 2019c4: 48 83 ec 10 sub $0x10,%rsp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
622 2019c8: 31 f6 xor %esi,%esi |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
623 2019ca: 48 8d 45 f8 lea -0x8(%rbp),%rax |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
624 2019ce: 48 89 c7 mov %rax,%rdi |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
625 2019d1: ba 04 00 00 00 mov $0x4,%edx |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
626 2019d6: e8 75 01 00 00 callq 201b50 <memset@plt> |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
627 2019db: 8b 45 f8 mov -0x8(%rbp),%eax |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
628 2019de: 48 83 c4 10 add $0x10,%rsp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
629 2019e2: 5d pop %rbp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
630 2019e3: c3 retq |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
631 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
632 00000000002019f0 <_Z2f2v>: |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
633 2019f0: 55 push %rbp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
634 2019f1: 48 89 e5 mov %rsp,%rbp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
635 2019f4: 48 83 ec 10 sub $0x10,%rsp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
636 2019f8: 48 89 f8 mov %rdi,%rax |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
637 2019fb: 48 89 f9 mov %rdi,%rcx |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
638 2019fe: 48 89 4d f8 mov %rcx,-0x8(%rbp) |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
639 201a02: 48 89 45 f0 mov %rax,-0x10(%rbp) |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
640 201a06: e8 85 00 00 00 callq 201a90 <_ZN10NonTrivialC2Ev> |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
641 201a0b: 48 8b 45 f0 mov -0x10(%rbp),%rax |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
642 201a0f: 48 83 c4 10 add $0x10,%rsp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
643 201a13: 5d pop %rbp |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
644 201a14: c3 retq |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
645 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
646 0000000000201a20 <f>: |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
647 201a20: 55 push %rbp ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
648 201a21: 48 89 e5 mov %rsp,%rbp ; | prolog |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
649 201a24: 48 83 ec 10 sub $0x10,%rsp ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
650 201a28: c7 45 fc 01 00 00 00 movl $0x1,-0x4(%rbp) ; a = 1 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
651 201a2f: 8b 45 fc mov -0x4(%rbp),%eax ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
652 201a32: 83 c0 7b add $0x7b,%eax ; | a += 123 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
653 201a35: 89 45 fc mov %eax,-0x4(%rbp) ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
654 201a38: e8 83 ff ff ff callq 2019c0 <f1> ; call f1() |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
655 201a3d: 89 45 f8 mov %eax,-0x8(%rbp) ; retval via reg, as small struct |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
656 201a40: 8b 45 fc mov -0x4(%rbp),%eax ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
657 201a43: 83 e8 7b sub $0x7b,%eax ; | a -= 123 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
658 201a46: 89 45 fc mov %eax,-0x4(%rbp) ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
659 201a49: 48 8d 7d f0 lea -0x10(%rbp),%rdi ; ptr to space to hold non-triv retval |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
660 201a4d: e8 9e ff ff ff callq 2019f0 <_Z2f2v> ; call f2() |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
661 201a52: 8b 45 fc mov -0x4(%rbp),%eax ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
662 201a55: 83 e8 0c sub $0xc,%eax ; | a-= 12 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
663 201a58: 89 45 fc mov %eax,-0x4(%rbp) ; / |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
664 201a5b: 48 83 c4 10 add $0x10,%rsp ; \ |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
665 201a5f: 5d pop %rbp ; | epilog |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
666 201a60: c3 retq ; | |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
667 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
668 |
fc614cb865c6
- doc and disasexample additions specific to non-trivial C++ aggregates as return values (incl. fixes to doc and additional LSB specific PPC32 section)
Tassilo Philipp
parents:
493
diff
changeset
|
669 |
618 | 670 |
671 ; ---------- structs by value, struct passed as vararg ----------> | |
672 ; | |
673 ; #include <stdlib.h> | |
674 ; #include <stdarg.h> | |
675 ; | |
676 ; struct A { int i, j; long long l; }; | |
677 ; | |
678 ; void leaf_call(int b, int c, int d, int e, ...) | |
679 ; { | |
680 ; } | |
681 ; | |
682 ; void nonleaf_call(int a, int b, int c, ...) | |
683 ; { | |
684 ; int d, e, g, h; | |
685 ; struct A f; | |
686 ; va_list ap; | |
687 ; va_start(ap, c); | |
688 ; d = va_arg(ap, int); | |
689 ; e = va_arg(ap, int); | |
690 ; f = va_arg(ap, struct A); | |
691 ; g = va_arg(ap, int); | |
692 ; h = va_arg(ap, int); | |
693 ; /* use some local data */ | |
694 ; *(char*)alloca(220) = 'L'; | |
695 ; leaf_call(b, c, d, e, f, g, h); | |
696 ; va_end(ap); | |
697 ; } | |
698 ; | |
699 ; int main() | |
700 ; { | |
701 ; nonleaf_call(0, 1, 2, 3, 4, (struct A){5, 6, 7ll}, 8, 9); | |
702 ; return 0; | |
703 ; } | |
704 | |
705 | |
706 | |
707 ; output from freebsd-12.2-x64 w/ clang 10.0.1 | |
708 | |
709 0000000000000000 <leaf_call>: | |
710 0: 55 push %rbp ; | |
711 1: 48 89 e5 mov %rsp,%rbp ; | |
712 4: 89 7d fc mov %edi,-0x4(%rbp) ; | |
713 7: 89 75 f8 mov %esi,-0x8(%rbp) ; | |
714 a: 89 55 f4 mov %edx,-0xc(%rbp) ; | |
715 d: 89 4d f0 mov %ecx,-0x10(%rbp) ; | |
716 10: 5d pop %rbp ; | |
717 11: c3 retq ; | |
718 12: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1) ; | |
719 19: 00 00 00 ; | |
720 1c: 0f 1f 40 00 nopl 0x0(%rax) ; | |
721 | |
722 0000000000000020 <nonleaf_call>: | |
723 20: 55 push %rbp ; | | |
724 21: 48 89 e5 mov %rsp,%rbp ; | prolog | |
725 24: 53 push %rbx ; | | |
726 25: 48 81 ec 28 02 00 00 sub $0x228,%rsp ; | open frame *with* static alloca() size included | |
727 2c: 84 c0 test %al,%al ; test how many used xmm regs (= 0) | |
728 2e: 0f 29 bd f0 fe ff ff movaps %xmm7,-0x110(%rbp) ; | | |
729 35: 0f 29 b5 e0 fe ff ff movaps %xmm6,-0x120(%rbp) ; | | |
730 3c: 0f 29 ad d0 fe ff ff movaps %xmm5,-0x130(%rbp) ; | | |
731 43: 0f 29 a5 c0 fe ff ff movaps %xmm4,-0x140(%rbp) ; | spill xmm regs onto stack (none used by call, though) | |
732 4a: 0f 29 9d b0 fe ff ff movaps %xmm3,-0x150(%rbp) ; | | |
733 51: 0f 29 95 a0 fe ff ff movaps %xmm2,-0x160(%rbp) ; | | |
734 58: 0f 29 8d 90 fe ff ff movaps %xmm1,-0x170(%rbp) ; | | |
735 5f: 0f 29 85 80 fe ff ff movaps %xmm0,-0x180(%rbp) ; / | |
736 66: 4c 89 8d 78 fe ff ff mov %r9,-0x188(%rbp) ; \ | |
737 6d: 4c 89 85 70 fe ff ff mov %r8,-0x190(%rbp) ; | | |
738 74: 48 89 8d 68 fe ff ff mov %rcx,-0x198(%rbp) ; | | |
739 7b: 89 95 64 fe ff ff mov %edx,-0x19c(%rbp) ; | in args (regs) -> local area (as temp store, mem order 0,1,2,3,4,8) | |
740 81: 89 b5 60 fe ff ff mov %esi,-0x1a0(%rbp) ; | | |
741 87: 89 bd 5c fe ff ff mov %edi,-0x1a4(%rbp) ; | | |
742 8d: 0f 84 67 00 00 00 je fa <nonleaf_call+0xda> ; jump to 0xfa if no xmm regs used | |
743 93: 0f 28 85 80 fe ff ff movaps -0x180(%rbp),%xmm0 ; | |
744 9a: 0f 29 85 30 ff ff ff movaps %xmm0,-0xd0(%rbp) ; | |
745 a1: 0f 28 8d 90 fe ff ff movaps -0x170(%rbp),%xmm1 ; | |
746 a8: 0f 29 8d 40 ff ff ff movaps %xmm1,-0xc0(%rbp) ; | |
747 af: 0f 28 95 a0 fe ff ff movaps -0x160(%rbp),%xmm2 ; | |
748 b6: 0f 29 95 50 ff ff ff movaps %xmm2,-0xb0(%rbp) ; | |
749 bd: 0f 28 9d b0 fe ff ff movaps -0x150(%rbp),%xmm3 ; | |
750 c4: 0f 29 9d 60 ff ff ff movaps %xmm3,-0xa0(%rbp) ; | |
751 cb: 0f 28 a5 c0 fe ff ff movaps -0x140(%rbp),%xmm4 ; | |
752 d2: 0f 29 a5 70 ff ff ff movaps %xmm4,-0x90(%rbp) ; | |
753 d9: 0f 28 ad d0 fe ff ff movaps -0x130(%rbp),%xmm5 ; | |
754 e0: 0f 29 6d 80 movaps %xmm5,-0x80(%rbp) ; | |
755 e4: 0f 28 b5 e0 fe ff ff movaps -0x120(%rbp),%xmm6 ; | |
756 eb: 0f 29 75 90 movaps %xmm6,-0x70(%rbp) ; | |
757 ef: 0f 28 bd f0 fe ff ff movaps -0x110(%rbp),%xmm7 ; | |
758 f6: 0f 29 7d a0 movaps %xmm7,-0x60(%rbp) ; | |
759 fa: 48 8b 85 78 fe ff ff mov -0x188(%rbp),%rax ; je loc | |
760 101: 48 89 85 28 ff ff ff mov %rax,-0xd8(%rbp) ; | |
761 108: 48 8b 8d 70 fe ff ff mov -0x190(%rbp),%rcx ; | |
762 10f: 48 89 8d 20 ff ff ff mov %rcx,-0xe0(%rbp) ; | |
763 116: 48 8b 95 68 fe ff ff mov -0x198(%rbp),%rdx ; | |
764 11d: 48 89 95 18 ff ff ff mov %rdx,-0xe8(%rbp) ; | |
765 124: 48 8d 75 b0 lea -0x50(%rbp),%rsi ; | |
766 128: 8b bd 5c fe ff ff mov -0x1a4(%rbp),%edi ; | |
767 12e: 89 7d f4 mov %edi,-0xc(%rbp) ; | |
768 131: 44 8b 85 60 fe ff ff mov -0x1a0(%rbp),%r8d ; | |
769 138: 44 89 45 f0 mov %r8d,-0x10(%rbp) ; | |
770 13c: 44 8b 8d 64 fe ff ff mov -0x19c(%rbp),%r9d ; | |
771 143: 44 89 4d ec mov %r9d,-0x14(%rbp) ; | |
772 147: 49 89 f2 mov %rsi,%r10 ; | |
773 14a: 4c 8d 9d 00 ff ff ff lea -0x100(%rbp),%r11 ; | |
774 151: 4d 89 5a 10 mov %r11,0x10(%r10) ; | |
775 155: 4c 8d 5d 10 lea 0x10(%rbp),%r11 ; | |
776 159: 4d 89 5a 08 mov %r11,0x8(%r10) ; | |
777 15d: 41 c7 42 04 30 00 00 00 movl $0x30,0x4(%r10) ; | |
778 165: 41 c7 02 18 00 00 00 movl $0x18,(%r10) ; | |
779 16c: 8b 5d b0 mov -0x50(%rbp),%ebx ; | |
780 16f: 83 fb 28 cmp $0x28,%ebx ; | |
781 172: 48 89 b5 50 fe ff ff mov %rsi,-0x1b0(%rbp) ; | |
782 179: 89 9d 4c fe ff ff mov %ebx,-0x1b4(%rbp) ; | |
783 17f: 0f 87 25 00 00 00 ja 1aa <nonleaf_call+0x18a> ; | |
784 185: 8b 85 4c fe ff ff mov -0x1b4(%rbp),%eax ; | |
785 18b: 48 63 c8 movslq %eax,%rcx ; | |
786 18e: 48 8b 95 50 fe ff ff mov -0x1b0(%rbp),%rdx ; | |
787 195: 48 03 4a 10 add 0x10(%rdx),%rcx ; | |
788 199: 83 c0 08 add $0x8,%eax ; | |
789 19c: 89 02 mov %eax,(%rdx) ; | |
790 19e: 48 89 8d 40 fe ff ff mov %rcx,-0x1c0(%rbp) ; | |
791 1a5: e9 20 00 00 00 jmpq 1ca <nonleaf_call+0x1aa> ; | |
792 1aa: 48 8b 85 50 fe ff ff mov -0x1b0(%rbp),%rax ; | |
793 1b1: 48 8b 48 08 mov 0x8(%rax),%rcx ; | |
794 1b5: 48 89 ca mov %rcx,%rdx ; | |
795 1b8: 48 81 c1 08 00 00 00 add $0x8,%rcx ; | |
796 1bf: 48 89 48 08 mov %rcx,0x8(%rax) ; | |
797 1c3: 48 89 95 40 fe ff ff mov %rdx,-0x1c0(%rbp) ; | |
798 1ca: 48 8b 85 40 fe ff ff mov -0x1c0(%rbp),%rax ; | |
799 1d1: 48 8d 4d b0 lea -0x50(%rbp),%rcx ; | |
800 1d5: 8b 10 mov (%rax),%edx ; | |
801 1d7: 89 55 e8 mov %edx,-0x18(%rbp) ; | |
802 1da: 8b 55 b0 mov -0x50(%rbp),%edx ; | |
803 1dd: 83 fa 28 cmp $0x28,%edx ; | |
804 1e0: 48 89 8d 38 fe ff ff mov %rcx,-0x1c8(%rbp) ; | |
805 1e7: 89 95 34 fe ff ff mov %edx,-0x1cc(%rbp) ; | |
806 1ed: 0f 87 25 00 00 00 ja 218 <nonleaf_call+0x1f8> ; | |
807 1f3: 8b 85 34 fe ff ff mov -0x1cc(%rbp),%eax ; | |
808 1f9: 48 63 c8 movslq %eax,%rcx ; | |
809 1fc: 48 8b 95 38 fe ff ff mov -0x1c8(%rbp),%rdx ; | |
810 203: 48 03 4a 10 add 0x10(%rdx),%rcx ; | |
811 207: 83 c0 08 add $0x8,%eax ; | |
812 20a: 89 02 mov %eax,(%rdx) ; | |
813 20c: 48 89 8d 28 fe ff ff mov %rcx,-0x1d8(%rbp) ; | |
814 213: e9 20 00 00 00 jmpq 238 <nonleaf_call+0x218> ; | |
815 218: 48 8b 85 38 fe ff ff mov -0x1c8(%rbp),%rax ; | |
816 21f: 48 8b 48 08 mov 0x8(%rax),%rcx ; | |
817 223: 48 89 ca mov %rcx,%rdx ; | |
818 226: 48 81 c1 08 00 00 00 add $0x8,%rcx ; | |
819 22d: 48 89 48 08 mov %rcx,0x8(%rax) ; | |
820 231: 48 89 95 28 fe ff ff mov %rdx,-0x1d8(%rbp) ; | |
821 238: 48 8b 85 28 fe ff ff mov -0x1d8(%rbp),%rax ; | |
822 23f: 48 8d 4d b0 lea -0x50(%rbp),%rcx ; | |
823 243: 8b 10 mov (%rax),%edx ; | |
824 245: 89 55 e4 mov %edx,-0x1c(%rbp) ; | |
825 248: 8b 55 b0 mov -0x50(%rbp),%edx ; | |
826 24b: 83 fa 20 cmp $0x20,%edx ; | |
827 24e: 48 89 8d 20 fe ff ff mov %rcx,-0x1e0(%rbp) ; | |
828 255: 89 95 1c fe ff ff mov %edx,-0x1e4(%rbp) ; | |
829 25b: 0f 87 25 00 00 00 ja 286 <nonleaf_call+0x266> ; | |
830 261: 8b 85 1c fe ff ff mov -0x1e4(%rbp),%eax ; | |
831 267: 48 63 c8 movslq %eax,%rcx ; | |
832 26a: 48 8b 95 20 fe ff ff mov -0x1e0(%rbp),%rdx ; | |
833 271: 48 03 4a 10 add 0x10(%rdx),%rcx ; | |
834 275: 83 c0 10 add $0x10,%eax ; | |
835 278: 89 02 mov %eax,(%rdx) ; | |
836 27a: 48 89 8d 10 fe ff ff mov %rcx,-0x1f0(%rbp) ; | |
837 281: e9 20 00 00 00 jmpq 2a6 <nonleaf_call+0x286> ; | |
838 286: 48 8b 85 20 fe ff ff mov -0x1e0(%rbp),%rax ; | |
839 28d: 48 8b 48 08 mov 0x8(%rax),%rcx ; | |
840 291: 48 89 ca mov %rcx,%rdx ; | |
841 294: 48 81 c1 10 00 00 00 add $0x10,%rcx ; | |
842 29b: 48 89 48 08 mov %rcx,0x8(%rax) ; | |
843 29f: 48 89 95 10 fe ff ff mov %rdx,-0x1f0(%rbp) ; | |
844 2a6: 48 8b 85 10 fe ff ff mov -0x1f0(%rbp),%rax ; | |
845 2ad: 48 8d 4d b0 lea -0x50(%rbp),%rcx ; | |
846 2b1: 48 8b 10 mov (%rax),%rdx ; | |
847 2b4: 48 89 55 c8 mov %rdx,-0x38(%rbp) ; | |
848 2b8: 48 8b 40 08 mov 0x8(%rax),%rax ; | |
849 2bc: 48 89 45 d0 mov %rax,-0x30(%rbp) ; | |
850 2c0: 8b 75 b0 mov -0x50(%rbp),%esi ; | |
851 2c3: 83 fe 28 cmp $0x28,%esi ; | |
852 2c6: 48 89 8d 08 fe ff ff mov %rcx,-0x1f8(%rbp) ; | |
853 2cd: 89 b5 04 fe ff ff mov %esi,-0x1fc(%rbp) ; | |
854 2d3: 0f 87 25 00 00 00 ja 2fe <nonleaf_call+0x2de> ; | |
855 2d9: 8b 85 04 fe ff ff mov -0x1fc(%rbp),%eax ; | |
856 2df: 48 63 c8 movslq %eax,%rcx ; | |
857 2e2: 48 8b 95 08 fe ff ff mov -0x1f8(%rbp),%rdx ; | |
858 2e9: 48 03 4a 10 add 0x10(%rdx),%rcx ; | |
859 2ed: 83 c0 08 add $0x8,%eax ; | |
860 2f0: 89 02 mov %eax,(%rdx) ; | |
861 2f2: 48 89 8d f8 fd ff ff mov %rcx,-0x208(%rbp) ; | |
862 2f9: e9 20 00 00 00 jmpq 31e <nonleaf_call+0x2fe> ; | |
863 2fe: 48 8b 85 08 fe ff ff mov -0x1f8(%rbp),%rax ; | |
864 305: 48 8b 48 08 mov 0x8(%rax),%rcx ; | |
865 309: 48 89 ca mov %rcx,%rdx ; | |
866 30c: 48 81 c1 08 00 00 00 add $0x8,%rcx ; | |
867 313: 48 89 48 08 mov %rcx,0x8(%rax) ; | |
868 317: 48 89 95 f8 fd ff ff mov %rdx,-0x208(%rbp) ; | |
869 31e: 48 8b 85 f8 fd ff ff mov -0x208(%rbp),%rax ; | |
870 325: 48 8d 4d b0 lea -0x50(%rbp),%rcx ; | |
871 329: 8b 10 mov (%rax),%edx ; | |
872 32b: 89 55 e0 mov %edx,-0x20(%rbp) ; | |
873 32e: 8b 55 b0 mov -0x50(%rbp),%edx ; | |
874 331: 83 fa 28 cmp $0x28,%edx ; | |
875 334: 48 89 8d f0 fd ff ff mov %rcx,-0x210(%rbp) ; | |
876 33b: 89 95 ec fd ff ff mov %edx,-0x214(%rbp) ; | |
877 341: 0f 87 25 00 00 00 ja 36c <nonleaf_call+0x34c> ; | |
878 347: 8b 85 ec fd ff ff mov -0x214(%rbp),%eax ; | |
879 34d: 48 63 c8 movslq %eax,%rcx ; | |
880 350: 48 8b 95 f0 fd ff ff mov -0x210(%rbp),%rdx ; | |
881 357: 48 03 4a 10 add 0x10(%rdx),%rcx ; | |
882 35b: 83 c0 08 add $0x8,%eax ; | |
883 35e: 89 02 mov %eax,(%rdx) ; | |
884 360: 48 89 8d e0 fd ff ff mov %rcx,-0x220(%rbp) ; | |
885 367: e9 20 00 00 00 jmpq 38c <nonleaf_call+0x36c> ; | |
886 36c: 48 8b 85 f0 fd ff ff mov -0x210(%rbp),%rax ; | |
887 373: 48 8b 48 08 mov 0x8(%rax),%rcx ; | |
888 377: 48 89 ca mov %rcx,%rdx ; | |
889 37a: 48 81 c1 08 00 00 00 add $0x8,%rcx ; | |
890 381: 48 89 48 08 mov %rcx,0x8(%rax) ; | |
891 385: 48 89 95 e0 fd ff ff mov %rdx,-0x220(%rbp) ; | |
892 38c: 48 8b 85 e0 fd ff ff mov -0x220(%rbp),%rax ; | |
893 393: 8b 08 mov (%rax),%ecx ; | |
894 395: 89 4d dc mov %ecx,-0x24(%rbp) ; | |
895 398: 48 89 e0 mov %rsp,%rax ; | |
896 39b: 48 89 c2 mov %rax,%rdx ; | |
897 39e: 48 81 c2 20 ff ff ff add $0xffffffffffffff20,%rdx ; | |
898 3a5: 48 89 d4 mov %rdx,%rsp ; | |
899 3a8: c6 80 20 ff ff ff 4c movb $0x4c,-0xe0(%rax) ; 'L' -> local area (of alloca()'d space) | |
900 3af: 8b 7d f0 mov -0x10(%rbp),%edi ; arg 0 | |
901 3b2: 8b 75 ec mov -0x14(%rbp),%esi ; arg 1 | |
902 3b5: 8b 55 e8 mov -0x18(%rbp),%edx ; arg 2 | |
903 3b8: 8b 4d e4 mov -0x1c(%rbp),%ecx ; arg 3 | |
904 3bb: 44 8b 45 e0 mov -0x20(%rbp),%r8d ; in arg 5 (local copy) -> r8 pointless, free regs available and using arg reg as temporary, needs freeing below | |
905 3bf: 44 8b 4d dc mov -0x24(%rbp),%r9d ; in arg 6 (stack) -> r9 pointless, free regs available and using arg reg as temporary, needs freeing below | |
906 3c3: 48 8b 45 c8 mov -0x38(%rbp),%rax ; in arg 4 (A.i, A.j) -> hold in scratch reg | |
907 3c7: 4c 8b 55 d0 mov -0x30(%rbp),%r10 ; in arg 4 (A.l) -> hold in scratch reg | |
908 3cb: 48 83 ec 10 sub $0x10,%rsp ; | stack space to pass arg 5 and 6, access ptr in r11 | |
909 3cf: 49 89 e3 mov %rsp,%r11 ; | | |
910 3d2: 45 89 4b 08 mov %r9d,0x8(%r11) ; 'push' arg 5, 'frees' r9 implicitly | |
911 3d6: 45 89 03 mov %r8d,(%r11) ; 'push' arg 6, 'frees' r8 implicitly | |
912 3d9: 45 31 c0 xor %r8d,%r8d ; | | |
913 3dc: 44 88 85 df fd ff ff mov %r8b,-0x221(%rbp) ; | number of used xmm registers (0) -> temp store (see below) | |
914 3e3: 49 89 c0 mov %rax,%r8 ; arg 4 (A.i, A.j) | | |
915 3e6: 4d 89 d1 mov %r10,%r9 ; arg 4 (A.l) | struct passed in regs, regardless of it being a vararg | |
916 3e9: 8a 85 df fd ff ff mov -0x221(%rbp),%al ; number of used xmm registers (upper bound, req for varargs) | |
917 3ef: e8 00 00 00 00 callq 3f4 <nonleaf_call+0x3d4> ; push return addr and call | |
918 3f4: 48 8d 65 f8 lea -0x8(%rbp),%rsp ; | | |
919 3f8: 5b pop %rbx ; | | |
920 3f9: 5d pop %rbp ; | epilog | |
921 3fa: c3 retq ; | | |
922 3fb: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1) ; garbage data | |
923 | |
924 0000000000000400 <main>: | |
925 400: 55 push %rbp ; | | |
926 401: 48 89 e5 mov %rsp,%rbp ; | prolog | |
927 404: 48 83 ec 30 sub $0x30,%rsp ; | | |
928 408: 31 ff xor %edi,%edi ; arg 0 | |
929 40a: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp) ; unsure... write 0 to local area @@@? | |
930 411: c7 45 e8 05 00 00 00 movl $0x5,-0x18(%rbp) ; | field i | |
931 418: c7 45 ec 06 00 00 00 movl $0x6,-0x14(%rbp) ; | fill struct A (local area) field j | |
932 41f: 48 c7 45 f0 07 00 00 00 movq $0x7,-0x10(%rbp) ; | field l | |
933 427: be 01 00 00 00 mov $0x1,%esi ; arg 1 | |
934 42c: ba 02 00 00 00 mov $0x2,%edx ; arg 2 | |
935 431: b9 03 00 00 00 mov $0x3,%ecx ; arg 3 | |
936 436: 41 b8 04 00 00 00 mov $0x4,%r8d ; arg 4 | |
937 43c: 48 8d 45 e8 lea -0x18(%rbp),%rax ; | | |
938 440: 4c 8b 08 mov (%rax),%r9 ; | | |
939 443: 4c 89 0c 24 mov %r9,(%rsp) ; | arg 5 (struct, pushed onto stack, as not enough regs) | |
940 447: 48 8b 40 08 mov 0x8(%rax),%rax ; | | |
941 44b: 48 89 44 24 08 mov %rax,0x8(%rsp) ; | | |
942 450: 41 b9 08 00 00 00 mov $0x8,%r9d ; arg 6 (in reg) | |
943 456: c7 44 24 10 09 00 00 00 movl $0x9,0x10(%rsp) ; arg 7 (pushed) | |
944 45e: b0 00 mov $0x0,%al ; number of used xmm registers (upper bound, req for varargs) | |
945 460: e8 00 00 00 00 callq 465 <main+0x65> ; push return addr and call | |
946 465: 31 c0 xor %eax,%eax ; return value | |
947 467: 48 83 c4 30 add $0x30,%rsp ; | | |
948 46b: 5d pop %rbp ; | epilog | |
949 46c: c3 retq ; | | |
950 | |
951 | |
952 | |
327
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
953 ; vim: ft=asm |
c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
Tassilo Philipp
parents:
diff
changeset
|
954 |