Forum TI-Planet.org

Il y a peu, je me suis lancé dans l'apprentissage de l'assembleur ARM. Etant donné le peu d'informations en français sur le sujet, je propose de vous détailler au mieux mes quelques "fraîches" connaissances et expériences . J'espère que cela vous incitera à vous lancer, vous aussi, dans l'aventure
A présent, entrons dans le vif du sujet !..




Elaborer un programme, l'assembler sur quelle machine ? Avec quel logiciel ?
Une chose est sûre : nous voulons programmer pour la TI-nspire (dotée de Ndless). Ce qui l'est moins, c'est la façon dont nous allons nous y prendre...Alors qu'un simple éditeur de texte suffit pour, dans un premier temps, rédiger notre programme, il nous faut ensuite pouvoir l ' "assembler" (c'est-à-dire transcrire ce texte en langage machine) au moyen d'un logiciel ou application appelé(e)...assembleur Personnellement, j'ai fait au plus simple : utiliser GNU Assembler (gas) sur mon raspberry (Hé oui, les raspberry 1,2 ou 3 ont dans le ventre un processeur... ARM )
(...)

Les 16 registres généraux 32 bits
- r0 à r12 : sans restriction particulière
- r13 (ou sp pour "stack pointer") : conventionnellement choisi comme pointeur de pile
- r14 (ou lr pour "link register") : réservé lors d'appel de sous-programme (contient l'adresse de retour)
- r15 (ou pc pour "program counter") : compteur ordinal (contient l'adresse de la prochaine instruction à exécuter)


Le registre d'état CPSR
Il contient notamment les bits de condition N,Z,C,V altérés selon les résultats des précédentes opérations (arithmétiques,logiques,de comparaison ou de transfert) :

- N (Negative) : à 1 si le résultat de l'opération est négatif, sinon à 0 (copie du bit 31 du résultat)
- Z (Zero) : à 1 si le résultat de l'opération est nul, sinon à 0
- C (Carry) : retenue sortante lors d'une opération d'addition ou soustraction; dernier bit sorti après une opération de décalage
- V (oVerflow) : dépassement de capacité lors d'une opération d'addition ou soustraction


Le rôle du suffixe "s"
Les instructions de comparaison (cmp,cmn,tst,teq) affectent naturellement les bits de condition. Les instructions d'assignation de registre (mov, mvn...) et de calculs peuvent agir de même grâce à l'ajout du suffixe "s".

Exemple:

Code: Select all

adds r0,r1,r2

Le résultat de cette addition affectera les bits de condition du registre CSPR


La puissance des extensions conditionnelles
Il est tout à fait possible de rendre uncertaine l'exécution d'une instruction rien qu'en fonction des bits de conditions ! Il suffit d’insérer entre celle-ci et son éventuel suffixe "s" l'une des 16 extensions conditionnelles suivantes:

Extensions ------------------------------- hi cc ou lo cs ou hs ls eq ne gt lt ge le mi pl vs vc

Significations ---------------------------- > < ≥ ≤ = (signé) ≠ (signé) > signé < signé ≥ signé ≤ signé négatif positif ou nul avec dépassement sans dépassement

Bits concernés --------------------------------------------------- (C=1 et Z=0) C=0 C=1 (C=0 et Z=1) Z=1 Z=0 (Z=0 et V=1) (N=1 et V=0) ou (N=0 et V=1) (N=1 et V=1) ou (N=0 et V=0) z=1 ou (N=1 et V=0) ou (N=0 et V=1) N=1 N=0 V=1 V=0

Exemple :

Code: Select all

adds     r0,r0,#-8
add      r3,r4,r4
addmi   r0,r1,r2

La dernière instruction stocke dans r0 la somme de r1 et r2 seulement si le résultat de la dernière opération affectant le CSPR (en l’occurence adds r0,r0,#-8) s’est avéré négatif


Le jeu d'instructions de l'ARM926EJ-S

Tout d'abord, quelques précisions sur les opérations de lecture/écriture en mémoire:
- les instructions ldr et str travaillant d'ordinaire avec des mots (32bits) peuvent optionnellement travailler sur des demi-mots (16bits) voire des octets (8bits) grâce à l'emploi de ces 4 suffixes:

h demi-mot non signé
sh demi-mot signé
b octet non signé
sb octet signé

-lors d'une lecture (via l'instruction ldr, ldm) ou écriture (via l'instruction str, stm) de donnée(s) en mémoire, le processeur ARM n'accepte pas l'emploi de "valeur immédiate" en tant que donnée, ni en tant qu'adresse-mémoire. D'où le recours systèmatique aux registres...
- Une l'instruction de lecture/écriture sera donc suivie d' un registre , puis l'un des modes d'adressage.

Les différents modes d'adressages

1)L'adressage avec déplacement relatif immédiat optionnel : [r0,#±valeur12bits]
Après exécution, r0 reste inchangé

Exemples:

Code: Select all

ldr r1,[r0]
ldr r1,[r0,#0]

stocke dans le registre r1 la valeur 32 bits contenue en adresses-mémoire r0,r0+1,r0+2 et r0+3 (car 4 octets )

Code: Select all

ldrb r11,[r5,#+12]
ldrb r11,[r5,#12]

stocke dans le registre r11 la valeur 8 bits contenue en adresse-mémoire r5+12

Code: Select all

ldrh r4,[r7,#-9]

stocke dans le registre r4 la valeur 16 bits contenue en adresses-mémoire r7-9 et r7-8 (car 2 octets)


2) L'adressage avec déplacement relatif immédiat pré-indexé: [r0,#±valeur12bits]!
Le décalage n'est pas optionnel ; après exécution, r0 = r0±valeur12bits

Exemple:

Code: Select all

ldr r10,[r6,#16]!

stocke dans r10 la valeur 32 bits contenue en adresses-mémoire r6+16, r6+17, r6+18 et r6+19 ; mets à jour r6 en l'incrémentant de 16 (c-à-d r6=r6+16)


3) L'adressage avec déplacement relatif immédiat post-indexé: [r0],#±valeur12bits
Seul r0 représente l'adresse-mémoire, la mise-à-jour de r0 s'effectue après exécution (r0=r0±valeur12bits)

Exemple:

Code: Select all

ldr r10,[r6],#16

stocke dans r10 la valeur 32 bits contenue en adresses-mémoire r6, r6+1 r6+2 et r6+3 (car 4 octets) ; ensuite, mets à jour r6 en l'incrémentant de 16 (c-à-d r6=r6+16)


4) L'adressage avec déplacement par registre (décalé ou non) : [r0,r1,type_de_décalage #valeur]

5 types de décalage sont disponibles :
- lsl#n : décalage logique de n bits vers la gauche (avec 1≤n≤31)
- lsr#n : décalage logique de n bits vers la droite (avec 1≤n≤32)
- asr#n : décalage arithmétique de n bits vers la droite (avec 1≤n≤32)
- ror#n : rotation de n bits vers la droite (avec 1≤n≤31)
- rrx : rotation d'1 bit vers la droite (bit de condition C = bit sortant)

Exemples:

Code: Select all

ldrb r7,[r0,r1]

stocke dans r7 la valeur 8 bits contenue en adresse-mémoire r0+r1

Code: Select all

ldrh r1,[r5,r9,lsl#3]

stocke dans r1 la valeur 16 bits contenue en adresses-mémoire r5+(r9*8) et r5+(r9*8)+1


5) L'adressage avec déplacement par registre (décalé ou non) pré-indexé : [r0,r1,type_de_décalage #valeur]!

Exactement comme l'adressage précédent, MAIS avec mise-à-jour de r0 après exécution

Exemples:

Code: Select all

ldrb r7,[r0,r1]!

stocke dans r7 la valeur 8 bits contenue en adresse-mémoire r0+r1 ; puis r0=r0+r1

Code: Select all

ldrh r1,[r5,r9, lsl#3]!

stocke dans r1 la valeur 16 bits contenue en adresses-mémoire r5+(r9*8) et r5+(r9*8)+1 ; puis r5=r5+(r9*8)


6) L'adressage avec déplacement par registre (décalé ou non) post-indexé : [r0],r1,type_de_décalage #valeur

Exemples:

Code: Select all

ldrb r7,[r0],r1

stocke dans r7 la valeur 8 bits contenue en adresse-mémoire r0 ; puis r0=r0+r1

Code: Select all

ldrh r1,[r5],r9, lsl#3

stocke dans r1 la valeur 16 bits contenue en adresses-mémoire r5 et r5+1 ; puis r5=r5+(r9*8)


ldm et stm ...Ou comment transférer un bloc de mémoire grâce aux registres !

Le processeur ARM ne comporte pas d'instruction dédiée au transfert de bloc de mémoire.
Il existe, cependant, l'instruction ldm permettant de charger dans plusieurs registres (comme "placés en file indienne") le contenu d'une zone-mémoire. Inversement, stm permet de transférer en une zone-mémoire le contenu respectif de chacun des registres.


(...)


(merci à Azher pour l'affichage en format tableau )

J'attends la suite avec impatience, je me suis mis à l'assembleur ARM depuis environ 2 mois, mais ton programme ne peut être compilé avec nAssembly, car l'instruction .WORD n'est pas encore "comprise"

à la place de .word , tu peux mettre .long
c'est comme .hword (valeur 16bits) qui peut être aussi remplacé par .short

Tu me fais penser que je devrais comparer nAssembler à mon assembleur sous linux (GNU Assembler), histoire de résoudre les problèmes de compatibilité (bref: trouver les directives communes)

et .long est compris par nAssembly

Non, je ne pense pas car je ne l'ai vu nulle part dans le code source de nAssembler.
Mais j'ai remarqué que nAssembler propose des directives équivalentes à .byte et .long (ou .word) : respectivement dcb (pour des données 8bits) et dcd (pour des données 32bits)
Par contre, pour ce qui est des données 16bits, je ne vois pas ce qui devrait être "dcw" dans le code-source...ça n'a pas l'air d'être géré par nAssembler.

Voici le manuel qui me sert de référence : http://www.keil.com/support/man/docs/ar ... 005584.htm

Oh, un lien très intéressant
Ok, je vais tester ton programme en l'adaptant.
Le .word stocke des données 16 bits non? Donc je ne vais pas pouvoir le faire, si tu n'as pas vu de dcw

Non, .word c'est pour déclarer des données 32 bits.
Voici un résumé:

Assembleur \ Déclaration de données...	8 bits	16 bits	32 bits
nAssembler	dcb	?	dcd
Armasm	dcb	dcw	dcd
GNU Assembler (gas)	.byte	.hword ou .short	.word ou .long

Voilà déjà une raison pour se concentrer sur un et un seul assembleur!
Sinon, tout s'embrouille très vite!

Serait-il possible que tu en fasses une version pdf?

Et aussi, tu saurais utiliser les syscalls, comme celle permettant d'afficher un caractère à l'écran? Je ne trouve nulle part, de documentation sur les syscalls du processeur ARM926EJ-S

Non, je ne sais rien sur les syscalls de la TI-nspire. En attendant, j'ai commencé à écrire mes propres routines d'affichage...
à ce propos, j'essaye de trouver une manière d'afficher ne nécessitant pas trop de données (parce qu'entrer tout un code ASCII en binaire, bonjour la migraine ) . L'affichage de type "segments" c'est bien pour les chiffres, moins bien pour les lettres...
L'idéal serait de trouver où se cachent les données (hypothétiques) des caractères utilisés par la TI-nspire

PS: c'est pas mal le site que tu as trouvé : https://www.root-me.org/fr/Documentatio ... assembleur