PureBasic

quand on récupere la sortie asm d'une source utilisant cos par exemple, on se rend compte qu'aucune fonction PB n'est appellée, uniquement l'instruction FCOS. En gros le même principe que les fonctions inline du C qui consistent à remplacer l'appel de la fonction par son code (de facon transparente).

Maintenant, comment faire la même chose en asm ? c'est en créant le fichier .obj ? ou bien en compilant le .lib ?

Dri

Arf, on est pas trop capable de te repondre , le mieux c'est d'envoyer un MP aux dieux de l'asm, je pense à tonton notament.

@++

Salut mon fonctionnaire, arrête de me flatter, tu vas me faire rougir.
J espère que tu ne seras pas déçu, si je te dis que je ne porte pas de casquette en cuir, ni de casque de chantier et encore moins de casque militaire.

Pour en venir à la question du doc, je ne suis pas sur de l’avoir bien comprise.
La fonction ‘inline’ est en gros utilisée pour optimiser un programme lors de la compilation.
Or pendant la compilation d une source en assembleur, aucune modification n est faite , les instructions sont directement converties en 0 et 1 et données à bouffer au processeur.
Il n y a donc, a mon avis, pas d équivalence pour ’inline’ en asm.

Je n'ai pas compris la question. En asm? Tu veux dire sous FASM?

bah dans la mesure où je fais de l'assembleur uniquement avec PB, je dirais que oui

Dri

Il faut distinguer l'assembleur du langage machine.

L'assembleur, ce sont les mnémoniques à peu près compréhensibles (comme FCOS, MOV, CMP...) qui sont convertis en langage machine par un programme d'assemblage, qui a un rôle d'interprète (qu'on appelle un assembleur, avec PB sous Windows c'est FASM).

Le programme résultant est en langage machine (une suite d'octets, un ou plusieurs par instruction). L'OS le charge en mémoire, et fixe le registre PC (compteur de programme ou pointeur d'instructions) sur le premier octet. Le processeur lit les octets, et les exécute.

Suivant les programmes d'assemblage, il y a de petites différences. FASM par exemple est assez simple, et ne suit pas à la lettre les recommandations d'Intel (se reporter à la doc pour plus d'infos). Il intégre aussi des macros. Il est donc possible de faire des "pseudos instructions", qui seront remplacées au moment de l'assemblage par un code plus long.

Je ne suis pas un fonctionnaire, mais un Sans Emploi Temporaire.

je vais essayer de bien expliquer le shmilblick

par exemple en C, quand je crée une fonction "inline"
le compilateur remplace les appels à la fonction directement par son code

c'est adapté par exemple à une fonction "min" ou "max"



au lieu d'avoir dans son code asm


on aura


et ca c'est possible même après que la fonction aie été compilée. donc ca doit bien pouvoir se faire avec fasm nan ? (ou bien polib etc...)

Dri

Avec Fasm tu n'as pas de procédures; on fait des sauts, voilà tout. De même on n'est pas obligé d'empiler les variables, on peut utiliser les registres. Pour remplacer inline, qui en gros oblige le compilo à éviter un saut et à créer le code asm en place, sans utiliser la pile, tu peux utiliser les macros, oui.

la question c'est pas comment je fais du inline en codant... mais quand je crée ma lib, comment faire pour compiler "inline" ?

(comme la fonction COS de PB par exemple)

Dri

Décidément, j'ai toujours du mal à comprendre
Si tu fais une lib, c'est pour faire des procédures, donc il y aura un saut de toutes façons?!

Bah par exemple regarde comment le code de la fonction Cos() est transformé par PB... Y'a pas de saut du tout.


Dri

Ok! J'ai enfin compris! En fait je ne pense pas que ça soit possible. Pure se comporte lui aussi comme un interpréteur; en gros il convertit le source PB en source FASM; donc pour lui tout est possible! En revanche dans une lib il n'y a que des procédures auxquelles on donne des paramètres ; cela signifie que lorsqu'on appelle ces procédures, il y a forcément un saut, plus du passage de paramètres.

Je vais quand même regarder demain

Le compilateur PB doit avoir une "liste" de fonction "non PB" qui sont donc (+ ou -) équivalentes au "inline" du C.

@Dri

Tu crées ta bibliothèque d'inclusions contenant les macros.
Dans ton source principal, tu inclus tes macros (INCLUDE fichier.INC) et tu les "invoques" (même si ce therme n'est pas exact, il se rapproche plus de l'utilisation d'une macro que le therme "appeler").

Tu n'auras plus aucun saut