2016-02-18 1 views
-3

Donc, je cours _asm avec C++ en utilisant Visual Studio. Donc, je suis novice en programmation d'assemblage, je suis un manuel et je sais que le registre général EAX contient 32 bits et AX est 16 avec AL, AH étant bas/haut.Instruction MOV pour les registres

Alors, comment pourrais-je déplacer plusieurs commandes en utilisant seulement l'instruction MOV. J'ai essayé de faire

MOV AL, 'a', 'c' , 'e' 

mais j'obtiens une quantité illégale d'opérandes. Thats seulement 3, donc ne devrait pas être capable de détenir cette valeur?

J'ai essayé après avoir fait

MOV EAX, 0 
MOV AL, 'a', 'c' , 'e' 

Alors, comment pourrais-je passer trois valeurs différentes, voire plus comme 12 lettres à 8 bits? Est-ce que je ne devrais pas me déplacer 0 à eax effacer à la fois le bas et le haut du bit 8 permettant à ces 3 variables d'être déplacées? Je veux seulement utiliser le registre de 8 bits pour y déplacer plusieurs valeurs, dans ce cas qui est 3. J'aime aussi savoir comment faire plus comme 12 lettres en 8 bits. J'ai lu que vous feriez MOV EAX, 0 mais je n'ai pas eu de chance.

Remarque: Ce n'est pas le programme complet, j'ai seulement inclus le problème avec MOV.

#include "stdafx.h" 
#include "stdio.h" 
#include <iostream> 

using namespace std; 
using std::cout; 
using std::cin; 


int main(void) 
{ 

    char test 
    _asm 
    { 
     MOV EAX, 0 
     MOV AL, 'a', 'c' , 'e' 
    } 
} 
+1

Avez-vous essayé 'mov eax, 'ace''? –

+1

Inline asm n'est pas le meilleur choix pour apprendre asm, IMO. Il y a quelques suggestions dans le wiki du tag http://stackoverflow.com/tags/x86/info. 'mov' ne peut pas prendre plusieurs opérandes source. Vous pouvez amener l'assembleur à faire des calculs pour produire une valeur pour un opérande source immédiat, mais la syntaxe ressemble à 'mov eax, ('a' << 16 | 'c' << 8 | 'e')'. (Ou quelque chose comme ça). Notez que c'est une expression unique qui a une valeur entière. Et comment pensez-vous que 12 lettres peuvent tenir dans 8 bits de toute façon? Un caractère ASCII est 8 bits. –

+0

Donc, le déplacement de 0 vers EAX vous permettrait seulement d'insérer 8 lettres maximum dans le registre de 8 bits (hi & low). Je comprends que maintenant, je pensais pour une raison quelconque qu'il y avait un moyen de le faire. Merci pour votre aide, je pense aussi que mov a plusieurs opérandes, – user5894146

Répondre

0

Si vous ne me suis fait littéraux de pousser vers le haut dans EAX vous pouvez utiliser le code suivant:

MOV EAX, 'ace' 

Si vous voulez un morceau de code qui peut utiliser trois variables pour composer la valeur qui va sur EAX, utilisez le code suivant comme modèle et remplacez les littéraux par des noms de variables.

MOV EAX, 'a' * 0x10000 + 'c' * 0x100 + 'e' 

Et enfin, si vous souhaitez une solution qui pousse un caractère par caractère, vous pouvez utiliser les éléments suivants:

void init() 
{ 
    _asm 
    { 
     XOR EAX, EAX 
    } 
} 

void push(char c) 
{ 
    _asm 
    { 
     SHL EAX, 8 
     MOV AL, c 
    } 
} 

Aussi je voudrais savoir comment faire plus comme 12 lettres dans 8 bits. J'ai lu vous auriez fait MOV EAX, 0 mais je n'ai pas eu de chance.

Je ne comprends pas ce que vous entendez par là, voulez-vous dire 12 caractères dans EAX. EAX est 32 bits, ce qui signifie seulement 4 caractères ASCII. Mais si ce que vous essayiez d'insérer dans EAX est un nombre hexadécimal (0-9 et a-f), cela signifie que vous ne pouvez plus en insérer 8 dans EAX.

+0

Cela doit être 'shl eax, 8' pour passer d'un octet entier. Êtes-vous mélangé entre «a» (0x61) et «0xa»? Même ainsi, vous voulez 'xor eax, eax' /' mov al, 0xa'/'shl al, 4' /' ou eax, 0xc'/'shl eax, 4' /' ou eax, 0xe'. (Ceci devrait éviter les ralentissements de registre partiel sur les processeurs Intel Votre séquence a un décrochage partiel ou une fusion sur le matériel pré-IvB sur le second 'shl', parce que le premier' shl' supprime la balise upper-bits-clear écrire le registre complet avec autre chose qu'un idiome de mise à zéro) –

+1

Votre première version de 'mov eax, imm32' a le même problème: essayez' 'a' * 0x10000 + 'c' * 0x100 + 'e''. Chaque caractère ASCII prend un octet entier (deux chiffres hexadécimaux, aka grignoter) –

+0

Merci Peter, totalement raté que, pour une raison quelconque, supposé que c'est un chiffre hexadécimal pas un personnage entier. Ma réponse est fixée en conséquence. – Bishoy