Mercurial > pub > dyncall > dyncall
diff doc/disas_examples/x86.cdecl.disas @ 327:c0390dc85a07
- doc: added disassembly examples for many platforms and calling conventions, for reference
| author | Tassilo Philipp |
|---|---|
| date | Fri, 22 Nov 2019 23:08:59 +0100 |
| parents | |
| children | 984e6652b975 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/doc/disas_examples/x86.cdecl.disas Fri Nov 22 23:08:59 2019 +0100 @@ -0,0 +1,490 @@ +; #include <stdlib.h> +; +; void leaf_call(int b, int c, int d, int e, int f, int g, int h) +; { +; } +; +; void nonleaf_call(int a, int b, int c, int d, int e, int f, int g, int h) +; { +; /* use some local data */ +; *(char*)alloca(220) = 'L'; +; leaf_call(b, c, d, e, f, g, h); +; } +; +; int main() +; { +; nonleaf_call(0, 1, 2, 3, 4, 5, 6, 7); +; return 0; +; } + + + +; output from arch_linux-2011.08.19-x86 w/ gcc 4.6.1 + +00000000 <leaf_call>: + 0: 55 push %ebp + 1: 89 e5 mov %esp,%ebp + 3: 5d pop %ebp + 4: c3 ret + +00000005 <nonleaf_call>: + 5: 55 push %ebp ; | + 6: 89 e5 mov %esp,%ebp ; | prolog + 8: 83 ec 38 sub $0x38,%esp ; / + b: b8 10 00 00 00 mov $0x10,%eax ; \ | + 10: 83 e8 01 sub $0x1,%eax ; | | creative way to move 250 to eax + 13: 05 eb 00 00 00 add $0xeb,%eax ; | / + 18: c7 45 f4 10 00 00 00 movl $0x10,-0xc(%ebp) ; | size comp wtf? \ + 1f: ba 00 00 00 00 mov $0x0,%edx ; | | + 24: f7 75 f4 divl -0xc(%ebp) ; | | obviously fastest way to round to multiple of 16 + 27: 6b c0 10 imul $0x10,%eax,%eax ; | | + 2a: 29 c4 sub %eax,%esp ; alloca(220) with size containing some padding computed above + 2c: 8d 44 24 1c lea 0x1c(%esp),%eax ; | + 30: 83 c0 0f add $0xf,%eax ; | start of alloca()'d memory -> eax, by ... + 33: c1 e8 04 shr $0x4,%eax ; | ... using ebx and 2 pointless store/reads in local space as helper to align to 16b + 36: c1 e0 04 shl $0x4,%eax ; | + 39: c6 00 4c movb $0x4c,(%eax) ; 'L' -> alloca()'d space + 3c: 8b 45 24 mov 0x24(%ebp),%eax ; | + 3f: 89 44 24 18 mov %eax,0x18(%esp) ; | + 43: 8b 45 20 mov 0x20(%ebp),%eax ; | + 46: 89 44 24 14 mov %eax,0x14(%esp) ; | + 4a: 8b 45 1c mov 0x1c(%ebp),%eax ; | + 4d: 89 44 24 10 mov %eax,0x10(%esp) ; | + 51: 8b 45 18 mov 0x18(%ebp),%eax ; | read in args 1-7 from prev frame's param area, and ... + 54: 89 44 24 0c mov %eax,0xc(%esp) ; | ... "push" onto stack as arg 0-6 + 58: 8b 45 14 mov 0x14(%ebp),%eax ; | + 5b: 89 44 24 08 mov %eax,0x8(%esp) ; | + 5f: 8b 45 10 mov 0x10(%ebp),%eax ; | + 62: 89 44 24 04 mov %eax,0x4(%esp) ; | + 66: 8b 45 0c mov 0xc(%ebp),%eax ; | + 69: 89 04 24 mov %eax,(%esp) ; | + 6c: e8 fc ff ff ff call 6d <nonleaf_call+0x68> ; push return address and call leaf_call (objdump not from final link but .o) + 71: c9 leave ; | + 72: c3 ret ; | epilog + +00000073 <main>: + 73: 55 push %ebp ; | + 74: 89 e5 mov %esp,%ebp ; | + 76: 83 e4 f0 and $0xfffffff0,%esp ; | prolog + 79: 83 ec 20 sub $0x20,%esp ; | + 7c: c7 44 24 1c 07 00 00 00 movl $0x7,0x1c(%esp) ; arg 7 -> stack + 84: c7 44 24 18 06 00 00 00 movl $0x6,0x18(%esp) ; arg 6 -> stack + 8c: c7 44 24 14 05 00 00 00 movl $0x5,0x14(%esp) ; arg 5 -> stack + 94: c7 44 24 10 04 00 00 00 movl $0x4,0x10(%esp) ; arg 4 -> stack + 9c: c7 44 24 0c 03 00 00 00 movl $0x3,0xc(%esp) ; arg 3 -> stack + a4: c7 44 24 08 02 00 00 00 movl $0x2,0x8(%esp) ; arg 2 -> stack + ac: c7 44 24 04 01 00 00 00 movl $0x1,0x4(%esp) ; arg 1 -> stack + b4: c7 04 24 00 00 00 00 movl $0x0,(%esp) ; arg 0 -> stack + bb: e8 fc ff ff ff call bc <main+0x49> ; push return address and call nonleaf_call (objdump not from final link but .o) + c0: b8 00 00 00 00 mov $0x0,%eax ; return value + c5: c9 leave ; | + c6: c3 ret ; | epilog + + + +; output from darwin-8.0.1-x86 w/ gcc 3.3 + +_leaf_call: + 0: 55 pushl %ebp + 1: 89 e5 movl %esp, %ebp + 3: 83 ec 08 subl $8, %esp + 6: c9 leave + 7: c3 retl + +_nonleaf_call: + 8: 55 pushl %ebp ; | + 9: 89 e5 movl %esp, %ebp ; | prolog + b: 83 ec 28 subl $40, %esp ; | + e: 81 ec e0 00 00 00 subl $224, %esp ; alloca(220) - with 4b padding + 14: 8d 44 24 20 leal 32(%esp), %eax ; | + 18: c6 00 4c movb $76, (%eax) ; / 'L' -> alloca()'d space + 1b: 8b 45 24 movl 36(%ebp), %eax ; \ + 1e: 89 44 24 18 movl %eax, 24(%esp) ; | + 22: 8b 45 20 movl 32(%ebp), %eax ; | + 25: 89 44 24 14 movl %eax, 20(%esp) ; | + 29: 8b 45 1c movl 28(%ebp), %eax ; | + 2c: 89 44 24 10 movl %eax, 16(%esp) ; | + 30: 8b 45 18 movl 24(%ebp), %eax ; | read in args 1-7 from prev frame's param area, and ... + 33: 89 44 24 0c movl %eax, 12(%esp) ; | ... "push" onto stack as arg 0-6 + 37: 8b 45 14 movl 20(%ebp), %eax ; | + 3a: 89 44 24 08 movl %eax, 8(%esp) ; | + 3e: 8b 45 10 movl 16(%ebp), %eax ; | + 41: 89 44 24 04 movl %eax, 4(%esp) ; | + 45: 8b 45 0c movl 12(%ebp), %eax ; | + 48: 89 04 24 movl %eax, (%esp) ; | + 4b: e8 b0 ff ff ff calll -80 <_leaf_call> ; push return address and call + 50: c9 leave ; | + 51: c3 retl ; | epilog + 52: 90 nop ; + 53: 90 nop ; + +_main: + 54: 55 pushl %ebp ; | + 55: 89 e5 movl %esp, %ebp ; | prolog + 57: 83 ec 28 subl $40, %esp ; | + 5a: c7 44 24 1c 07 00 00 00 movl $7, 28(%esp) ; arg 7 -> stack + 62: c7 44 24 18 06 00 00 00 movl $6, 24(%esp) ; arg 6 -> stack + 6a: c7 44 24 14 05 00 00 00 movl $5, 20(%esp) ; arg 5 -> stack + 72: c7 44 24 10 04 00 00 00 movl $4, 16(%esp) ; arg 4 -> stack + 7a: c7 44 24 0c 03 00 00 00 movl $3, 12(%esp) ; arg 3 -> stack + 82: c7 44 24 08 02 00 00 00 movl $2, 8(%esp) ; arg 2 -> stack + 8a: c7 44 24 04 01 00 00 00 movl $1, 4(%esp) ; arg 1 -> stack + 92: c7 04 24 00 00 00 00 movl $0, (%esp) ; arg 0 -> stack + 99: e8 6a ff ff ff calll -150 <_nonleaf_call> ; push return address and call + 9e: b8 00 00 00 00 movl $0, %eax ; return value + a3: c9 leave ; | + a4: c3 retl ; | epilog + + + +; output from freebsd-9.3-x86 w/ gcc 4.2.1 + +00000000 <leaf_call>: + 0: 55 push %ebp + 1: 89 e5 mov %esp,%ebp + 3: 5d pop %ebp + 4: c3 ret + 5: 8d 74 26 00 lea 0x0(%esi),%esi + 9: 8d bc 27 00 00 00 00 lea 0x0(%edi),%edi + +00000010 <nonleaf_call>: + 10: 55 push %ebp ; | + 11: 89 e5 mov %esp,%ebp ; | prolog + 13: 83 ec 28 sub $0x28,%esp ; | + 16: 81 ec f0 00 00 00 sub $0xf0,%esp ; alloca(220) - with padding for 16b alignment + 1c: 8d 44 24 1c lea 0x1c(%esp),%eax ; | + 20: 89 45 fc mov %eax,-0x4(%ebp) ; | + 23: 8b 45 fc mov -0x4(%ebp),%eax ; | + 26: 83 c0 0f add $0xf,%eax ; | start of alloca()'d memory -> eax, by ... + 29: c1 e8 04 shr $0x4,%eax ; | ... using ebx and 2 pointless store/reads in local space as helper to align to 16b + 2c: c1 e0 04 shl $0x4,%eax ; | + 2f: 89 45 fc mov %eax,-0x4(%ebp) ; | + 32: 8b 45 fc mov -0x4(%ebp),%eax ; | + 35: c6 00 4c movb $0x4c,(%eax) ; 'L' -> alloca()'d space + 38: 8b 45 24 mov 0x24(%ebp),%eax ; | + 3b: 89 44 24 18 mov %eax,0x18(%esp) ; | + 3f: 8b 45 20 mov 0x20(%ebp),%eax ; | + 42: 89 44 24 14 mov %eax,0x14(%esp) ; | + 46: 8b 45 1c mov 0x1c(%ebp),%eax ; | + 49: 89 44 24 10 mov %eax,0x10(%esp) ; | + 4d: 8b 45 18 mov 0x18(%ebp),%eax ; | read in args 1-7 from prev frame's param area, and ... + 50: 89 44 24 0c mov %eax,0xc(%esp) ; | ... "push" onto stack as arg 0-6 + 54: 8b 45 14 mov 0x14(%ebp),%eax ; | + 57: 89 44 24 08 mov %eax,0x8(%esp) ; | + 5b: 8b 45 10 mov 0x10(%ebp),%eax ; | + 5e: 89 44 24 04 mov %eax,0x4(%esp) ; | + 62: 8b 45 0c mov 0xc(%ebp),%eax ; | + 65: 89 04 24 mov %eax,(%esp) ; | + 68: e8 fc ff ff ff call 69 <nonleaf_call+0x59> ; push return address and call leaf_call (objdump not from final link but .o) + 6d: c9 leave ; | + 6e: c3 ret ; | epilog + 6f: 90 nop ; + +00000070 <main>: + 70: 8d 4c 24 04 lea 0x4(%esp),%ecx ; | + 74: 83 e4 f0 and $0xfffffff0,%esp ; | + 77: ff 71 fc pushl -0x4(%ecx) ; | + 7a: 55 push %ebp ; | prolog + 7b: 89 e5 mov %esp,%ebp ; | + 7d: 51 push %ecx ; | + 7e: 83 ec 24 sub $0x24,%esp ; | + 81: c7 44 24 1c 07 00 00 00 movl $0x7,0x1c(%esp) ; arg 7 -> stack + 89: c7 44 24 18 06 00 00 00 movl $0x6,0x18(%esp) ; arg 6 -> stack + 91: c7 44 24 14 05 00 00 00 movl $0x5,0x14(%esp) ; arg 5 -> stack + 99: c7 44 24 10 04 00 00 00 movl $0x4,0x10(%esp) ; arg 4 -> stack + a1: c7 44 24 0c 03 00 00 00 movl $0x3,0xc(%esp) ; arg 3 -> stack + a9: c7 44 24 08 02 00 00 00 movl $0x2,0x8(%esp) ; arg 2 -> stack + b1: c7 44 24 04 01 00 00 00 movl $0x1,0x4(%esp) ; arg 1 -> stack + b9: c7 04 24 00 00 00 00 movl $0x0,(%esp) ; arg 0 -> stack + c0: e8 fc ff ff ff call c1 <main+0x51> ; push return address and call leaf_call (objdump not from final link but .o) + c5: b8 00 00 00 00 mov $0x0,%eax ; return value + ca: 83 c4 24 add $0x24,%esp ; | + cd: 59 pop %ecx ; | + ce: 5d pop %ebp ; | epilog + cf: 8d 61 fc lea -0x4(%ecx),%esp ; | + d2: c3 ret ; | + + + +; output from gentoo_linux-20191029-x86 w/ gcc 8.3.0 + +00000000 <leaf_call>: + 0: 55 push %ebp + 1: 89 e5 mov %esp,%ebp + 3: e8 fc ff ff ff call 4 <leaf_call+0x4> + 8: 05 01 00 00 00 add $0x1,%eax + d: 90 nop + e: 5d pop %ebp + f: c3 ret + +00000010 <nonleaf_call>: + 10: 55 push %ebp + 11: 89 e5 mov %esp,%ebp + 13: 83 ec 18 sub $0x18,%esp + 16: e8 fc ff ff ff call 17 <nonleaf_call+0x7> + 1b: 05 01 00 00 00 add $0x1,%eax + 20: 65 a1 14 00 00 00 mov %gs:0x14,%eax + 26: 89 45 f4 mov %eax,-0xc(%ebp) + 29: 31 c0 xor %eax,%eax + 2b: b8 10 00 00 00 mov $0x10,%eax + 30: 48 dec %eax + 31: 05 e8 00 00 00 add $0xe8,%eax + 36: b9 10 00 00 00 mov $0x10,%ecx + 3b: ba 00 00 00 00 mov $0x0,%edx + 40: f7 f1 div %ecx + 42: 6b c0 10 imul $0x10,%eax,%eax + 45: 29 c4 sub %eax,%esp + 47: 89 e0 mov %esp,%eax + 49: 83 c0 0f add $0xf,%eax + 4c: c1 e8 04 shr $0x4,%eax + 4f: c1 e0 04 shl $0x4,%eax + 52: c6 00 4c movb $0x4c,(%eax) + 55: 83 ec 04 sub $0x4,%esp + 58: ff 75 24 pushl 0x24(%ebp) + 5b: ff 75 20 pushl 0x20(%ebp) + 5e: ff 75 1c pushl 0x1c(%ebp) + 61: ff 75 18 pushl 0x18(%ebp) + 64: ff 75 14 pushl 0x14(%ebp) + 67: ff 75 10 pushl 0x10(%ebp) + 6a: ff 75 0c pushl 0xc(%ebp) + 6d: e8 fc ff ff ff call 6e <nonleaf_call+0x5e> + 72: 83 c4 20 add $0x20,%esp + 75: 90 nop + 76: 8b 45 f4 mov -0xc(%ebp),%eax + 79: 65 33 05 14 00 00 00 xor %gs:0x14,%eax + 80: 74 05 je 87 <nonleaf_call+0x77> + 82: e8 fc ff ff ff call 83 <nonleaf_call+0x73> + 87: c9 leave + 88: c3 ret + +00000089 <main>: + 89: 8d 4c 24 04 lea 0x4(%esp),%ecx ; | + 8d: 83 e4 f0 and $0xfffffff0,%esp ; | + 90: ff 71 fc pushl -0x4(%ecx) ; | + 93: 55 push %ebp ; | + 94: 89 e5 mov %esp,%ebp ; | prolog (with some stack protection check call, I think) + 96: 51 push %ecx ; | + 97: 83 ec 04 sub $0x4,%esp ; | + 9a: e8 fc ff ff ff call 9b <main+0x12> ; | unsure@@@ call of stackguard stuff, maybe?. (objdump not from final link but .o) + 9f: 05 01 00 00 00 add $0x1,%eax ; | ??? add 1 to ret val from unknown call + a4: 6a 07 push $0x7 ; arg 7 -> stack + a6: 6a 06 push $0x6 ; arg 6 -> stack + a8: 6a 05 push $0x5 ; arg 5 -> stack + aa: 6a 04 push $0x4 ; arg 4 -> stack + ac: 6a 03 push $0x3 ; arg 3 -> stack + ae: 6a 02 push $0x2 ; arg 2 -> stack + b0: 6a 01 push $0x1 ; arg 1 -> stack + b2: 6a 00 push $0x0 ; arg 0 -> stack + b4: e8 fc ff ff ff call b5 <main+0x2c> ; push return address and call nonleaf_call (objdump not from final link but .o) + b9: 83 c4 20 add $0x20,%esp ; ??? + bc: b8 00 00 00 00 mov $0x0,%eax ; return value + c1: 8b 4d fc mov -0x4(%ebp),%ecx ; | ??? + c4: c9 leave ; | + c5: 8d 61 fc lea -0x4(%ecx),%esp ; | epilog ??? + c8: c3 ret ; | + + + +; output from haiku w/ gcc 4.4.4 + +00000000 <leaf_call>: + 0: 55 push %ebp + 1: 89 e5 mov %esp,%ebp + 3: 5d pop %ebp + 4: c3 ret + +00000005 <nonleaf_call>: + 5: 55 push %ebp + 6: 89 e5 mov %esp,%ebp + 8: 53 push %ebx + 9: 83 ec 04 sub $0x4,%esp + c: e8 00 00 00 00 call 11 <nonleaf_call+0xc> + 11: 5b pop %ebx + 12: 81 c3 03 00 00 00 add $0x3,%ebx + 18: 81 ec f0 00 00 00 sub $0xf0,%esp + 1e: 89 e0 mov %esp,%eax + 20: 83 c0 0f add $0xf,%eax + 23: c1 e8 04 shr $0x4,%eax + 26: c1 e0 04 shl $0x4,%eax + 29: c6 00 4c movb $0x4c,(%eax) + 2c: 83 ec 04 sub $0x4,%esp + 2f: ff 75 24 pushl 0x24(%ebp) + 32: ff 75 20 pushl 0x20(%ebp) + 35: ff 75 1c pushl 0x1c(%ebp) + 38: ff 75 18 pushl 0x18(%ebp) + 3b: ff 75 14 pushl 0x14(%ebp) + 3e: ff 75 10 pushl 0x10(%ebp) + 41: ff 75 0c pushl 0xc(%ebp) + 44: e8 fc ff ff ff call 45 <nonleaf_call+0x40> + 49: 83 c4 20 add $0x20,%esp + 4c: 8b 5d fc mov -0x4(%ebp),%ebx + 4f: c9 leave + 50: c3 ret + +00000051 <main>: + 51: 8d 4c 24 04 lea 0x4(%esp),%ecx + 55: 83 e4 f0 and $0xfffffff0,%esp + 58: ff 71 fc pushl -0x4(%ecx) + 5b: 55 push %ebp + 5c: 89 e5 mov %esp,%ebp + 5e: 53 push %ebx + 5f: 51 push %ecx + 60: e8 00 00 00 00 call 65 <main+0x14> + 65: 5b pop %ebx + 66: 81 c3 03 00 00 00 add $0x3,%ebx + 6c: 6a 07 push $0x7 + 6e: 6a 06 push $0x6 + 70: 6a 05 push $0x5 + 72: 6a 04 push $0x4 + 74: 6a 03 push $0x3 + 76: 6a 02 push $0x2 + 78: 6a 01 push $0x1 + 7a: 6a 00 push $0x0 + 7c: e8 fc ff ff ff call 7d <main+0x2c> + 81: 83 c4 20 add $0x20,%esp + 84: b8 00 00 00 00 mov $0x0,%eax + 89: 8d 65 f8 lea -0x8(%ebp),%esp + 8c: 83 c4 00 add $0x0,%esp + 8f: 59 pop %ecx + 90: 5b pop %ebx + 91: 5d pop %ebp + 92: 8d 61 fc lea -0x4(%ecx),%esp + 95: c3 ret + + + +; output from nexenta-1.0.1-b85-x86 w/ gcc 4.0.3 + +00000000 <leaf_call>: + 0: 55 push %ebp + 1: 89 e5 mov %esp,%ebp + 3: c9 leave + 4: c3 ret + +00000005 <nonleaf_call>: + 5: 55 push %ebp + 6: 89 e5 mov %esp,%ebp + 8: 83 ec 08 sub $0x8,%esp + b: 81 ec f0 00 00 00 sub $0xf0,%esp + 11: 89 65 fc mov %esp,0xfffffffc(%ebp) + 14: 8b 45 fc mov 0xfffffffc(%ebp),%eax + 17: 83 c0 0f add $0xf,%eax + 1a: c1 e8 04 shr $0x4,%eax + 1d: c1 e0 04 shl $0x4,%eax + 20: 89 45 fc mov %eax,0xfffffffc(%ebp) + 23: 8b 45 fc mov 0xfffffffc(%ebp),%eax + 26: c6 00 4c movb $0x4c,(%eax) + 29: ff 75 24 pushl 0x24(%ebp) + 2c: ff 75 20 pushl 0x20(%ebp) + 2f: ff 75 1c pushl 0x1c(%ebp) + 32: ff 75 18 pushl 0x18(%ebp) + 35: ff 75 14 pushl 0x14(%ebp) + 38: ff 75 10 pushl 0x10(%ebp) + 3b: ff 75 0c pushl 0xc(%ebp) + 3e: e8 fc ff ff ff call 3f <nonleaf_call+0x3a> + 43: 83 c4 1c add $0x1c,%esp + 46: c9 leave + 47: c3 ret + +00000048 <main>: + 48: 55 push %ebp + 49: 89 e5 mov %esp,%ebp + 4b: 83 ec 08 sub $0x8,%esp + 4e: 83 e4 f0 and $0xfffffff0,%esp + 51: b8 00 00 00 00 mov $0x0,%eax + 56: 83 c0 0f add $0xf,%eax + 59: 83 c0 0f add $0xf,%eax + 5c: c1 e8 04 shr $0x4,%eax + 5f: c1 e0 04 shl $0x4,%eax + 62: 29 c4 sub %eax,%esp + 64: 6a 07 push $0x7 + 66: 6a 06 push $0x6 + 68: 6a 05 push $0x5 + 6a: 6a 04 push $0x4 + 6c: 6a 03 push $0x3 + 6e: 6a 02 push $0x2 + 70: 6a 01 push $0x1 + 72: 6a 00 push $0x0 + 74: e8 fc ff ff ff call 75 <main+0x2d> + 79: 83 c4 20 add $0x20,%esp + 7c: b8 00 00 00 00 mov $0x0,%eax + 81: c9 leave + 82: c3 ret + + + +; output from openbsd-4.0-x86 w/ gcc 3.3.5 (propolice) + +00000000 <leaf_call>: + 0: 55 push %ebp + 1: 89 e5 mov %esp,%ebp + 3: c9 leave + 4: c3 ret + +00000005 <nonleaf_call>: + 5: 55 push %ebp + 6: 89 e5 mov %esp,%ebp + 8: 83 ec 18 sub $0x18,%esp + b: a1 00 00 00 00 mov 0x0,%eax + 10: 89 45 e8 mov %eax,0xffffffe8(%ebp) + 13: 81 ec e0 00 00 00 sub $0xe0,%esp + 19: 89 e0 mov %esp,%eax + 1b: c6 00 4c movb $0x4c,(%eax) + 1e: 83 ec 04 sub $0x4,%esp + 21: ff 75 24 pushl 0x24(%ebp) + 24: ff 75 20 pushl 0x20(%ebp) + 27: ff 75 1c pushl 0x1c(%ebp) + 2a: ff 75 18 pushl 0x18(%ebp) + 2d: ff 75 14 pushl 0x14(%ebp) + 30: ff 75 10 pushl 0x10(%ebp) + 33: ff 75 0c pushl 0xc(%ebp) + 36: e8 fc ff ff ff call 37 <nonleaf_call+0x32> + 3b: 83 c4 20 add $0x20,%esp + 3e: 8b 45 e8 mov 0xffffffe8(%ebp),%eax + 41: 3b 05 00 00 00 00 cmp 0x0,%eax + 47: 74 13 je 5c <nonleaf_call+0x57> + 49: 83 ec 08 sub $0x8,%esp + 4c: ff 75 e8 pushl 0xffffffe8(%ebp) + 4f: 68 00 00 00 00 push $0x0 + 54: e8 fc ff ff ff call 55 <nonleaf_call+0x50> + 59: 83 c4 10 add $0x10,%esp + 5c: c9 leave + 5d: c3 ret + +0000005e <main>: + 5e: 55 push %ebp + 5f: 89 e5 mov %esp,%ebp + 61: 83 ec 18 sub $0x18,%esp + 64: 83 e4 f0 and $0xfffffff0,%esp + 67: b8 00 00 00 00 mov $0x0,%eax + 6c: 29 c4 sub %eax,%esp + 6e: a1 00 00 00 00 mov 0x0,%eax + 73: 89 45 e8 mov %eax,0xffffffe8(%ebp) + 76: 6a 07 push $0x7 + 78: 6a 06 push $0x6 + 7a: 6a 05 push $0x5 + 7c: 6a 04 push $0x4 + 7e: 6a 03 push $0x3 + 80: 6a 02 push $0x2 + 82: 6a 01 push $0x1 + 84: 6a 00 push $0x0 + 86: e8 fc ff ff ff call 87 <main+0x29> + 8b: 83 c4 20 add $0x20,%esp + 8e: b8 00 00 00 00 mov $0x0,%eax + 93: 8b 55 e8 mov 0xffffffe8(%ebp),%edx + 96: 3b 15 00 00 00 00 cmp 0x0,%edx + 9c: 74 13 je b1 <main+0x53> + 9e: 83 ec 08 sub $0x8,%esp + a1: ff 75 e8 pushl 0xffffffe8(%ebp) + a4: 68 0d 00 00 00 push $0xd + a9: e8 fc ff ff ff call aa <main+0x4c> + ae: 83 c4 10 add $0x10,%esp + b1: c9 leave + b2: c3 ret + + + +; @@@ windows missing + +; vim: ft=asm +