Pourquoi avons-nous besoin d'un langage d'assemblage?

Nous écrivons principalement des programmes dans un langage de haut niveau. Alors pendant mes études, je suis tombé sur un langage d'assemblage. Un assembleur convertit donc le langage d'assemblage en langage machine et un compilateur fait de même avec un langage de haut niveau. J'ai trouvé que le langage d'assemblage contient des instructions comme déplacer r1 r3, déplacer un 5, etc. Et c'est assez difficile à étudier. Alors pourquoi le langage d'assemblage a-t-il été créé? Ou était-ce celui qui est venu en premier avant même le langage de haut niveau? Pourquoi est-ce que j'étudie les assembleurs dans mon cours d'ingénierie informatique?

"Alors pourquoi le langage d'assemblage a-t-il été créé?"

Le langage d'assemblage a été créé en tant que raccourci exact pour le codage au niveau de la machine, afin que vous n'ayez pas à compter les 0 et les 1 toute la journée. Il fonctionne de la même manière que le code au niveau de la machine: avec des instructions et des opérandes.

"Lequel est venu en premier?"

Wikipedia a un bon article sur l' histoire des langages de programmation

"Pourquoi est-ce que j'étudie les assembleurs dans mon cours d'ingénierie informatique?"

Bien que ce soit vrai, vous ne vous trouverez probablement pas en train d'écrire l'application de votre prochain client dans l'assemblage, il y a encore beaucoup à gagner à apprendre l'assemblage.

Aujourd'hui, le langage d'assemblage est utilisé principalement pour la manipulation directe du matériel, l'accès à des instructions de processeur spécialisées ou pour résoudre des problèmes de performances critiques. Les utilisations typiques sont les pilotes de périphériques, les systèmes embarqués de bas niveau et les systèmes en temps réel.

Le langage d'assemblage est aussi proche du processeur que possible en tant que programmeur, donc un algorithme bien conçu est flamboyant - l'assemblage est idéal pour optimiser la vitesse. C'est une question de performance et d'efficacité. Le langage d'assemblage vous donne un contrôle complet sur les ressources du système. Tout comme une chaîne d'assemblage, vous écrivez du code pour pousser des valeurs uniques dans des registres, vous traitez les adresses mémoire directement pour récupérer des valeurs ou des pointeurs. (source: codeproject.com )

Pourquoi avons-nous besoin d'un langage d'assemblage?

Eh bien, il n'y a en fait qu'une seule langue dont nous aurons besoin , appelée "langage machine" ou "code machine". Cela ressemble à ceci:

0010000100100011

C'est la seule langue que votre ordinateur peut parler directement. C'est la langue parlée par un CPU (et techniquement, différents types de CPU parlent des versions différentes). Ça craint aussi de regarder et d'essayer de comprendre.

Heureusement, chaque section de binaire correspond à une signification particulière. Il est divisé en plusieurs sections:

0010|0001|0010|0011

operation type  source register  other source  destination register
0010            0001             0010          0011

Ces valeurs correspondent à:

operation type 0010 = addition
source register 0001 = register 1
other source 0010 = register 2
destination register 0011 = register 3

Donc, cette opération ajouterait les nombres dans les registres 1 et 2 et mettrait cette valeur dans le registre 3. Si vous placez littéralement ces valeurs dans un CPU et lui dites "go", cela ajoutera deux nombres pour vous. L'opération "soustraire" pourrait être un 0011 ou quelque chose, au lieu de 0010 ici. Quelle que soit la valeur, le CPU fera une soustraction.

Donc, un programme pourrait ressembler à ceci (n'essayez pas de le comprendre, car j'ai créé cette version particulière du code machine pour expliquer les choses):

instruction 1: 0010000100100011
instruction 2: 0011000110100100
instruction 3: 0101001100010111
instruction 4: 0010001001100000

Est-ce que ça craint de lire? Absolument. Mais nous en avons besoin pour le CPU . Eh bien, si chaque code machine correspond à une action particulière, faisons simplement un raccourci "anglais", puis une fois que nous comprenons ce que fait le programme, convertissez-le en vrai code machine binaire et donnez-le au CPU pour qu'il s'exécute.

Ainsi, nos instructions d'origine ci-dessus pourraient ressembler à:

(meaning)      operation type  source register  other source  destination register
(machine code) 0010            0001             0010          0011
("English")    add             r1               r2            r3

Notez que cette version anglaise a une correspondance exacte avec le code machine . Ainsi, lorsque nous écrivons une ligne de cet «anglais», nous écrivons vraiment un code machine plus convivial et plus compréhensible.

Eh bien, c'est du langage d'assemblage. C'est pourquoi il existe et pourquoi il a été créé à l'origine.

Pour comprendre pourquoi nous en avons besoin maintenant, lisez les réponses ci-dessus, mais la clé à comprendre est la suivante: les langages de haut niveau n'ont pas une seule représentation est le code machine. Par exemple en C, ou Python, ou autre:

z = x + y

Cela ressemble à notre ajout ci-dessus, en supposant qu'il xest dans le registre 1, yest dans le registre 2 et zdevrait se retrouver dans le registre 3. Mais qu'en est-il de cette ligne?

z = x * 2 + (y / 6) * p + q - r

Essayez de représenter cette ligne en 16 bits de binaire et de dire à un CPU "go". Tu ne peux pas. Le code machine n'a pas d'instruction d'opération unique pour effectuer une addition, une soustraction et quoi que ce soit d'autre avec 4 ou 5 variables à la fois. Il doit donc d'abord être converti en une séquence de code machine. C'est ce que vous faites lorsque vous "compilez" ou "interprétez" un langage de haut niveau.

Eh bien, nous avons des programmes pour le faire, alors pourquoi avons-nous besoin d'assemblage maintenant? Disons que votre programme s'exécute plus lentement que prévu et que vous voulez savoir pourquoi. En regardant la "sortie" en langage machine de cette ligne, cela pourrait ressembler à ceci:

1010010010001001
0010001000010000
0110010000100100
0010001011000010
0010100001000001
0100010100000001
0010010101000100
0010101010100000
0000100111000010

Juste pour faire une seule ligne de Python. Donc vous voulez vraiment déboguer ça?!?!?! Non . Au lieu de cela, vous demandez à votre compilateur de bien vouloir vous fournir le résultat sous la forme que vous pouvez réellement comprendre facilement, qui est la version du langage d'assemblage correspondant exactement à ce code machine. Ensuite, vous pouvez déterminer si votre compilateur fait quelque chose de stupide et essayer de le réparer.

(Remarque supplémentaire sur les conseils de @ Raphael: vous pouvez réellement construire des processeurs qui fonctionnent avec des choses autres que les codes binaires, comme les codes ternaires (base 3) ou décimaux, ou même ASCII. Pour des raisons pratiques, nous avons vraiment collé au binaire.)

Alors pourquoi le langage d'assemblage a-t-il été créé? ou était-ce celui qui est venu en premier avant même le langage de haut niveau?

Oui, l'assemblage a été l'un des premiers langages de programmation à utiliser du texte comme entrée, par opposition aux fils de soudure, à l'aide de cartes enfichables et / ou de commutateurs à bascule. Chaque langage d'assemblage a été créé pour un seul processeur ou famille de processeurs, les instructions étant directement mappées aux opcodes exécutés par le processeur.

Pourquoi est-ce que j'étudie les assembleurs dans mon cours d'ingénierie informatique?

Si vous devez programmer des pilotes de périphérique ou écrire des compilateurs, comprendre le fonctionnement d'un processeur est inestimable, sinon nécessaire. La meilleure façon de comprendre cela est d'écrire du code dans l'assembly.

Si vous regardez comment un compilateur écrit du code, il est courant de voir des options pour appeler des conventions qui, sans connaître l'assembly, ne peuvent probablement pas être comprises.

Si vous devez résoudre un bogue et que la seule entrée que vous avez est un vidage de mémoire , alors vous devez absolument connaître l'assembly pour comprendre la sortie qui est le code d'assembly et, si vous êtes chanceux, augmenté avec des déclarations de niveau supérieur d'un langage de haut niveau.

Permettez-moi d'ajouter un aspect moins pratique. Ce n'est (probablement) pas une raison historique mais une raison pour vous, aujourd'hui.

L'assemblage (par rapport aux langages de haut niveau) est nu . Il ne cache rien (ce qui se fait dans le logiciel), et il est simple en ce sens qu'il a un ensemble d'opérations fixe relativement petit.

Cela peut être utile pour une analyse exacte de l'algorithme. La sémantique et le flux de contrôle sont si simples que le comptage de toutes les opérations (ou le nombre attendu) peut être effectué en annotant le graphique du flux de contrôle avec les nombres de transitions (probabilités). Knuth fait cela dans ses livres TAoCP avec grand effet, démontrant certaines des analyses d'algorithmes les plus rigoureuses qui soient.

Anecdote: mon collègue a appris à lire Java Bytecode dans ce but précis.

Il y a des réponses ici:

• Quand avons-nous besoin d'un langage d'assemblage? sur Programmers.SE

• Pourquoi le langage d'assemblage est toujours nécessaire si nous avons des langages de haut niveau offrant des outils sophistiqués? sur Stackoverflow

• Pourquoi étudier la langue de l'assemblage? par Gary L. Burt

Toutes ces réponses indiquent:

• Optimisation vitesse / mémoire
• Comprendre le fonctionnement de la machine
• Les programmeurs Noob deviennent des experts
• Si vous connaissez l'assemblage, vous savez comment écrire des compilateurs pour votre langage High Lvl
• etc

Assembly = code machine
Certaines personnes ne cessent de répéter en quoi le langage d'assemblage est différent des codes numériques que le CPU comprend.
Cela (bien que vrai) manque complètement le point.
En ce qui concerne la traduction, le langage d'assemblage et le numérique (binaire, hexadécimal) sont une seule et même chose.

Grok it or drop it
Si vous grok assemblez vous savez comment fonctionne un ordinateur réel.
assemblage grokking implique:

• Apprendre les instructions et leur signification (duh).
• Comprendre ce que fait l'instruction, ce qu'elle ne fait pas et tous ses effets secondaires .
• Apprendre comment une CPU traite les instructions
  • Fonctionnement du pipeline.
  • Que multiscalarsignifie
  • Qu'est-ce qu'un cœur de processeur?
  • Fonctionnement du cache.
  • Comprendre comment compter le cycle
  • apprendre les enseignements d'Agner Fog
• Comprendre comment les compilateurs génèrent du code et comment ils échouent parfois.
• Optimiser des problèmes bien définis et très spécifiques.

Si vous grok assemblez, vous avez bien une image presque complète du fonctionnement du CPU connecté à votre clavier.
Vous devez utiliser ces connaissances comme un chirurgien du cerveau utilise son scalpel.

Pas besoin d'abstractions puantes
À moins de grogner l'assemblage (et donc le CPU sur la table d'opération), vous ne serez jamais libéré des griffes des abstractions de la machine RAM (ou que Dieu interdise à la machine Turing l'horreur ).

L33t Hax0r 5k1llz
Assembly vous aide également à comprendre comment le 133thax0r parvient à déjouer les schémas de protection. (Q: pourquoi l'ASLR ne fonctionne- t - mov rax,fs:[28h]il pas ? Car il le casse ).

Le 0,1%
Ce n'est pas la connaissance de l'assemblage qui compte, mais la connaissance de la machine sur laquelle vous travaillez qui compte.
Si vous voulez connaître la machine, vous devez la comprendre et cela signifie parler la langue de la machine.

Si vous ne le faites pas, vous êtes coincé avec l'abstraction.
C'est de la science et c'est bien, mais ce n'est jamais le tableau complet.

C'est comme apprendre à parler Xhosa
À moins que vous ne visiez le niveau de gourou, restez fidèle à ce que vous savez, ces clics compliqueront votre vie .

Parce que c'est drôle.

À ce jour, j'ai d'abord appris RPG II à l'aide d'un IBM System 32, puis plus tard APL sur un 370. J'étais avant tout question de taille et de vitesse. Mon mantra était plus petit et plus rapide. L'assemblage est le langage le plus compact et le plus rapide du marché. Je ferais des programmes de test en C et en Assembly. Lorsque les programmes C nécessiteraient des centaines de Ko, un programme d'assemblage équivalent serait souvent inférieur à 5 Ko. Lorsque j'étudiais la sortie du compilateur C, je trouvais du code qui vérifierait et revérifierait les paramètres pour effectuer des vérifications conditionnelles des erreurs possibles qui étaient assez souvent rares et exotiques et assez inutiles, tout cela prenait du temps, mais le plus gros gonflement de la mémoire passait absolument tout vers et depuis la pile.

Dans l'environnement de programmation d'aujourd'hui, l'écriture de code offre un niveau supplémentaire de sécurité et de protection. Être capable de lire des informations directement à partir d'un matériel qui n'est pas accessible aux langages de haut niveau, vous permet de crypter avec Assembly d'une manière qu'un programme ne peut être utilisé que sur cette machine particulière. Par exemple, crypter une clé utilisateur à l'aide de l'adresse MAC de l'interface réseau, puis stationner cette clé sur un secteur spécifique non enregistré du disque dur, puis marquer le secteur comme mauvais afin que les autres fichiers ne puissent pas l'écraser. Bien sûr, vous perdez le secteur, mais qu'est-ce que c'est? 2048 ou 4096 octets sur des milliards ou des milliards?