Conversion de code ARM en 68000

Cette page traite de la conversion de programmes écrits en assembleur ARM (architecture ARM7/ARMv4) vers l'assembleur Motorola 68000. L'ARM et le 68000 sont tous deux des microprocesseurs RISC/CISC 32 bits, mais leurs philosophies de conception diffèrent significativement : l'ARM est un microprocesseur RISC a ensemble d'instructions fixe de 32 bits avec exécution conditionnelle intégrée, tandis que le 68000 est un microprocesseur CISC a instructions de longueur variable.

Différences fondamentales entre ARM et 68000

Différences clefs pour la conversion :

• Architecture load/store vs mémoire-mémoire : L'ARM ne peut accéder à la mémoire que via LDR (load) et STR (store). Toutes les opérations arithmétiques/logiques travaillent sur des registres uniquement. Le 68000 peut opérer directement sur la mémoire (ADD.L d(An),Dn par exemple). Lors de la conversion, les séquences LDR+operation+STR de l'ARM peuvent souvent être remplacées par une seule instruction 68000 travaillant directement en mémoire.
• Exécution conditionnelle : Sur ARM, presque toute instruction peut être conditionnelle (suffixe de condition : ADDEQ, MOVNE,...). Le 68000 n'a que les instructions Bcc (branchement conditionnel) et Scc (positionnement conditionnel). Les instructions ARM conditionnelles doivent être converties en séquences Bcc + instruction sur le 68000.
• Barrel shifter intégré : Sur ARM, le second opérande peut être décalé/tourné avant l'opération (ADD R0, R1, R2, LSL #3). Le 68000 n'a pas cette fonctionnalité. Il faut décomposer en un décalage suivi de l'opération.
• Mise a jour des drapeaux : Sur ARM, les drapeaux ne sont mis a jour que si le suffixe S est présent (ADDS, SUBS,...). Sur le 68000, la plupart des instructions mettent a jour les drapeaux automatiquement. Cela peut causer des problèmes si le code ARM dépend de drapeaux non modifies entre deux instructions.
• Registres : L'ARM a 16 registres généraux (R0-R15) dont R13 (SP), R14 (LR) et R15 (PC) ont des rôles spéciaux. Le 68000 sépare les registres en données (D0-D7) et adresses (A0-A7). Certains registres ARM a usage général doivent être cartographiés sur des registres d'adresse du 68000 s'ils servent de pointeurs.

Correspondance des registres

Notes sur la correspondance :

• R0-R7 → D0-D7 : cartographie naturel car l'ARM utilise R0-R7 principalement pour les données. Les opérations arithmétiques et logiques ARM sur R0-R7 se convertissent directement en opérations sur D0-D7.
• R8-R12 → A0-A4 : les registres hauts de l'ARM servent souvent de pointeurs ou de variables préservées. Ils sont cartographiés sur les registres d'adresse du 68000. Si un registre ARM haut est utilise pour des calculs arithmétiques, il faut utiliser un registre Dn temporaire sur le 68000 car les registres An ne supportent pas toutes les opérations.
• R14 (LR) : L'ARM stocke l'adresse de retour dans LR lors d'un BL (Branch with Link). Le 68000 empile automatiquement l'adresse de retour avec BSR/JSR. Le LR n'a donc pas d'équivalent direct ; l'adresse de retour est sur la pile.
• CPSR → CCR : Les drapeaux ARM (N,Z,C,V) correspondent aux drapeaux 68000 (N,Z,C,V). Le drapeaux X du 68000 n'a pas d'équivalent direct sur ARM. Le champ mode du CPSR (bits 0-4) n'a pas d'équivalent direct car le 68000 n'a que 2 modes (user/superviseur) contre 7 pour l'ARM.

Conversion des instructions de transfert

L'ARM utilise LDR/STR pour les accès mémoire et MOV pour les transferts entre registres. Le 68000 utilise MOVE pour tout.

Chargement depuis la mémoire :

Entreposage en mémoire :

Transferts multiples (LDM/STM) :

Note : LDM/STM de l'ARM avec différents modes d'adressage (IA=Increment After, IB=Increment Before, DA=Decrement After, DB=Decrement Before) se convertissent en MOVEM avec les modes(An)+ ou -(An) du 68000. Attention : MOVEM du 68000 ne supporte que (An)+ pour la lecture et -(An) pour l'écriture.

Chargement d'adresses :

Note : ARM utilise souvent LDR Rn, =constante pour charger des constantes 32 bits depuis un bassin (littéral de bassin). Le 68000 charge directement les constantes 32 bits en mode immédiat.

Conversion des instructions arithmétiques

Note importante : Sur ARM, les instructions a 3 opérandes (ADD R0, R1, R2) placent le résultat dans un registre différent des sources. Sur le 68000, les opérations sont a 2 opérandes (ADD.L D2,D0 modifie D0). Il faut donc souvent ajouter un MOVE.L préalable pour préserver l'opérande source.

Si R0 = R1 (destination = première source), le MOVE.L est inutile et la conversion est directe :

• ADD R0, R0, R2 → ADD.L D2, D0

Conversion des instructions logiques et décalage

Barrel shifter combine (spécificité ARM) :

Note : Le barrel shifter intégré de l'ARM est l'une des différences les plus significatives. Chaque instruction ARM avec un opérande décalé nécessite un registre temporaire et une instruction de décalage supplémentaire sur le 68000. D7 est souvent utilise comme registre temporaire pour cela.

Conversion des instructions de branchement

Branchements conditionnels :

Note sur les conditions : Les conditions ARM et 68000 utilisent les mêmes noms pour les mêmes tests logiques. La correspondance est directe car les deux processeurs utilisent les mêmes drapeaux (N,Z,C,V) avec la même sémantique pour les branchements.

Boucles :

Note : DBRA du 68000 décrémenté un compteur 16 bits et boucle si le résultat n'est pas -1. Pour des compteurs 32 bits, utiliser SUBQ.L #1,Dn / BNE .boucle.

Conversion des modes d'adressage

L'ARM a un nombre limite de modes d'adressage pour LDR/STR. Le 68000 a 14 modes d'adressage utilisables avec la plupart des instructions.

Accès aux tableaux :

Conversion des instructions de pile et appels

Convention d'appel AAPCS (ARM) :

Note : La convention d'appel ARM (AAPCS) passe les 4 premiers arguments dans R0-R3, le reste sur la pile. La convention C classique du 68000 passe tout sur la pile. Lors de la conversion, les arguments dans les registres ARM doivent être empilés pour le 68000, ou bien on peut adopter une convention registre personnalisée pour le 68000 (D0-D3 pour les arguments).

Prologue/épilogue de fonction :

Accès aux paramètres et variables locales :

Sauvegarde/restauration de registres :

Conversion des instructions spécifiques ARM

Swap (SWP) :

Multiplication longue (UMULL, SMULL, UMLAL, SMLAL) :

CLZ (Count Leading Zeros, ARMv5+) :

MRS/MSR (accès au registre d'état) :

SWI (Software Interrupt) :

Instructions Thumb (jeu d'instructions 16 bits) :

Le mode Thumb de l'ARM utilise des instructions 16 bits pour une meilleure densité de code. Le 68000 n'a pas d'équivalent direct. Les instructions Thumb doivent être converties dans leur forme ARM équivalente, puis converties en 68000.

Conversion de l'exécution conditionnelle ARM

L'exécution conditionnelle est une caractéristique majeure de l'ARM. Presque toute instruction peut être rendue conditionnelle par un suffixe (EQ, NE, CS, CC, MI, PL, VS, VC, HI, LS, GE, LT, GT, LE, AL).

Méthode de conversion :

Optimisation avec Scc du 68000 :

Note : L'exécution conditionnelle ARM évite les branchements (bénéfique pour le pipeline ARM). Sur le 68000, les branches courtes (BCC.S) avec un déplacement 8 bits sont efficaces et le coût de la conversion est faible.

Exemples complets de conversion ARM → 68000

Exemple 1 : Longueur d'une chaîne (strlen)

Exemple 2 : Copie de mémoire (memcpy)

Exemple 3 : Recherche dichotomique (binary search)

Exemple 4 : Inversion d'endianness (utile pour le portage)

Exemple 5 : Factorielle récursive

Tableau récapitulatif des différences ARM → 68000

Résumé

La conversion de code ARM en 68000 présente des défis spécifiques liés aux différences fondamentales entre architectures RISC et CISC. Voici les points clefs :

• Architecture load/store : Les séquences ARM LDR + operation + STR peuvent souvent être remplacées par une seule instruction 68000 opérant directement en mémoire. Cela réduit le nombre d'instructions mais change la structure du code.
• Opérandes a 3 registres : Les instructions ARM a 3 opérandes (ADD Rd, Rn, Op2) nécessitent un MOVE.L préalable sur le 68000 quand la destination diffère de la première source. Quand Rd = Rn, la conversion est directe.
• Barrel shifter : Le décalage intégré dans l'operande 2 de l'ARM n'a pas d'équivalent sur le 68000. Il faut décomposer en une instruction de décalage + l'opération, en utilisant un registre temporaire (typiquement D7).
• Exécution conditionnelle : Les instructions conditionnelles ARM doivent être converties en séquences Bcc.S + instruction sur le 68000. Pour une instruction isolée, le coût est faible (2 octets pour le BCC.S). Pour des séquences conditionnelles, regrouper sous un seul branchement.
• Correspondance des registres : R0-R7 -> D0-D7 pour les données, R8-R12 → A0-A4 pour les pointeurs. R13(SP) → A7, R14(LR) n'a pas d'équivalent (adresse de retour sur pile), R15(PC) → PC.
• Conventions d'appel : L'ARM passe les 4 premiers arguments dans R0-R3 (AAPCS), le 68000 les passe typiquement sur la pile. BL → BSR/JSR, BX LR → RTS. LINK/UNLK remplacent la gestion manuelle du frame pointer ARM.
• Transferts multiples : LDM/STM de l'ARM se convertissent en MOVEM du 68000. Attention : MOVEM ne supporte que les modes (An)+ et -(An), pas les variations IA/IB/DA/DB de l'ARM. LDMIA/STMDB sont les plus courants et se convertissent directement.
• Drapeaux et conditions : Les drapeaux N,Z,C,V sont les mêmes sur les deux architectures. La différence majeure est que les drapeaux ARM ne sont mis a jour que si le suffixe S est présent, tandis que le 68000 les met a jour automatiquement. Vérifier que le code ne dépend pas de drapeaux non modifiés.
• Endianness : L'ARM est souvent en little-endian tandis que le 68000 est big-endian. Pour les données binaires (fichiers, protocoles réseau), inverser l'ordre des octets avec la séquence ROL.W #8 + SWAP + ROL.W #8.
• Multiplication/Division : L'ARM a MUL 32x32->32 mais pas de division matérielle. Le 68000 a DIVU/DIVS 16 bits mais pas de multiplication 32 bits (sauf 68020+). Les deux architectures nécessitent des routines logicielles pour les opérations dépassant leurs capacités matérielles.