C-Code-Fragmente aus Assembler rekonstruieren

Hallo,

ich hab hier Assemblercode und den dazugehörigen C-Code, in dem Fragmente fehlen. Diese sollten sich ja aus dem Assembler erschließen lassen, aber ich hab da wohl den falschen Ansatz.
(der Assemblercode wurde mit gcc -S -O3 foo.c erzeugt)

0:   push   %ebp
1:   mov    %esp,%ebp
3:   push   %ebx
4:   mov    0x8(%ebp),%eax
7:   mov    0xc(%ebp),%ecx
a:   lea    (%eax,%eax,4),%eax
d:   lea    0x4(%ecx,%eax,4),%eax
11: mov     (%eax),%edx
13: shl     $0x2,%edx
16: mov     0xb8(%ecx),%ebx
1c: add     (%ecx),%ebx
1e: mov     %ebx,0x4(%edx,%eax,1)
22: pop     %ebx
23: mov     %ebp,%esp
25: pop     %ebp
26: ret

typedef struct {
        int left;
        a_struct a[LEN];
        int right;
} b_struct;

void foo(int i, b_struct *bp) {
        int n = bp->left + bp->right;
        a_struct *ap = &bp->a[i];
        ap->x[ap->idx] = n;
}

Der Wert von LEN und der Aufbau des structs a_struct gilt es herauszufinden.

Meine Ahname war folgendes, aber das weicht nach der Assemblercodeerzeugung stark von der Vorgabe ab:

#define LEN 2

typedef struct
{
  int x;
  int idx[LEN];
} a_struct;

Wie ist der korrekte C-Code dazu?

Danke!

hi,

// pseudo-code
         eax = arg1
         ecx = arg2
         eax = ecx+(eax*20)+4       // a_struct *ap = &bp->a[i];       --> sizeof(a_struct) = 20
         edx = [eax]*4              // idx = a.index*4
         ebx = [ecx+180+4]+[ecx]    // int n = bp->left + bp->right;   --> LEN=180
 [edx+eax+4] = ebx                  // ap->x[ap->idx] = n;

//mein Vorschlag:
typedef struct { 
        int left; 
        a_struct a[9]; 
        int right; 
} b_struct; 

typedef struct { 
    int idx;     // index in x (0...3)
    int x[4];
}a_struct;

Danke, das ist schon näher an der Vorlage:

push   %ebp
mov    %esp,%ebp
mov    0xc(%ebp),%ecx
mov    0x8(%ebp),%eax
mov    0xb8(%ecx),%edx
lea    (%eax,%eax,4),%eax
add    0x4(%ecx,%eax,4),%eax
add    (%ecx),%edx
mov    %edx,0x8(%ecx,%eax,4)
pop    %ebp
ret

Inwieweit liefert der gcc bzw. objdump eigentlich unter verschiedenen (Unix-)Systemen vergleichbare oder identische Ergebnisse?

In diesem Fall hat das nix mit dem Betriebssystem zu tun. Der erzeugte Code ist nur vom verwendeten Compiler, deren Einstellungen und eventuell von der Version abhängig.