L'ARM a connu une progression:
- Une architecture d'instructions 32 bits, avec un code plus volumineux que beaucoup d'autres architectures, mais pouvant être décodée rapidement et permettant d'effectuer de nombreuses opérations avec moins d'instructions que les architectures concurrentes
- Une architecture au format double instruction, qui pourrait basculer entre le jeu d’instructions ARM agréable et puissant (mais malheureusement quelque peu saturé), et un jeu d’instructions "Thumb" 16 bits moins puissant (mais beaucoup plus compact). Chaque instruction Thumb avait une instruction ARM correspondante, minimisant quelque peu la nécessité pour les programmeurs d'apprendre deux jeux d'instructions.
- Une architecture Thumb2, qui a ajouté des instructions de deux mots au jeu d'instructions Thumb, produisant ce qui est principalement avantageux pour tous: le code ARM typique contiendrait un mélange d'instructions uniquement disponibles dans ARM, et d'instructions qui auraient été disponibles dans Thumb. mais devait être représenté comme 32 bits de toute façon; dans Thumb2, un tel code tire parti des avantages d'espace du remplacement de certaines instructions 32 bits par des instructions 16 bits.
- Une architecture exclusivement basée sur le pouce, qui est plus contraignante que je ne l'aimerais, mais qui est plus petite et moins chère que toutes les autres.
L'architecture ARM permet d'effectuer très rapidement certaines opérations sophistiquées, beaucoup plus rapidement que sur n'importe quelle autre puce. Par exemple (en utilisant ARM7-TDMI):
ldrh r0, [r10, # ADDR_BUS_OFS]; Lire le bus d'adresse système cible (13 bits)
ldrb r1, [r9, r0, lsr # 8]; Utiliser les bits supérieurs pour rechercher une adresse dans un tableau de gestionnaires
ajoutez pc, r9, r1 lsl # 2; Aller au gestionnaire approprié
Chaque gestionnaire est stocké sous forme d'octet, ce qui donne 1/4 du déplacement d'adresse à partir du début de la table. L’effet net est que, une fois que le contenu du bus d’adresses a été extrait, il ne faut que six cycles (deux instructions) pour accéder à un gestionnaire basé sur les cinq bits supérieurs de l’extraction, à l’aide d’une table de sauts de 32 octets.
Le code THUMB correspondant ressemblerait davantage à:
; En supposant que nous n’avons pas besoin de r6 / r7 pour autre chose, ils sont réaffectés à partir de r9 / r10.
ldrh r0, [r7, # ADDR_BUS_OFS]
mov r1, r0
lsr r1, r1, n ° 8; THUMB exige que la source et la destination soient identiques
ldrb r1, [r6, r1]
lsl r1, r1, n ° 1; Peut utiliser shift-left-two, si les adresses cibles sont alignées sur le mot entier
ajouter pc, r1
C'est très bien du point de vue de la densité du code, étant donné que les instructions ne sont que la moitié de celles des originaux, mais qu'il faudrait neuf cycles après l'extraction au lieu de six. Dans une application où le bus surveillé fonctionnera à son rythme, que l'ARM ait ou non réussi à le gérer, les instructions ARM plus rapides sont un avantage considérable.
Incidemment, Thumb2 est compatible binaire avec Thumb, ce qui facilite l'utilisation des outils précédents, mais signifie qu'il y a certaines choses qu'il ne peut pas faire aussi bien que l'ARM d'origine. Par exemple, dans ARM, on pourrait "faire pivoter" un bitmap 8x8 dans quatre registres en utilisant environ 3 instructions sur deux bits:
movs r0, r4, lsl # 25; Placez le bit supérieur de LSB en C et le bit suivant en N
orrcs r6, # 0x00000001
orrmi r6, # 0x00000100
Dans Thumb2, il serait nécessaire d'ajouter des instructions conditionnelles explicites:
movs r0, r4, lsl # 25; Placez le bit supérieur de LSB en C et le bit suivant en N
itcs
orrcs r6, # 0x00000001
itmi
orrmi r6, # 0x00000100
Réduction nette de 33% de l'efficacité en termes de temps et d'espace par rapport à ARM; il s'agit probablement d'un exemple du pire cas où le code du pouce est moins efficace qu'ARM, et même ce n'est pas vraiment horrible.
Un autre léger inconvénient de Thumb2 par rapport à ARM: dans le code ARM, toutes les instructions commencent par des limites de mots complets, facilitant ainsi l’analyse statique. Dans Thumb2, les instructions peuvent commencer arbitrairement aux limites d'un demi-mot et chevaucher les limites d'un mot entier. L'analyse statique peut donc être beaucoup plus difficile.