Need for Speed

Interfacciarsi con il linguaggio C: le struct

Nel linguaggio C, una struct è un tipo composito, formato da campi diversi. Ogni campo ha il proprio tipo e la propria dimensione.

Per esempio, questo definisce un tipo formato da tre interi, due da 4 byte ed uno da 8 byte:

struct example {
    int32_t first_four_byte_integer;
    uint32_t second_four_byte_integer;
    uint64_t eight_byte_integer;
};

Una struct può anche contenere altre struct:

struct example_2 {
    struct example first;
    struct example second;
};

Se uno dei campi della struct è un array, tutti i byte allocati per l'array fanno parte della struct. Se invece il campo è solo un puntatore all'array, allora l'array deve essere memorizzato altrove:

struct with_array {
    char string[20];
};
// all 20 bytes of string are inside struct with_array

struct with_pointer {
    const char *string;
};
// only the 8-byte pointer to the string is inside struct with_pointer

Allineamento

L'allineamento di un tipo è una potenza di due non negativa (1, 2, 4, 8, ...) che rappresenta un requisito sul suo indirizzo. Ogni oggetto di quel tipo deve trovarsi ad un indirizzo che sia un multiplo del suo allineamento.

Per un tipo primitivo, l'allineamento è di solito uguale alla sua dimensione; quindi, per esempio, un int32_t di solito ha un allineamento di 4 byte. Questo significa che int32_t deve essere allocato su confini di 4 byte.

L'allineamento di una struct, invece, è l'allineamento massimo tra i suoi campi. Quindi, per esempio, la struct example definita sopra avrebbe un allineamento di 8 byte, dato che questo è l'allineamento di uint64_t.

Se l'allineamento di un campo della struct è minore di quello della struct, dopo quel campo possono essere inseriti dei byte di padding. Questo garantisce che i campi successivi e la struct nel suo insieme rispettino i requisiti di allineamento. In pratica, questo significa che, anche se quei byte di padding contribuiscono alla dimensione della struct, non vengono usati nel valore della struct:

struct example_3 {
    char one_byte; // alignment of 1
    int four_byte; // alignment of 4
};
// example_3 has alignment of 4 (the same as int)
// it occupies 8 bytes in space:
// 1 byte for field 'one_byte'
// 3 padding bytes (with undefined value)
// 4 bytes for field 'four_byte'

Nota che nella struct definita sopra, il campo 'one_byte' ha allineamento 1 e può essere collocato a qualsiasi indirizzo. Dato che il campo 'four_byte' ha allineamento 4, anche i campi della struct devono rispettare i confini di 4 byte. Questo significa che tra due campi qualsiasi della struct deve esserci un numero di byte multiplo di 4. Dato che 'one_byte' occupa solo 1 byte, dopo di esso vengono inseriti 3 byte di padding per rispettare questo confine.

I campi adiacenti vengono raggruppati quando possibile, per ridurre al minimo il numero di byte di padding necessari:

struct two_padding {
    char one; // alignment of 1
    char two; // alignment of 1
    int three; // alignment of 4
};
// struct two_padding has alignment of 4 (the same as int)
// it occupies 8 bytes in space:
// 1 byte for field 'one'
// 1 byte for field 'two'
// 2 padding bytes
// 4 bytes for field 'three'

Questo raggruppamento deve rispettare anche l'allineamento di ogni campo:

struct one_padding {
    char one; // alignment of 1
    int16_t two; // alignment of 2
    int three; // alignment of 4
};
// struct one_padding has alignment of 4 (the same as int)
// it occupies 8 bytes in space:
// 1 byte for field 'one'
// 1 padding byte
// 2 bytes for field 'two'
// 4 bytes for field 'three'
// Since 'two' has alignment of 2, it must be placed in a 2-byte boundary
// So, there must be 1 padding byte between 'one' and 'two'

Questo significa che cambiare l'ordine dei campi in una struct può a volte portare a una differenza nella sua dimensione:

struct example_4 {
    int64_t one;
    short two;
    int32_t three;
};
// example_4 has alignment of 8 (the same as int64_t)
// it occupies 16 bytes in space:
// 8 bytes for field 'one'
// 2 bytes for field 'two'
// 2 padding bytes
// 4 bytes for field 'three'
// two' and 'three' are adjacent and can be grouped to sum up 8 bytes with only 2 bytes of padding

struct example_5 {
    int16_t one;
    int64_t two;
    unsigned int three;
};
// example_5 also has alignment of 8 (the same as int64_t)
// however, it occupies 24 bytes in space:
// 2 bytes for field 'one'
// 6 bytes for padding
// 8 bytes for field 'two'
// 4 bytes for field 'three'
// 4 padding bytes
// 'one' can't be grouped with 'two' because their sum would be higher than the struct's alignment
// 'two' and 'three' also can't be grouped, for the same reason
// so padding bytes must be inserted in full after each field with less than 8 bytes in alignment

Nota che l'allineamento di un array è uguale all'allineamento del suo tipo sottostante:

struct array_example {
    char string[10]; // alignment of 1
};
// array_example has alignment of 1 (it can be placed at any address)
// it occupies 10 bytes in space, one for each char in 'string'

Gli elementi di un array possono essere raggruppati allo stesso modo in cui lo sarebbero se non facessero parte di un array:

struct group_array {
    int16_t arr[3];
    int8_t one_byte;
    int32_t four_byte;
};
// group_array has alignment of 4 because this is the alignment of 'four_byte'
// it occupies 12 bytes in space:
// 4 bytes for arr[0] and arr[1]
// 2 bytes for arr[2]
// 1 byte for 'one_byte'
// 1 padding byte (arr[2] is grouped with 'one_byte')
// 4 bytes for 'four_byte'

È importante tenere conto di eventuali byte di padding quando si accede ad una struct in assembly.

Convenzione di chiamata

In generale, i valori vengono passati alle funzioni e restituiti da esse come ci si aspetterebbe:

• I valori interi, compresi gli indirizzi di memoria e gli enum, vengono passati nei registri di uso generale (GPR).
• I valori in virgola mobile vengono passati nei registri xmm.

Le struct, però, sono un caso speciale. Come regola generale, tutti i campi di una struct occupano spazio adiacente in memoria e dovrebbero essere collocati in un unico registro quando possibile:

struct single_type {
    int16_t first;
    int16_t second;
    int16_t third;
    int16_t fourth;
};
// this struct occupies 8 bytes
// it is entirely passed in the same GPR register:
// the field 'first' is passed on the lowest 2 bytes
// each subsequent field is passed in the following 2 bytes

Se una struct ha campi con valori interi ed anche campi con valori in virgola mobile, ogni 8 byte consecutivi della struct vanno classificati separatamente:

struct mixed_types {
    double first;
    int second;
    int third;
};
// this struct occupies 16 bytes
// the field 'first' is passed in the first 8 bytes of a xmm register
// the fields 'second' and 'third' are passed in the same GPR register:
// the field 'second' is passed on the lowest 4 bytes
// the field 'third' is passed in the next 4 bytes

Se interi e valori in virgola mobile si trovano negli stessi 8 byte, il tipo è intero e l'intero blocco di 8 byte (compreso il valore in virgola mobile) viene collocato in un GPR:

struct mixed_types {
    int32_t integer;
    float floating_point;
};
// this struct occupies 8 bytes
// it is entirely passed in the same GPR register:
// the field 'integer' is passed on the lowest 4 bytes
// the field 'floating_point' is passed on the next 4 bytes

Tuttavia, le struct di dimensione superiore a 16 byte vengono di solito collocate in memoria, indipendentemente dal tipo di ogni 8 byte:

struct big_struct {
    uint8_t first;
    double second;
    int64_t third;
};
// this struct occupies 24 bytes, including 7 padding bytes between 'first' and 'second'
// it is entirely passed in memory

Quando una struct viene passata come argomento ad una funzione, occupa tutti i registri necessari. Se invece è collocata in memoria, si usa lo stack.

Regole simili valgono per le struct restituite da una funzione. Di solito vengono restituite prima in rax e rdx (se di valore intero) o in xmm0 e xmm1 (se di valore in virgola mobile). Se invece sono collocate in memoria, chi chiama deve riservare loro dello spazio e passare l'indirizzo di questa posizione di memoria come primo argomento implicito della funzione (in rdi). La funzione memorizza poi la struct in questo spazio e ne restituisce l'indirizzo in rax.