Échange de devises

Dans les concepts précédents, nous avons vu que la directive global rend une fonction ou une variable définie dans un fichier source visible depuis les autres fichiers. De même, la directive extern informe l'assembleur qu'une fonction ou une variable utilisée dans le fichier source courant est définie dans un autre fichier.

Ces deux directives sont le principal moyen pour le code assembleur d'interagir avec d'autres fichiers source afin d'obtenir de la modularisation.

Pour ce qui est de ces directives, peu importe que le code externe soit défini ou utilisé en assembleur ou dans un langage de haut niveau. Ainsi, par exemple, même une fonction définie dans un langage de haut niveau peut être utilisée dans du code x86-64 si elle est déclarée extern.

De la même manière, la convention d'appel est partagée par toutes ces fonctions, qu'elles soient définies en assembleur ou dans un langage de haut niveau, et même avec le système d'exploitation (OS).

Cependant, comme en assembleur une donnée n'est qu'une séquence d'octets, il est important de garder à l'esprit la manière dont le langage de haut niveau qui réalise l'interface gère la mémoire.

Les types en C

Le langage C est un choix courant de langage de haut niveau pour interagir avec du code assembleur. Il facilite l'interaction avec le système d'exploitation, en offrant des surcouches de haut niveau pour de nombreuses tâches importantes, comme afficher à l'écran, lire depuis un clavier ou allouer de la mémoire dynamique.

Dans ce parcours, les tests sont écrits en C, il est donc important d'en donner un aperçu général.

Types primitifs

Il existe de nombreux types primitifs en C et leur taille, en octets, peut varier. Certains d'entre eux sont résumés dans le tableau suivant, avec leur taille typique dans un système x86-64 :

Chacun de ces types entiers peut être signé (par défaut) ou non signé. Lorsqu'ils sont non signés, cela doit être précisé, par exemple : unsigned int.

Il existe des alias pour les types entiers, définis pour offrir un contrôle précis sur leur taille :

Ces alias peuvent être préfixés par u pour indiquer un type non signé, par exemple : uint64_t.

D'autres alias méritent d'être signalés :

Un _Bool, ou son alias bool, est particulier : bien qu'il occupe un octet entier, il ne peut prendre que l'une de deux valeurs, true (1) et false (0).

Les valeurs de ces types primitifs sont passées aux fonctions et renvoyées par elles selon les règles habituelles pour les entiers et les valeurs à virgule flottante.

Enums

Un enum est un type qui peut prendre l'un d'un certain nombre d'éléments indiqués explicitement :

enum example {
    example_1,
    example_2,
    example_3,
    example_4
};

En C, les enum sont implicitement convertis vers un type entier, généralement un int, c'est-à-dire un entier de 4 octets.

Par défaut, le premier élément possible d'un enum est converti en 0 et tous les éléments suivants sont convertis en l'entier suivant. Ainsi, dans l'enum example défini ci-dessus, example_1 aurait la valeur 0, example_2 aurait la valeur 1, et ainsi de suite.

Il est possible d'indiquer la valeur de n'importe quel élément d'un enum, et par défaut l'élément suivant prend alors l'entier suivant comme valeur :

enum example_2 {
    example_1 = 4,
    example_2 = 8,
    example_3
}; // example_3 is equal to 9

Adresses mémoire

En C, une adresse mémoire est référencée par un pointeur vers un type et notée avec l'opérateur *. Par exemple, int64_t * désigne un emplacement mémoire pour un ou plusieurs int64_t.

Les adresses sont traitées comme des entiers de 8 octets, comme d'habitude.

Tableaux

Les tableaux sont passés aux fonctions, et renvoyés par elles, sous forme de pointeurs vers leur premier élément.

int64_t example_arr[] = {1, 2, 3}; // this is an array of 3 signed 8-byte integers
fn(example_arr); // this is a function that passes a pointer (int64_t *) to the beginning of the array as an argument

Chaque élément d'un tableau a la taille du type des éléments de ce tableau. Le tableau example_arr défini ci-dessus, par exemple, contient 3 éléments de 8 octets chacun, soit 24 octets au total.

Comme les tableaux ne stockent pas leur longueur, une valeur distincte est généralement nécessaire pour indiquer le nombre d'éléments, à moins qu'une valeur sentinelle ne marque la fin.

Strings

Les strings en C sont un tableau de char, un type de 1 octet. La plupart des strings sont constituées de caractères ASCII et terminées par NUL : elles s'arrêtent donc lorsqu'un octet de valeur 0 est trouvé. Cela signifie que la longueur d'une string n'a généralement pas besoin d'être passée comme argument distinct.