Est-jeu d'instructions et langage assembleur la même chose?

https://stackoverflow.com/questions/5382130

28-10-2019
|

Question

Je me demandais si jeu et Assemblée de langue sont la même chose?

Dans le cas contraire, comment diffèrent-ils et quelles sont leurs relations?

Merci et salutations!

La solution

Je pense que tout le monde est de vous donner la même réponse. Le jeu d'instructions est le jeu (comme en mathématiques) de toutes les instructions du processeur peut exécuter ou comprendre. Assembleur est un langage de programmation.

Permettez-moi quelques exemples basés sur quelques-unes des questions que vous posez. Et je vais être sauter autour d'un processeur à avec ce code que j'ai à portée de main.

Instruction ou opcode ou langage binaire ou à la machine, quel que soit le terme que vous souhaitez utiliser pour les bits / octets qui sont chargés dans le processeur à décoder et exécutés. Un exemple

0x5C0B

Le langage assembleur, serait

add r12,r11

Pour ce processeur particulier. Dans ce cas, cela signifie que r11 = r11 + r12. Donc, je mets ce texte, le r12 ajouter, r11 dans un fichier texte et d'utiliser un assembleur (un programme qui compile / assemble assembleur) pour assembler dans une certaine forme de binaire. Comme tout langage de programmation des fichiers que vous créez parfois objet lien puis ensemble, parfois, vous pouvez aller directement à un binaire. Et il y a beaucoup de formes de binaires qui sont en ascii et binaire et un tout autre discussion.

Maintenant, que pouvez-vous faire en assembleur qui ne fait pas partie du jeu d'instructions? Comment ils diffèrent? Eh bien pour commencer, vous pouvez avoir des macros:

.macro add3 arg1, arg2, arg3

    add \arg1,\arg3
    add \arg2,\arg3

.endm


.text

   add3 r10,r11,r12

Les macros sont comme fonctions en ligne, ils ne sont pas des fonctions qui sont appelées mais génèrent du code en ligne. Pas différent d'une macro C par exemple. Ainsi, vous pouvez les utiliser pour économiser quelques ou vous pouvez les utiliser pour abstrait quelque chose que vous voulez faire encore et encore et que vous voulez la capacité de changer en un seul endroit et ne pas avoir à toucher tous les cas. L'exemple ci-dessus génère essentiellement la suivante:

add r10,r12
add r11,r12

Une autre différence entre le jeu d'instructions et de montage langage sont des instructions pseudo, pour cet ensemble d'instructions particulier par exemple il n'y a pas d'instruction pop pour sauter les choses de la pile au moins pas par ce nom, et je vais vous expliquer pourquoi. Mais vous êtes autorisé à économiser quelques secondes et utiliser un pop dans votre code:

pop r12

La raison pour laquelle il n'y a pas pop est parce que les modes d'adressage sont suffisamment souples pour avoir une lecture de l'adresse dans le registre source a mis la valeur dans le registre de destination et incrémenter le registre source par un mot. Ce qui en assembleur pour ce jeu d'instructions est

mov @r1+,r12

à la fois pop et le résultat mov dans le 0x413C opcode.

Un autre exemple des différences entre le jeu d'instructions et assembleur, la commutation des jeux d'instructions, est quelque chose comme ceci:

ldr r0,=bob

Ce qui à ce moyen de langage d'assemblage charger l'adresse de bob dans le registre 0, il n'y a pas d'instruction pour cela, ce que l'assembleur fait avec elle est de générer quelque chose qui ressemblerait à ceci si vous deviez écrire en assembleur à la main:

ldr r0,ZZ123
...
ZZ123: .word bob

Pour l'essentiel, dans un endroit accessible à partir de cette instruction, pas dans le chemin d'exécution, un mot est créé l'éditeur de liens remplira avec l'adresse de bob. L'instruction LDR également par l'assembleur ou éditeur de liens s'encodé avec un LDR d'un PC instruction relative.

Cela conduit à toute une catégorie de différences entre le jeu d'instructions et le langage assembleur

call fun

Code machine n'a aucun moyen de savoir quel plaisir est ou où le trouver. Pour cet ensemble d'instructions avec ses nombreux modes d'adressage (note que je suis spécifiquement et évitais volontairement nommer les jeux d'instructions que je utilise comme non pertinent à la discussion) l'assembleur ou éditeur de liens selon le cas peut être (selon l'endroit où les extrémités de la fonction fun en étant relatif à cette instruction).

L'assembleur peut choisir de coder cette instruction comme pc par rapport, si la fonction amusante est de 40 octets avant l'instruction d'appel, il peut coder avec l'équivalent d'appel PC + 36 (prendre quatre hors parce que le PC est un instructien avant au moment de l'exécution, ce qui est une instruction de 4 octets).

Ou l'assembleur ne peut pas savoir où ou quel plaisir est et laisser à l'éditeur de liens, et dans ce cas, l'éditeur de liens peut mettre l'adresse absolue de la chose fonction qui serait similaire à appeler # 0xD00D.

la même chose pour les charges et les magasins, certains jeux d'instructions ont près et de loin pc par rapport, certains ont l'adresse absolue, etc. Et vous ne se soucient pas de choisir, vous pouvez juste dire

mov bob,r1

et l'assembleur ou éditeur de liens ou une combinaison des deux se charge du reste.

Notez que pour certains jeux d'instructions de l'assembleur et éditeur de liens peuvent se produire à la fois dans un programme. Aujourd'hui, nous sommes habitués au modèle de compilation à des objets, puis lier des objets, mais pas tous les assembleurs suivent ce modèle.

Quelques autres cas où le langage assembleur peut prendre quelques raccourcis:

hang: b hang
  b .
  b 2f
1:
  b 1b
  b 1f
1:
  b 1b
2:

Le blocage: b hang est logique, branche à l'étiquette appelée blocage. Essentiellement une branche à l'auto. Et comme son nom l'indique ceci est une boucle infinie. Mais pour ce langage assembleur b. des moyens branche à soi-même, une boucle infinie mais je na pas inventer une étiquette, tapez et branche à elle. Un autre raccourci utilise des nombres moyens b 1b branche à une arrière, les regards assembleur pour le numéro d'étiquette 1 derrière ou au-dessus de l'instruction. Le b 1F, ce qui est une branche à soi-même, signifie la branche 1 vers l'avant, ce qui est parfaitement code valide pour cet assembleur. Il regardera vers l'avant ou en dessous de la ligne de code pour un numéro d'étiquette 1: Et vous pouvez réutiliser le numéro 1 comme un fou dans votre programme en langage assembleur pour cet assembleur, sauve d'avoir à inventer des noms d'étiquettes pour les branches courtes et simples. Les deuxièmes branches b 1b à la seconde 1. et est une branche à l'auto.

Il est important de comprendre que la société qui a créé le processeur définit le jeu d'instructions, et le code de la machine ou opcodes ou tout autre terme qu'eux-mêmes ou que vous utilisez pour les bits et octets le processeur décode et exécute. Très souvent, cette société produira un document avec le langage d'assemblage pour les instructions, une syntaxe. Souvent, cette société produira un programme assembleur pour compiler / assembler que le langage d'assemblage ... en utilisant cette syntaxe. Mais cela ne signifie pas que toute autre personne sur la planète qui choisit d'écrire un assembleur pour ce jeu d'instructions doit utiliser cette syntaxe. Ceci est très évident avec le jeu d'instructions x86. De même les instructions de Psuedo comme la pop ci-dessus ou la syntaxe macro ou d'autres raccourcis comme le b 1b doivent être honorées d'un assembleur à l'autre. Et très souvent pas, vous voyez cela avec ARM par exemple le symbole de commentaire universel de; ne fonctionne pas avec gnu assembleur vous devez utiliser @ à la place. ARMs assembleur n'utilise le; (Notez que j'écris mon assembleur de bras avec, @ pour le rendre portable). Il est pire encore avec des outils gnu par exemple, vous pouvez pouvez mettre les choses en langage C comme #define et / * commentaire * / dans votre assembleur et utiliser le compilateur C au lieu de l'assembleur et cela fonctionnera. Je préfère rester aussi pur que possible pour une portabilité maximale, mais naturellement, vous pouvez choisir d'utiliser tout ce qui présente les offres d'outils.

Autres conseils

L'instruction est composé de toutes les instructions d'un processeur peut exécuter, tout est assemblée la langue de programmation qui utilise ces instructions pour faire des programmes.
En d'autres termes, le jeu d'instructions est juste un groupe d'octets d'une unité centrale de traitement peut comprendre, mais vous ne pouvez pas faire quelque chose d'utile avec eux (pensez les instructions que les lettres de l'alphabet) tout est assemblée une langue qui vous permet de combiner ces instructions (ou lettres) pour faire un programme (quelque chose comme un discours).

Un langage d'assemblage est plus qu'un simple surensemble du jeu d'instructions: il est un moyen de générer des fichiers d'objets, les symboles, les informations de débogage, liens, et aussi d'avoir une même programmation structurée minimale à ce niveau. (Bâtiment peu sur d'autres réponses / commentaires ici)

mise en page de fichier objet. Par exemple, les sections: code, données, en lecture seule, le débogage, la liaison dynamique. La directive « org » commune indique l'assembleur l'emplacement des instructions / données.
Pré-traitement. Cela inclut des macros (extension en ligne, répétition) et parfois la programmation structurée (mise en page de la structure, définissant des noms d'alias pour les registres).
Définition des données. Soit y compris les fichiers de gros, ou définir octet / mot à la fois, par exemple « .byte », « .word », « .DW » en fonction de votre architecture.

La plupart des compilateurs C génèrent l'assemblage, qui est ensuite transmis à l'assembleur pour créer des fichiers d'objets. Si vous regardez la sortie de gcc lorsqu'il est exécuté avec le drapeau « S », vous verrez plus de ce qui précède utilisé. Si vous avez debug activé (-G) et une liaison dynamique (par défaut ces jours-ci), vous verrez une énorme quantité de réunion non consacré à des instructions seulement.

Un langage assembleur comprendra mnémoniques pour les instructions, mais ajoute normalement un peu plus, par exemple:

macros
d'une certaine façon de définir les données
façons de définir les noms (par exemple, pour les fonctions)

Edit: Une instruction (en soi) est codé en binaire pour le CPU pour le lire. Le mnémonique est un nom pour l'instruction. Par exemple, en langage assembleur je pourrais écrire « hache mov, 1 ». L'instruction correspondante pour ce serait (dans le cas d'un x86) être codé comme B8 00000001 (en hexadécimal).

Définition des données, des macros, des noms de fonctions, etc., ne sont pas des instructions réelles. Une macro (un peu comme une macro dans C, etc.) vous permet de définir des noms au cours du processus d'assemblage. Il pourrait (souvent se) conduisent à générer des instructions, mais ils sont séparés de la définition de la macro elle-même. Tout comme en C, lorsque vous définissez des données qui résulteront généralement dans un enregistrement dans le fichier objet spécifiant une certaine quantité d'espace pour le nom X, mais ne génère pas directement les instructions.

Un ordinateur (plus précisément processeur) ne peut le faire le calcul à-dire effectuer des opérations arithmétiques et logiques.

Une opération arithmétique ou logique unique est appelée une instruction .

La collection de toutes les instructions est appelé jeu d'instructions de cet ordinateur (plus précisément processeur).

Le jeu d'instructions est soit câblé dans le processeur ou est mis en oeuvre en utilisant une technique appelée microcode .

L'ordinateur ne peut être programmé, si elle avait une langue qu'il comprend à savoir quelque chose. Le code binaire est pas la langue de l'ordinateur. code binaire jeu d'instructions en fonction est la langue de l'ordinateur.

A la langue est rien spécification sur papier . Le premier langage conçu sur le papier était le langage machine. Sa mise en œuvre dans l'ordinateur n'a été possible que par le matériel (ou le dernier microcode technique). Cette mise en œuvre est appelé jeu d'instructions. Toutes les autres langues seront conçues sur la langue de la machine.

langue machine a été difficile de travailler avec nous la plupart du temps de travail avec alphabets dans notre vie quotidienne. Par conséquent, il a été décidé d'introduire une langue mnémotechnique appelée langue Assemblée sur la langue de la machine. La mise en œuvre de la langue de l'Assemblée a été nommé Assembleur.

[On peut se demander comment le premier assembleur a été écrit. Le premier assembleur peut ou ne peut pas être écrit en langage machine. Je ne suis pas mentionner le concept de bootstrapping ici par souci de simplicité]

SOMMAIRE:

Assembleur est converti en jeu d'instructions par Assembleur. Et les deux sont différents côtés d'une pièce avec une couche d'abstraction ou code mnémonique entre eux. Le langage machine est « bit encodage » du jeu d'instructions d'un processeur. Assemblée langue est « encodage symbolique » du jeu d'instructions d'un processeur.

Quand vous regardez dans l'article de Wikipédia sur Assemblée lié ??à votre question, il est un exemple ci-dessous montrant des instructions en langage assembleur et correspondant code objet. Les deux sont différentes représentations de la même chose: les instructions du jeu d'instructions d'un processeur. Mais seule la colonne avec le titre « Instruction (AT & T syntaxe) » contient langage d'assemblage.

Espérons que cela le rend plus clair.

Tout est en architecture en couches avec "stricte (la plupart du temps) et bien défini interfaces" .

Début du matériel

Il y a beaucoup de couches jusqu'à ce que vous atteignez jusqu'à processeur.

Calque Je veux dire que nous partons de « physics-> appareils (électronique) -> analogique (amplificateur) -> Gates-> Numérique Circuits> Micro-Architecture-> Architecture (ISA, processeur)
Mais début du processeur, il comporte deux parties (Comme la plupart des systèmes embarqués ont). : Matériel et logiciel.
une partie du logiciel qui est appelé ISA (Instruction Set Architecture)

Il a toutes les instructions qu'un processeur respecté peut prendre en charge. Cela signifie que ISA est lié à un seul processeur (matériel comme x86).
La chose importante est la raison pour laquelle cette ISA est nécessaire? Même comme je le disais plus tôt, il est stricte et bien définie Interface. Processeur ne peut pas exécuter une instruction au-delà ISA [Strict]

Mais Toute personne qui veut utiliser ce processeur peut utiliser ces commandes de ISA pour obtenir son travail. [Interface bien définie]

Maintenant, venez à l'Assemblée, C, Assembleur, compilateur ....

Architecture en couches que vous savez que nous utilisons (Arch Layered) en matériel pour mettre en œuvre un processeur pour vous

Vous pouvez en savoir plus sur pourquoi cette architecture en couches. Il fait facile à traiter un grand pas de problème à pas.
Même ici ce que nous voulons? ce que notre objectif est?

Nous voulons utilisateur peut utiliser ce processeur facilement. Ici, l'utilisateur est programmeur .
Voir la difficulté pour le programmeur.

Un programmeur peut se rappeler toutes les instructions pour un processeur ceux qui sont au format binaire. Et processeur peut changer dans l'application suivante d'Intel à IBM (pas maintenant d'une version spécifique).
- Nous avons donc ici aussi l'architecture en couches [non fixe].
- 1) Assembleur - compilateur
- 2) Assembleur

Assembleur est également une couche ce qu'elle a - deux interfaces. Même avec le compilateur.

Ex: Vous écrivez un code C. processeur ne peut pas comprendre ce code. Il écrit tout COMPRENDRE au format binaire et défini par instruction donnée dans ISA. Mais il est difficile d'écrire (maintenir | modifier) ??un programme dans l'enseignement dans ISA.

1) Donc, écrire un code utilisateur en C. Ce code un compilateur C comprendre. Parce qu'un utilisateur est limité à utiliser uniquement la syntaxe donnée en C. Cela signifie que le compilateur C donnant une interface standard et bien défini à l'utilisateur à une extrémité. A l'autre et il peut utiliser directement l'instruction ISA ou une autre interface appelée « Assembleur ».

2) Maintenant, si vous utilisez Assembleur puis compilateur traduira tous les C-code dans la syntaxe donnée par Assembleur. Et la syntaxe Assembleur fournir au compilateur appelé langage assembleur. Il est l'interface aussi bien définie et tout le monde peut l'utiliser pour le programme en langage d'assemblage. Et à l'autre bout Assembleur convertit toute sa syntaxe (mnémoniques | directives, ce ne sont pas présents dans ISA) aux instructions de code binaire dans ISA.

Voici quelques exemple de cette traduction.

Dans C = hello.c
Dans le code = Assemblée hello.s
Dans l'objet Code = hello.obj (pas de lien Fait: Plus d'info)

Dans ce fichier, une ligne est « Machine: Advanced Micro Devices X86-64 » qui fournit des informations sur le processeur en conséquence, nous utilisons ISA et assembleur. Et programmeur C est pas au courant de cela, il est libre de code C. C'est l'avantage de "Bien Interface Defined".

Dans le code machine = hello.binary (Après la liaison: Plus d'info)

Pour Comparer Il suffit de voir

hello.c (programme C)
hello.asm2bin (Object File Table: mise en correspondance directe Instruction mnémoniques et binaire)
hello.asm2bin_exe (Table fichier binaire: Plus mappage après l'association)

Vous verrez une ligne dans ces fichiers "désassemblage de section .. " Depuis ce assembleur faire: Il assembler l'instruction ISA (modèle binaire) du langage assembleur, donc ici, nous voyons d'abord l'instruction ISA, puis desassembly à mnémoniques.

Tous les fichiers sont à ce lien [Télécharger et Open]

https://www.dropbox.com/sh/v2moak4ztvs5vb7/AABRTxl7KQlqU2EkkMkKssqYa? dl = 0

Dans Linux Vous pouvez utiliser vim, emacs pour ouvrir ces fichiers.
Dans Windows, utilisez simplement vim ou de l'utilisation « Open-> Sélectionnez un programme de ..... » après un clic droit sur le fichier et sélectionnez l'éditeur de texte de votre choix.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow