Mettre du code ASM dans une source C ?

[Sharynn]

Sharynn

#8511

Je désirerai savoir si l’on peut intégré du code asm dans une source C.

Je développe une petite application et pour le moment je désirerai utiliser un bout de code ASM pour pouvoir la faire tourner. En attendant que je le convertisse en C.

Merci

Amos un jour, Amos Toujours
-----------------------------------
AmOS4 - Library Amos sous C (Os3-Os4)

[AmiDARK]

AmiDARK

#130523

Déjà, commence par mentionner le compilateur C que tu veux utiliser

ça permettra de dire si ce « dit » compilateur gère l’incorporation du code ASM « inline » ou si tu devras mettre ton code ASM en librairie ou autre …

@ +

[corto]

corto

#130524

Donc tu as du code asm que tu voudrais incorporer dans du C, c’est tout à fait possible, voici deux possibilités :

1. Il s’agit de quelques instructions et tu peux faire de l’assembleur inline (que l’on déclare avec « asm volatile ») mais c’est compliqué, sous-documenté, … et du coup, risqué : il faut expérimenter et vérifier le code généré pour voir s’il n’y a pas d’effet de bord.

2. C’est une fonction écrite en assembleur et qui respecte l’ABI utilisée (sur PPC : passage de paramètres r3 et suivant, pointeur de pile en r1, etc.) alors elle doit être déclarée en « global » pour que ton code C qui va l’appeler puisse en avoir connaissance. Tu compiles ton code asm en objet comme tu ferais avec un source C et tu linkes le tout.

[Sharynn]

Sharynn

#130525

Pour le moment, j’utilise hisoft C sous OS3.9… ensuite je traduirai la source pour PPc Os4.0..

@Corto: Tu as un exemple pour que je décortique ?

Amos un jour, Amos Toujours
-----------------------------------
AmOS4 - Library Amos sous C (Os3-Os4)

[corto]

corto

#130526

Voila l’exemple :

– exemple.c : ton programme principal C, il déclare en extern la fonction assembleur

– exempleasm.S : ton code assembleur, il déclare la fonction en global

Tu compiles les 2, tu linkes les objets et tu lances avec un nombre d’arguments variable pour voir que ça fonctionne bien.

Quoique c’est du PPC, je ne sais pas si tu peux le lancer. En tout cas, la méthode est là.

// exemple.c

// Pour compiler :

// gcc -c exemple.c

// gcc -c exemple_asm.S

// gcc -o exemple exemple.o exempleasm.o

#include

extern int fonction_asm(int a, int b);

int main(int argc, char **argv)

{

int v;

int res;

v = (int)argv;

res = fonction_asm(argc, v);

printf("argc = %d, v = %d (0x%08x), (v & 15) = %d, res = %dn", argc, v, v, v & 15, res);

return 0;

}

# exempleasm.S

.global fonction_asm

.align 2

fonction_asm:

# les parametres sont recus en r3 et r4

# le resultat est retourne en r3

andi. 4, 4, 15 # masque parametre b : b = b & 15

add 3, 3, 4 # additionne a et la nouvelle valeur de b

blr

A toi de jouer !

[crisot]

crisot

#130527

Tiens c’est marrant ce dont parle Corto. Mes demos aone utilisent la première méthode, « asm volatile ». Le concept si je me rappelle bien, c’est qu’il faut déclarer les registres que tu va utiliser pour que le compilo les restaures à la fin de ton code asm (un truc du genre je sais plus exactement).

Le problème avec ce truc, c’est que je ne pouvais compiler qu’avec -O 0 (c’est à dire aucune opti). Des que j’utilisais O1, O2, ou O3, le code C se chiait dessus à la sortie de la fonction ASM.

J’ai pas cherché plus loin parceque 90% de la demo est en ASM, je sais pas si c’était moi, GCC, ou autre chose, n’empeche que ce que dit Corto est interessant.

[corto]

corto

#130528

Crisot ! Content de te lire, ça faisait si longtemps !

Ce que tu décris s’explique, il suffit qu’il y ait une erreur dans la déclaration de ton bloc asm et ça peut avoir des conséquences. La syntaxe est ardue et les explications pas claires. Quand tu as une ou quelques lignes, ça passe, tu arrives à voir quels registres tu utilises mais au-delà, c’est immonde.

Il faut déclarer la valeur retournée, les valeurs en entrée (et éventuellement modifiée), les registres modifiés en internes, il faut aussi associer à chacun des paramètres du bloc un nom dépendant de son ordre %0, %1, %2, … dans le code asm c’est un vrai casse-tête (je crois que le nommage a été amélioré ceci dit).

C’est pour ça que si le but est d’écrire une fonction asm dans un programme C, c’est très simple, il n’y a qu’à respecter l’ABI : utiliser les registres autorisés, sauver les autres sur la pile et les restaurer à la fin, …

J’ai commencé à écrire un article sur l’asm inline ppc il y a quelques temps mais je ne sais pas si je le finirai un jour …

[henes]

henes

#130529

Orienté x86 et un peu vieux maintenant mais toujours sympa :

http://www.cs.virginia.edu/~clc5q/gcc-inline-asm.pdf