Discussion :

[Kraane]

Hello,

Je me trouve face a mon incertitude concernant un bout de code.
Je dois fournir a une API, une chaîne de caractères sous forme d'un pointeur sur un unsigned int, tout en respectant l'alignement du type et la règle de strict aliasing.

Actuellement, j'ai géré le soucis comme cela

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
typedef union uData
{
    uint32_t* uint_ptr;
    char* char_ptr;
} Data;
 
uint32_t* convert_str_to_uintptr()
{
    Data d;
 
    d.char_ptr = malloc(n * sizeof(char));
    // Fill the string here
 
    return d.uint_ptr;
}

Est-ce que cette méthode permet de satisfaire a toutes mes exigences ?

[dalfab]

Bonjour,

- L'alignement est respecté car malloc() doit retourner un buffer respectant le 'fundamental alignment' qui par définition respecte tous le types standard dont font partie uint32_t et char.
- Le strict alignement, je pense que tu veux dire le 'strict aliasing'. Il est forcément respecté car il n'y qu'un seul type de données écrite (en plus ce sont des char qui n'ont jamais de problèmes d'aliasing.)
- Mais il y a un 'undefined behavior' car tu lis dans une union pas le même champ que tu as écrit. Certains compilateurs signalent ce problème mais tous savent utiliser le fait que les 2 données sont bien les mêmes.

[Kraane]

L'alignement est respecté car malloc() doit retourner un buffer respectant le 'fundamental alignment' qui par définition respecte tous le types standard dont font partie uint32_t et char.

Je suis d'accord,
Mais l'API lit la chaîne de caractères via un pointeur sur un unsigned int. L'adresse de mon tableau de caractère doit donc être un multiple de 4.
Si tu me dis que malloc retourne une adresse respectant l'alignement de tous les types standard, alors je suis content.
(sur un système 64bit, mes adresses devraient donc toutes être multiple de 8 ? pour respecter le type double qui est de 8 bytes sur mon architecture)

Le strict alignement, je pense que tu veux dire le 'strict aliasing'. Il est forcément respecté car il n'y qu'un seul type de données écrite (en plus ce sont des char qui n'ont jamais de problèmes d'aliasing.)

Oui, excuse moi, c'est bien du strict aliasing dont je parle.

Je suis d'accord sur le fait que la conversion d'un uint32_t vers un char respecte le strict aliasing.
L'inverse, en revanche, ne l'est pas.

Mais il y a un 'undefined behavior' car tu lis dans une union pas le même champ que tu as écrit. Certains compilateurs signalent ce problème mais tous savent utiliser le fait que les 2 données sont bien les mêmes.

En effet,
Je viens de relire l'article de Mike Acton, et il semble que ce soit un 'undefined behavior'.
Je vais donc récupérer le uint32_t directement depuis le malloc.

[Bktero]

J'ai l'impression qu'il y a mélange entre aliasing et alignment, je me trompe ?

[Kraane]

Que veux-tu dire par la ?

Peut-être que je n’interprète pas correctement ces deux termes...

[Bktero]

L'alignement, c'est une problématique de placement en mémoire. En gros, l'adresse est-elle multiple de 1,2, 4 ou 8 ? Certains processeurs ne me permettent pas exemple pas les accès non alignés. Exemple avec le Cortex-M0 de chez ARM, si tu veux lire 32 bits, il faut que l'adresse soit multiple de 4 ; sinon, le processeur génère une erreur.

L'aliasing, c'est le fait d'avoir un ou plusieurs alias. Pour reprendre la définition de Wikipédia https://en.wikipedia.org/wiki/Aliasing_(computing) :

In computing, aliasing describes a situation in which a data location in memory can be accessed through different symbolic names in the program

En C, il existe une règle à respecter : celle du strict aliasing https://gist.github.com/shafik/848ae...3cffee272a58f8

Ces problématiques sont presque séparées : le fait que tes données soient bien ou mal alignées n'a pas de lien direct avec le fait que tu es plusieurs alias pour une même donnée. C'est la règle du strict aliasing qui mélange un peu les choses.