Syntaxe Assembleur - Page 1

Je suis en train de programmer un assembleur associé a une VM fait maison (pour le fun et augmenter mon skill)
Alors déja je me rends compte que le little endian que je ne trouvais pas logique jusqu'a maintenant, a finalement beaucoup de sens pour les accès mémoire a différente taille (octet, mot, long)
Ensuite, j'ai mimé les syntaxes d'assembleur que je connais (68k principalement) et je me rends compte en fait que certaine syntaxe ne sont pas logique d'un point de vue execution.
Par exemple:
move.l #1234,d0 ; d0 = 1234 move.l #machin,d0 ; d0 = 1234 move.l 1234,d0 ; d0 = 5678 move.l machin,d0 ; d0 = 5678 jmp machin ; jump a 1234 move.l #machin,a0 ; a0 = 1234 move.l (a0),d0 ; d0 = 5678 jmp (a0) ; jump a 1234 org 1234 machin: dc.l 5678 D'un point de vue assembleur, j'ai mon parseur d'opcode d'un coté et mon parseur d'arguments de l'autre.
mon parseur d'arguments detecte le type de donnée en fonction de la syntaxe de l'argument et pas en fonction de l'opcode !
du coup, entre "move.l machin,d0" et "jmp machin", pour moi machin vaut la même chose, (idem pour (a0))
mais dans la logique des assembleurs courant, c'est plutôt l'opcode qui determine le type de donnée.
Je ne m'étais jamais posé la question jusqu'a présent, mais maintenant je trouve pas ça logique.
(enfin, en vrai si, "jmp (a0)" m'a toujours perturbé, car j'aurais plutôt écrit "jmp a0" naturellement)

Pour avoir une syntaxe logique, je proposerais ça:
move.l #1234,d0 ; d0 = 1234 move.l #machin,d0 ; d0 = 1234 move.l 1234,d0 ; d0 = 1234 move.l machin,d0 ; d0 = 1234 move.l (1234),d0 ; d0 = 5678 move.l (machin),d0 ; d0 = 5678 jmp machin ; jump a 1234 jmp a0 ; jump a 1234 jmp (machin) ; jump a 5678 jmp (a0) ; jump a 5678 Qu'en pensez vous ?

C'est un topic pile-poil pour toi, ça

La même question se pose pour le x86 : MASM interprète mov eax, machin comme dans ton premier exemple, mais NASM l'interprète comme dans ton second exemple (ils ont fait le choix de la logique stricte plutôt que de suivre la syntaxe traditionnelle).

En tout cas, si tu fais ton propre assembleur qui ne suit pas les règles habituelles des assembleurs 68k, je te conseille de changer suffisamment la syntaxe pour qu'il n'y ait pas d'ambiguïté (même un truc tout bête, du genre utiliser des crochets plutôt que des parenthèses par exemple). Parce que sinon, c'est un coup à se mélanger les pinceaux tôt ou tard.

Ah non, pas une n-ième syntaxe 68k

Artemis (./1) :
(enfin, en vrai si, "jmp (a0)" m'a toujours perturbé, car j'aurais plutôt écrit "jmp a0" naturellement)

Etonnamment, non, ça ne m'a jamais perturbé ^^ Faut que j'y réfléchisse. Mais a0 n'est pas exécutable, donc "jmp a0" m'aurait choqué je pense.
Qui n'a jamais rêvé d'avoir les registres exécutables, mappés dans l'ordre d0-d7/a0-a7, on aurait pu faire du smc dedans et des trucs délire

En fait c'est marrant ce que tu proposes, je me suis posé le même genre de question quand j'ai voulu faire un assembleur qui mimique A68k.

je suis en train de chercher mes topics où je posais ce genre de questions philosophiques sur le parsing asm. Je suis retombé sur ça. J'avais du temps à perdre à l'époque

Bon, des sujets en rapport avec tes questions (non je n'ai pas de réponses, que des questions supplémentaires )
topics/162435-adressage-dun-label
topics/113885-labels-et-symboles
Il y a certainement d'autres topics qui parlent de mes élucubrations.



Putain j'étais vraiment parti loin à l'époque
topics/169157-bug-de-lemulation-de-jsr-par-tiemu-meme-pas-vrai-dabord-o
topics/155634-fake-pedrom-sous-ams
topics/121394-toujours-plus-loin-dans-les-bugs-stranges

Artemis (./1) :
je me rends compte que le little endian que je ne trouvais pas logique jusqu'a maintenant, a finalement beaucoup de sens pour les accès mémoire a différente taille (octet, mot, long)

waw mais c'est à ça que sert le little endian??

Disons que c'est un des avantages du little-endian, sachant que le big-endian a aussi les siens. C'est pour ça que les deux existent en pratique, d'ailleurs.

Et quels sont les avantages du little endian ? J'imagine que son inventeur n'était pas juste con en effet...

(au passage, le big endian m'était si naturel que je n'ai compris son avantage que quand Artemis a expliqué pourquoi )

T'es sûr que t'as pas inversé les deux dans ta phrase ? Parce que venant de toi, ça m'étonne ^^

(cross) Bien sûr que si que j'ai inversé

Artemis (./1) :
1. move.l #1234,d0 ; d0 = 1234
2. move.l #machin,d0 ; d0 = 1234
3. move.l 1234,d0 ; d0 = 1234
4. move.l machin,d0 ; d0 = 1234

Alors à mes yeux :

1 est explicite, le # implique une valeur numérique immédiate

2 raye les yeux, invoque Cthulu, et provoque probablement une faille spatio-spirituelle exploitable par One Nation.
En effet, que vaut "machin" ? a priori son adresse.
Alors que vaut la valeur immédiate d'une adresse ?
Certains diront :
a. c'est un non-sens
b. l'adresse elle-même
c. d'autres enfin son contenu. Dans ce dernier cas, (machin) est plus explicite

3 veut dire que le longword pointé par 1234 est copié dans d0 (1234, sans #, est une adresse)

4 signifie que le contenu situé à l'adresse machin est copié dans d0.
C'est ce qu'on signifie, couramment du reste, avec un move.l machin(pc),d0. Sauf que là tu vas reloger, ou du moins résoudre en temps de linking
4 est en fait un synonyme de (machin) à mes yeux, ce qui est cohérent avec machin(pc)

Voilà, c'est mon interpretation. Je n'ai codé qu'avec A68k et GNU as.
déjà, discutons de ça, voyons la suite après

Folco (./8) :
2 raye les yeux, invoque Cthulu, et provoque probablement une faille spatio-spirituelle exploitable par One Nation.

• Zerosquare note : ne jamais montrer mon code 68k à Folco

(au passage, Orion_ fait un assembleur pour sa propre machine virtuelle, donc il n'a à se soucier de rester cohérent avec ce qui existait avant)

Non rien.

Folco (./8) :
(cross) Bien sûr que si que j'ai inversé

Artemis (./1) :
1. move.l #1234,d0 ; d0 = 1234
2. move.l #machin,d0 ; d0 = 1234
3. move.l 1234,d0 ; d0 = 1234
4. move.l machin,d0 ; d0 = 1234

3 veut dire que le longword pointé par 1234 est copié dans d0 (1234, sans #, est une adresse)

4 signifie que le contenu situé à l'adresse machin est copié dans d0.
C'est ce qu'on signifie, couramment du reste, avec un move.l machin(pc),d0. Sauf que là tu vas reloger, ou du moins résoudre en temps de linking
4 est en fait un synonyme de (machin) à mes yeux, ce qui est cohérent avec machin(pc)

Donc, move.l 1234,d0 ça copie ce qui est à 1234, mais jmp 1234 ça jump juste a 1234 (et pas par ce qui est pointé par 1234)
même syntaxe, 2 comportements différent pour moi
d'ou -> pas logique

En effet, ce n’est pas logique. Comme pea/lea en fait.
C’est pas idiot ce que tu proposes :
jmp #1234 devrait jumper à 1234
jmp 1234, voire jmp (1234) devraient jumper au contenu de 1234.

Et la on attaque les mnémoniques :
jmp.w 1234 devrait lire le word commençant à 1234, alors que certains assembleurs décodent « jmp (1234).w », forme que je trouve très étrange.