Big Endian в Little Endian

Question

Мой первоначальный вопрос назначения заключается в следующем:

Write a program that uses the variables below and MOV instructions to copy the value from bigEndian to littleEndian, reversing the order of the bytes. The number's 32 - bit value is understood to be 12345678 hexadecimal.

.data 
bigEndian BYTE 12h, 34h, 56h, 78h 
littleEndian DWORD? 

Я думаю, что мой код правильный, но я не могу понять, почему я получаю эту ошибку. Вот мой код и ошибка:

.386 
.model flat, stdcall 
.stack 4096 
ExitProcess PROTO, dwExitCode:DWORD 

.data 
bigEndian BYTE 12h, 34h, 56h, 78h 
littleEndian DWORD ? 
.code 
main PROC 
mov eax, DWORD PTR bigEndian; eax = 87654321h 
mov littleEndian, eax 

invoke ExitProcess, 0 
main ENDP 
END main 

1>------ Build started: Project: BigEndianLittleEndian, Configuration: Debug Win32 ------

1> Assembling BigEndiantoLittleEndian.asm...

1>BigEndiantoLittleEndian.asm(20): error A2008: syntax error

1>C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V140\BuildCustomizations\masm.targets(50,5): error MSB3721: The command "ml.exe /c /nologo /Zi /Fo"Debug\BigEndiantoLittleEndian.obj" /W3 /errorReport:prompt /TaBigEndiantoLittleEndian.asm" exited with code 1.

========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Как я могу исправить эту ошибку?

Here is updated code:

.386 
.model flat, stdcall 
.stack 4096 
ExitProcess PROTO, dwExitCode:DWORD 

.data 
bigEndian BYTE 12h, 34h, 56h, 78h 
littleEndian DWORD ? 


.code 
main PROC 

mov ah, byte ptr bigEndian+0 
mov al, byte ptr bigEndian+1 
mov word ptr littleEndian+2,ax;here I want to move my now full register into  the 32bit register eax. 
mov ah, byte ptr bigEndian+2 
mov al, byte ptr bigEndian+3 
mov word ptr littleEndian+2,ax here I want to move my now full register into the 32bit register eax which results in the order being reversed. 


invoke ExitProcess, 0 
main ENDP 
END main 

Я получаю ошибку

1>------ Build started: Project: BigEndianLittleEndian, Configuration: Debug Win32 ------

1> Assembling BigEndiantoLittleEndian.asm...

1>C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V140\Microsoft.CppCommon.targets(708,9): error MSB4030: "main" is an invalid value for the "NoEntryPoint" parameter of the "Link" task. The "NoEntryPoint" parameter is of type "System.Boolean".

========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

Answer 1

Вы должны фактически поменять байты в eax перед записью на память:

mov eax,DWORD PTR bigEndian 
bswap eax 
mov littleEndian,eax 

Используя исключительно mov инструкции это может быть например:

mov al,DWORD PTR bigEndian+0 
mov ah,DWORD PTR bigEndian+1 
mov bl,DWORD PTR bigEndian+2 
mov bh,DWORD PTR bigEndian+3 

mov littleEndian+0,bh 
mov littleEndian+1,bl 
mov littleEndian+2,ah 
mov littleEndian+3,al 

Answer 2

Я только что закончил это на своем ассемблере. Вот что я с трудом придумал. Я почти уверен, что есть лучший и более правильный способ сделать это, но это был единственный способ понять это. Еще не включили его для оценки, поэтому я не знаю, насколько хорошо он хорошо держится в этом аспекте. Подозреваю, все будет хорошо. Он выполняет то, что задает проблема, в пределах установленных ограничений.

; Description: Copy value from bigEndian to littleEndian, reversing order of bytes 
; Assignment: A06B 4.10 Programming Exercise 
; Date: 3/17/2016 

INCLUDE Irvine32.inc 

.data 
bigEndian  BYTE   12h, 34h, 56h, 78h 
littleEndian DWORD   ? 

.code 
main   PROC 
       mov  al, [bigEndian+3]  ;swap 78h and 12h 
       mov  ah, [bigEndian]  
       mov  [bigEndian], al 
       mov  [bigEndian+3], ah 

       mov  al, [bigEndian+2]  ;swap 56h and 34h 
       mov  ah, [bigEndian+1] 
       mov  [bigEndian+1], al 
       mov  [bigEndian+2], ah 

       mov  eax, DWORD PTR bigEndian ;move reverse ordered bytes to eax 
       mov  littleEndian, eax  ;move reverse ordered byted to littleEndian 
       invoke ExitProcess, 0 
main   ENDP 
END main 

Answer 3

Я пришел с тем, что кажется лучшим способом решить проблему. Он по-прежнему придерживается ограничений только с использованием команд MOV, но он не разрушает исходное значение массива.

INCLUDE Irvine32.inc 

.data 
bigEndian  BYTE 12h, 34h, 56h, 78h 
littleEndian DWORD ? 

.code 
main   PROC 
    mov esi, OFFSET bigEndian 
    mov eax, 0 
    mov al, [esi+3]  ;Isolate 5678h 
    mov ah, [esi+2] 
    mov ebx, 0 
    mov bl, [esi+1]  ;Isolate 1234h 
    mov bh, [esi] 

    mov esi, OFFSET littleEndian 
    mov [esi], eax  ;Move 5678h into lower 16bits of littleEndian 
    mov [esi+2], ebx ;Move 1234h into higher 16bits of littleEndian  
    invoke ExitProcess, 0 
main  ENDP 
END main 

Answer 4

У меня на самом деле было это одно и то же задание, подумал, что я отправлю свой ответ здесь. Существует способ поменять байты, используя указатели и команду OFFSET. LittleEndian применяется только при записи байтов в память. Это означает, что при запуске следующего кода eax будет удерживать обратные байты bigEndian.

< LittleEndian => BigEndian

mov ebx,OFFSET bigEndian 
mov eax, [ebx] 

Это назначение, однако, ограничен нам только с помощью оператора мов. В моем случае, операторы OFFSET также не допускаются. Буквально все, что мы могли использовать, было mov. В связи с этим вам нужно будет вручную обменивать байты, и поскольку вы не можете перемещать данные из памяти в память, мы вынуждены использовать 8-битный регистр в качестве буфера для временного хранения данных.

Вы можете получить доступ к каждому байту bigEndian отдельно, используя смещения bigEndian + 0 -> bigEndian + 3, но, учитывая, что мы объявили littleEndian после bigEndian, память была выделена для littleEndian сразу после bigEndian. Это означает, что если мы смещаем смещения bigEndian + 4 -> bigEndian + 7, мы можем напрямую обращаться к littleEndian, используя небольшие 8-битные приращения. Я воспользовался этим и использовал его в своем коде.

EDIT: Вот конечный результат

.386 
.model flat,stdcall 
.stack 4096 
ExitProcess proto,dwExitCode:dword 
INCLUDE Irvine32.inc 
.data 

    bigEndian BYTE 12h, 34h, 56h, 78h 
    littleEndian DWORD ? 

.code 
main proc 

    ; You can swap them by taking advantage of when littleEndian is applied to variables in memory. 
    ; Since we are limited to only mov operators, we cannot use this code. But it's nice to have for the future. 
    ; mov ebx,OFFSET bigEndian 
    ; mov eax, [ebx] 

    ; Display bigEndian 
    mov ebx, 1 ;set to write eax al 8 hex digits using WriteHexB 
    mov al, bigEndian+0 
    call WriteHexB 
    mov al, bigEndian+1 
    call WriteHexB 
    mov al, bigEndian+2 
    call WriteHexB 
    mov al, bigEndian+3 
    call WriteHexB 
    call CrlF 

    ; Since bigEndian was declared before littleEndian, bigEndian only goes as far as bigEndian+3 
    ; However, since littleEndian was declared after, we can traverse littleEndian using bigEndian+4 -> bigEndian+7. 
    ; Considering we cannot move data from memory to memory, we have to use an 8-bit register as a buffer. 
    ; We will use al register. 

    ; bigEndian = 12345678h, littleEndian = 00000000h 

    mov al, bigEndian+0 
    mov bigEndian+4, al 

    ; bigEndian = 12345678h, littleEndian = 00000012h 

    mov al, bigEndian+1 
    mov bigEndian+5, al 

    ; bigEndian = 12345678h, littleEndian = 00003412h 

    mov al, bigEndian+2 
    mov bigEndian+6, al 

    ; bigEndian = 12345678h, littleEndian = 00563412h 

    mov al, bigEndian+3 
    mov bigEndian+7, al 

    ; bigEndian = 12345678h, littleEndian = 78563412h 



    ; Write littleEndian to eax to display on screen 
    mov eax, littleEndian 

    ; Display littleEndian 
    call WriteHex 
    call CrlF 

    ; Display 'Press [enter] to continue...' 
    call WaitMsg 

    invoke ExitProcess,0 
main endp 
end main