[C] Sforamento array

[Unrue]

Ciao ragazzi, ho un pezzo di codice che mi dà il seguente errore:

Bounds error: attempt to reference memory overrunning the end of an object.

L'errore capita a questa chiamata:

static opal_atomic_lock_t class_lock = { { OPAL_ATOMIC_UNLOCKED } };

Che a sua volta genera errore in questo blocco di codice alla riga evidenziata:

static inline int opal_atomic_cmpset_32( volatile int32_t *addr,
                                        int32_t oldval, int32_t newval)
{
   unsigned char ret;
   __asm__ __volatile (
                       SMPLOCK "cmpxchgl %1,%2   \n\t"
                               "sete     %0      \n\t"
                       : "=qm" (ret)
                       : "q"(newval), "m"(*((volatile long*)addr)), "a"(oldval)
                       : "memory");

   return (int)ret;
}

Non riesco a capire inanzitutto cosa fa questo pezzo di codice. Qualcuno può illuminarmi ?

[Unrue]

Mi sono un pò documentato.

Questa è "Extended Assembler". Queste:

SMPLOCK "cmpxchgl %1,%2   \n\t"
                               "sete     %0      \n\t"

Sono le direttive.

Questi i registri di output:

: "=qm" (ret)

Questi di input:

: "q"(newval), "m"(*((volatile long*)addr)), "a"(oldval)

infine ci sono i "clubber registers", che ancora non ho ben capito cosa sono.

Ora, quello che non capisco, i vari %1, %0 si riferiscono ai registri o agli argomenti passati alla funzione?

[DanieleC88]

La clobber list è la lista dei registri non passati come parametri di input/output al blocco assembly, ma che sono modificati dalle istruzioni che vi scrivi. In sostanza, dici al compilatore di non fare più affidamento sul contenuto di quei registri. Se usi "memory" fai qualcosa di simile, ma indicandogli che il blocco di codice assembly potrebbe modificare dei valori contenuti nella memoria, oltre ai registri direttamente.

Invece, %0, %1 e %2 fanno riferimento ai parametri di input/output di quel blocco, nel tuo caso sono rispettivamente ret, newval e addr, mentre oldval dovrebbe finire in EAX, se non ricordo male.

[Unrue]

Originariamente inviato da DanieleC88

La clobber list è la lista dei registri non passati come parametri di input/output al blocco assembly, ma che sono modificati dalle istruzioni che vi scrivi. In sostanza, dici al compilatore di non fare più affidamento sul contenuto di quei registri. Se usi "memory" fai qualcosa di simile, ma indicandogli che il blocco di codice assembly potrebbe modificare dei valori contenuti nella memoria, oltre ai registri direttamente.

Invece, %0, %1 e %2 fanno riferimento ai parametri di input/output di quel blocco, nel tuo caso sono rispettivamente ret, newval e addr, mentre oldval dovrebbe finire in EAX, se non ricordo male.

Ok, grazie Però ad esempio, la funzione "sete", cosa fa? Non mi riesce trovarla. Inoltre in quel blocco di codice, l'argomento %3, riferito a oldval, non viene mai usato. Possibile?

[DanieleC88]

SETE sta per Set If Equal, imposta il registro ad 1 se nelle flags è stato impostato il bit Zero dopo l'ultima operazione.
Il valore oldval è usato, ma in maniera un po' più nascosta: viene caricato in EAX (è questo il significato di "a") e poi usato da CMPXCHGL. Questa infatti confronta il valore in EAX col secondo operando: se sono uguali, imposta Zero e carica il primo operando nel secondo, altrimenti disattiva Zero e carica il secondo operando in AL (nota che se la sintassi fosse quella Intel anziché AT&T, dovresti invertire sempre primo/secondo operando).

In sostanza, si sta facendo una cosa tipo:

long *pMemory = (long *)addr;

if ((*pMemory) == oldval)
{
  (*pMemory) = newval;
  return 1;
}
return 0;

[Unrue]

Originariamente inviato da DanieleC88

SETE sta per Set If Equal, imposta il registro ad 1 se nelle flags è stato impostato il bit Zero dopo l'ultima operazione.
Il valore oldval è usato, ma in maniera un po' più nascosta: viene caricato in EAX (è questo il significato di "a") e poi usato da CMPXCHGL. Questa infatti confronta il valore in EAX col secondo operando: se sono uguali, imposta Zero e carica il primo operando nel secondo, altrimenti disattiva Zero e carica il secondo operando in AL (nota che se la sintassi fosse quella Intel anziché AT&T, dovresti invertire sempre primo/secondo operando).

In sostanza, si sta facendo una cosa tipo:

long *pMemory = (long *)addr;

if ((*pMemory) == oldval)
{
  (*pMemory) = newval;
  return 1;
}
return 0;

Dunque, credo di aver capito. Quindi la cmpxchgl di suo non ritorna nulla? Per questo serve anche la sete? Infatti è lei che ritorna il valore ret (%0)

Altra cosa, io sto lavorando su un amd 64 bit, ma come mai quindi in questo codice c'è la sintassi AT&T e non Intel?

Inoltre, siccome quella parte di codice lavora su valori a 32 bit, che senso potrebbe avere quel cast a long? Trallaltro è proprio nella riga incriminata.

[DanieleC88]

Sì, la CMPXCHGL imposta una flag, oltre a spostare i valori. Poi con SETE quel codice aggiorna il valore dentro una variabile locale.

Perché la sintassi AT&T? Non so, probabilmente solo una questione di compilatore, con GCC al momento è l'unica supportata, da quel che mi risulta.

ciao