2016-09-20

#include <iostream>
using namespace std;
struct st1 { char vc[4]; }; struct st2 { int vd[4]; };
class cl
{   st1 s; long v[4];
public:
    cl(char c, st2& s2);
    void elab1(st1 s1, st2 s2);
    void stampa()
    {   int i;
        for (i=0;i<4;i++) cout << s.vc[i] << ' '; cout << endl;
        for (i=0;i<4;i++) cout << v[i] << ' '; cout << endl << endl;
    }
};


#include "cc.h"
cl::cl(char c, st2& s2) {
    for (int i = 0; i < 4; i++) {
        s.vc[i] = c + i;
        v[i] = s2.vd[i] + s.vc[i];
    }
}
void cl::elab1(st1 s1, st2 s2) {
    cl cla('a', s2);
    for (int i = 0; i < 4; i++) {
        if (s.vc[i] <= s1.vc[i]) {
            s.vc[i] = cla.s.vc[i];
            v[i] = cla.v[i];
        }
    }
}


SOLUZIONE

# COSTRUTTORE

.global _ZN2clC1EcR3st2

_ZN2clC1EcR3st2:

  # RECORD DI ATTIVAZIONE
  #  st2& s2    -24
  # i   |   c     -16
  # this    -8
  # %old_rbp  <-    %rbp
  # %rip

  # PROLOGO
    pushq %rbp
    movq %rsp,    %rbp
    subq $24,   %rsp

  # COPIA PARAMETRI

    movq %rdi,    -8(%rbp)
    movb %sil,    -16(%rbp)       #char c è il primo parametro della funzione quindi è il primo
                                        #ad essere passato dopo l°oggetto classe. SIL-SI-ESI_RSI
    movq %rdx,    -24(%rbp)

  # CORPO

    movl $0,    -12(%rbp)         # i = 0
    movq -8(%rbp),    %rdi       # this oggetto classe
for:
    cmpl $4,    -12(%rbp)
    jge finefor
    movslq -12(%rbp),   %rcx     # estendo i su q (8 byte = 64 bit) per indirizzamento
    movb -16(%rbp),   %al        # salvo c in al
    addb %cl,   %al              # AL = AL + CL, al = c e cl è la parte meno significativa
                                      # di rcx dove ho salvato i. Quindi in al ho i + c
                                      # char è su 8 bit (reg %AL) per sommargli un intero
                                      # devo effettuare il cast int -> prendo parte meno
                                      # significativa del reg in cui è salvato l°int.
    movb %al, (%rdi, %rcx)       # metto (i+c) in s.vc[i], s è il primo elemento dell° oggetto
                                      # classe quindi non devo aggiungere niente, solo reg
                                      # ogg classe e %rcx == i per indirizzamento
    movq -24(%rbp),     %r8
    movslq (%r8, %rcx, 4), %r9        # s2.vd[i]
    movsbq (%rdi, %rcx),  %rbx         #s.vc[i]
    addq %rbx,    %r9
    movq %r9,   8(%rdi, %rcx, 8)      # v[i] = s.vc[i] + s2.vd[i]
    incl -12(%rbp);
    jmp for
finefor:
    leave
    ret

# elab1

.global _ZN2cl5elab1E3st13st2

_ZN2cl5elab1E3st13st2:

  # RECORD DI ATTIVAZIONE
  # cla   -72     <- cla          #cla = st1 s (che è un array di 4 char quindi occupa 4*1 byte => 4byte) e long v[4] che è un array di 4 long e quindi occupa 8*4 = 32 byte. quindi in totale cl cla è di 32+4 byte = 36 byte, allineati a multiplo di 8: 40 byte
  # cla   -64
  # cla   -56
  # cla   -48
  # cla   -40
  # s2    -32     <-  s2  parte meno significativa
  # s2    -24
  # i   |   s1 -16
  # this    -8
  # %old_rbp      <-    %rbp
  # %rip

  # PROLOGO
    pushq %rbp
    movq %rsp,    %rbp
    subq $72,   %rsp

  # COPIA PARAMETRI
    movq %rdi,    -8(%rbp)        # this, oggetto classe
    movl %esi,    -16(%rbp)       # s1
    movq %rdx,    -32(%rbp)       # parte meno significativa di s2
    movq %rcx,    -24(%rbp)       # parte più significativa di s2

  # CREAZIONE cla
    leaq -71(%rbp),   %rdi        # inserisco nel reg rdi la posizione in cui deve essere creato l°oggetto cioè -72(%rbp)
    movb $'a',  %sil
    leaq -32(%rbp),   %rdx        # metto con lea perchè nel costruttore il parametro è passato come riferimento
    call _ZN2clC1EcR3st2

  # FOR
    movl $0,    -12(%rbp)
    movq -8(%rbp),    %rdi
for1:
    cmpl $4,    -12(%rbp)
    jge finefor1
    movslq -12(%rbp),   %rcx            # converto i da 'l' a 'q' per indicizzazione
if:
    movb (%rdi, %rcx), %sil             # s.vc[i]
    cmpb -16(%rbp, %rcx), %sil          # se s.vc[i] è maggiore di s1.vc[i] allora salta a fineif
    jge fineif
    movb -72(%rbp, %rcx),   %al         #cla.s.vc[i]
    movb %al,   (%rdi, %rcx)            #s.vc[i] = cla.s.vc[i]
    movq -64(%rbp, %rcx, 8),    %rax    # cla.v[i]
    movq %rax,    8(%rdi, %rcx, 8)      # s.v[i] = cla.v[i]
fineif:
    incl -12(%rbp)
    jmp for1
finefor1:
    leave
    ret