 8048548:       55                      push   %ebp
 8048549:       89 e5                   mov    %esp,%ebp

 804854b:       83 ec 08                sub    $0x8,%esp

^^ point of this?
^^ my guess is some sort of whacky alignment, but i see no point here.

 804854e:       8b 45 08                mov    0x8(%ebp),%eax

^^ base pointer

 8048551:       83 c4 f8                add    $0xfffffff8,%esp
 8048554:       ff 70 04                pushl  0x4(%eax)

push directly from our base pointer.
this doesnt always happen with gcc.

 8048557:       68 e8 85 04 08          push   $0x80485e8
 804855c:       e8 4b fe ff ff          call   80483ac <_init+0x80>
 8048561:       31 c0                   xor    %eax,%eax
 8048563:       c9                      leave
 8048564:       c3                      ret
 8048565:       90                      nop

^^ this is with -O6 --noinline  (-O6 is mostly pointless, but just to be
sure to get full optimisation)

---

 80484b0:       55                      push   %ebp
 80484b1:       89 e5                   mov    %esp,%ebp

^^ function prologue

 80484b3:       83 ec 08                sub    $0x8,%esp

^^ local var

 80484b6:       83 c4 f8                add    $0xfffffff8,%esp

^^ stack alignment for call

 80484b9:       8b 45 08                mov    0x8(%ebp),%eax

^^ load base pointer

 80484bc:       8b 50 04                mov    0x4(%eax),%edx
 80484bf:       52                      push   %edx

^^ peekhole optimisation can catch this also.
^^ we have 2 ops here.. access structure, followed by use in proc arg.

 80484c0:       68 28 86 04 08          push   $0x8048628

^^ argz for printf()
^^ 0x8048628 is format string in text segment (rodata)

 80484c5:       e8 f2 fe ff ff          call   80483bc <_init+0x90>
 80484ca:       83 c4 10                add    $0x10,%esp

^^ call + stack correction

 80484cd:       31 c0                   xor    %eax,%eax

^^ retval = 0

 80484cf:       eb 00                   jmp    80484d1 <process+0x21>
 80484d1:       c9                      leave

^^ peekhole optimisation can easily catch this in a binary.
eb 00 is a scanstring :)

 80484d2:       c3                      ret

^^^^ without any optimisation

