Analisi di codice C

Question

Ecco la funzione che sto scrivendo sulla macchina Linux a 64 bit.

void myfunc(unsigned char* arr) //array of 8 bytes is passed by reference
{
   unsigned long a = 0; //8 bytes
   unsigned char* LL = (unsigned char*) &a;

   LL[0] = arr[6];
   LL[1] = arr[3];
   LL[2] = arr[1];
   LL[3] = arr[7];
   LL[4] = arr[5];
   LL[5] = arr[4];
   LL[6] = arr[0];
   LL[7] = arr[2];
}

Ora le mie domande sono:

variabile
1. Will 'a' essere memorizzato in un registro in modo che non ci vorrà accedere più e più volte dalla RAM o Chache?
2. lavoro su architettura a 64 bit, devo presumere che matrice 'arr' verrà memorizzato in un registro come parametri delle funzioni sono memorizzati in un registro a 64 bit arco?
3. Quanto è efficiente tipo puntatore casting? La mia ipotesi è che dovrebbe essere inefficiente a tutti?

Qualsiasi aiuto sarebbe appriciated.

Saluti

Answer 1

1. a non può essere memorizzato in un registro, come hai preso il suo indirizzo. (Valdo fa giustamente notare che un compilatore davvero intelligente potrebbe ottimizzare la matrice accessi nelle operazioni bit e congedo a in un registro, ma non ho mai visto un compilatore farlo, e io non sono sicuro che sarebbe vento per essere più veloce).
2. arr (il puntatore stesso) viene memorizzato in un registro (%edi, su amd64). contenuto della matrice sono nella memoria.
3. Pointer casting di tipo di per sé , spesso genera alcun codice a tutti. Tuttavia, fare le cose stupide con tipo calchi può portare a codice molto inefficiente, o anche per il codice il cui comportamento non è definito.

Sembra che si sta tentando di permutare i byte in un array e poi spingere in un numero, e il codice macchina vostro esempio genera non è terribilmente male per questo. Il suggerimento di David di usare l'avanzamento e la maschera operazioni invece è buono (questo sarà anche evitare problemi se il codice mai deve essere eseguito su un big-endian della macchina), e ci sono anche le istruzioni vettore permute SSE, ma ho sentito che stanno genere di un dolore per l'uso.

Per inciso, si dovrebbe fare il tipo di ritorno della funzione esempio essere unsigned long e mettere return a; proprio alla fine; quindi è possibile utilizzare gcc -O2 -S e vedere esattamente quello che si ottiene dalla compilazione. Senza la modifica a ritorno, GCC sarà allegramente ottimizzare via l'intero corpo della funzione, poiché ha effetti collaterali non visibili esternamente.

Answer 2

Si potrebbe fare meglio di usare l'avanzamento esplicito e mascherare le istruzioni per raggiungere questo obiettivo, invece di utilizzare array di indicizzazione.

Le operazioni di array stanno andando a rendere più difficile per il compilatore da utilizzare registri per questo, perché in genere non ci sono le istruzioni che fanno cose come "carico 8 bit dal 3 byte del registro A". (Una ottimizzazione compilatore potrebbe figura che è possibile farlo con turni / maschere, ma non sono sicuro di come probabile che sia).

Answer 3

1. La questione se la a variabile verrà memorizzato nel registro è una questione di ottimizzazione. Dal momento che non c'è volatile modificatore IMHO un compilatore intelligente farà questo.

2. E 'una questione di convenzione di chiamata. Se per convenzione un singolo parametro puntatore viene trasferita in un registro -. Così sarà arr

3. Pointer casting di tipo non è un'operazione che interpreta CPU. Non c'è codice generato per esso. E 'solo le informazioni per il compilatore di quello che vuoi dire.

(In realtà a volte colata fa produrre codice in più, ma questo è legato alla ereditarietà multipla e il polimorfismo)

Answer 4

Dipende dal vostro livello di ottimizzazione. È possibile esaminare l'assemblea a rispondere alle vostre domande. Con gcc, utilizzare il "-S" bandiera.

gcc -S -O0 -o /tmp/xx-O0.s /tmp/xx.c
gcc -S -O3 -o /tmp/xx-O3.s /tmp/xx.c

Il montaggio è generato completamente differente. (Assicuratevi di fare il cambiamento return a; suggerito da Zack .)

Vedi anche questo messaggio per suggerimenti su come generare un c misto / assemblaggio messa in vendita (che diventa rapidamente inutile con l'ottimizzazione).