Cette page décrit l'assembleur du YASEP (c'est à dire le programme qui transforme les instructions en code binaire) ainsi que les conventions de langage (la syntaxe) permettant d'écrire un logiciel pour le YASEP. Pour obtenir des informations sur une instruction en particulier, consultez la carte des opcodes.
Cette page couvre les points suivants :
L'assembleur du YASEP est constitué de deux couches :
L'instruction est l'unité de base d'un programme, à la manière d'un atome.
* Pour le YASEP, cela consiste en un mot de 16 ou 32 bits, contenant différents champs
qui indiquent ce qu'il faut faire avec quoi.
* Pour l'assembleur, une instruction est une ligne de texte qui contient tous ces champs
sous une forme symbolique et lisible.
Une instruction contient typiquement :
La structure binaire des instructions est expliquée ici.
Les instructions du YASEP sont assez simples mais elles ne sont pas toujours pratiques, alors certains opcodes ont besoin de modifications mineures. Ce sont souvent des dérogations mineures aux règles de codage, qui sont indiquées par des flags (les propriétés internes de chaque opcode).
L'assembleur tient compte de ces flags pour transformer le texte source en code binaire, afin de garder les instructions faciles à utiliser, lisibles et cohérentes, indépendamment de leur encodage réel, des exceptions d'encodage ou de l'architecture du processeur.
Le but du langage assembleur est d'éviter au developpeur de logiciels de garder en tête tous les details de l'architecture. Pour coder en langage assembleur avec le YASEP, il suffit de se rappeler un minimum de règles :
Et c'est tout ce qu'il y a à dire au sujet de la "syntaxe".
L'assembleur accepte 3 formats de nombres :
Les nombres sont souvent utilisés dans des contextes où le nombre de bits significatifs est limité par la taille du conteneur (habituellement, le champ immédiat d'une instruction). Quand trop de bits sont donnés, l'assembleur conserve seulement le nombre desiré de bits de poid faible, et efface les bits de poids forts. L'exemple suivant montre comment le nombre est tronqué : db 1234h.
Note : le désassembleur écrit toujours les valeurs en hexadécimal.
La capacité à créer des nombres arbitraires est souvent indispensable. L'assembleur dispose des trois pseudo-instructions suivantes :
On peut mettre autant de nombres qu'on veut (cela dépend uniquement du moteur JavaScript, pas de l'assembleur). L'interface graphique de l'assembleur n'affichera pas tout les chiffres quand plus de 32 bits seront donnés mais ils seront disponibles dans d'autres logiciels, en definissant la fonction emit_bin() comme dans l'exemple ci-dessous :
résultat:
(messages d'erreurs)
Il n'est pas encore possible d'écrire des chaînes ASCII à l'heure actuelle.
Depuis août 2008, le YASEP existe en versions 16 bits et 32 bits. Les opcodes ne changent pas mais quelques-uns ne riment à rien selon la taille des registres. Le code source peut spécifier qu'une certaine taille est utilisée, afin que l'assembleur émette un message de warning lorsqu'il rencontre un opcode invalide pour la version de YASEP attendue.
YASEP16 spécifie que le CPU est sur 16 bits. Toutes les instructions spécifiques au mode 32 bits émettent un warning.
YASEP32 spécifie que le CPU est sur 32 bits. Toutes les instructions spécifiques au mode 16 bits émettent un warning.
YASEP (par défaut) indique que le type de CPU est générique, indéfini, et toutes les instructions sont valides.
Ces pseudo-instructions ne génèrent aucun code binaire et peuvent être utilisées dans n'importe quel ordre, car elles contrôlent un flag interne. Ce flag est comparé avec les flags de toutes les instructions assemblées (voir aussi YASEP32_ONLY et YASEP16_ONLY).
L'assembleur basique reconnaît les symboles suivants et rejette tous les autres :
Pour faciliter l'écriture du code assembleur (penser à ce que le processeur doit faire et laisser à l'assembleur le choix de comment ce sera codé), il y a deux types d'alias : les alias de formes (voir ALIAS_RR, c'est à dire une écriture simplifiée de certaines formes) et les alias d'instructions (ces alias sont listés après la table des instructions). Cette section parle des alias d'instructions.
Ces alias peuvent être utilisés comme des instructions normales mais elle permettent différentes formes ou sémantiques, tout en utilisant des vraies instructions sous le capot.
Le désassembleur ne peut pas deviner toutes les substitutions pour retrouver l'alias original, donc ne vous étonnez pas si certaines instructions comme NOT ou NEG sont correctement assemblées mais le désassembleur donne un opcode différent.
Bien que les instructions soient relativement simples, elles apparaissent sous plusieurs formes différentes en langage assembleur. Cela est habituellement dû à des raisons comme :
Les différentes formes (combinaisons d'opérandes et autres champs) sont décrites ici et les flags ont aussi leur propre page.
Normalement, toutes les données inutilisées ou non initialisées sont à zéro.
Cependant, lorsque certains champs ne sont pas utilisés (par FORM_ALONE or FORM_R...), ces champs peuvent être mis à d'autres valeurs, choisies par l'assembleur. Cela pourrait réduire la consommation et les émissions radioélectriques. grâce à des techniques comme la minimisation ou l'espacement des changements d'états (toggle minimization et toggle spacing).
L'assembleur du YASEP sera capable de calculer les bonnes valeurs assez facilement et utiliser les champs ignorés par certaines instructions. Une réduction de la consommation électrique de quelques pourcent pourrait être ainsi obtenue, bien que de plus grands gains viennent d'un meilleur encodage des instruction, d'un compilateur plus intelligent et d'algorithmes plus efficaces.