Why can't I directly move a byte to a 64-bit register?

Question

Why can't I directly move a byte from memory to a 64-bit register in the Intel x86-64 assembly?

For example, this code:

extern printf

global main

segment .text

main:
    enter   2, 0

    mov     byte [rbp - 1], 'A'
    mov     byte [rbp - 2], 'B'

    mov     r12, [rbp - 1]
    mov     r13, [rbp - 2]             

    xor     rax, rax           
    mov     rdi, Format                                                                                             
    mov     rsi, r12                                                                                                
    mov     rdx, r13                                                                                                
    call    printf                                                                                                  

    leave                                                                                                           
    ret                                                                                                             

segment .data                                                                                                       
Format:     db "%d %d", 10, 0

prints:

65 16706

I need to change the move byte to the r12 and r13 registers so that the code works correctly:

xor     rax, rax
mov     al, byte [rbp - 1]
mov     r12, rax
xor     rax, rax
mov     al, byte [rbp - 2]
mov     r13, rax

Now it prints what is intended:

65 66

Why do we need this?

Is there an easier way to do this?

Thank.

Answer 1

Use null or character expansion if necessary.

For example: movzx eax, byte [rbp - 1]for zero extension in RAX .

movsx rax, byte [rbp - 1] to go to RAX.

Answer 2

8- 64-

movzx 64- .

movzx     r12, byte ptr [rbp - 1]
movzx     r13, byte ptr [rbp - 2]

mov       ax,  word ptr [rbp - 2]
movzx     r12, al
movzx     r13, ah

. . http://www.felixcloutier.com/x86/MOVZX.html " 64- r/m8 , REX: AH, BH, CH, DH."

, :

mov       ax,  word ptr [rbp - 2]
movzx     r12, al
mov       al, ah
movzx     r13, al

movxz', , ( ) - .

, 64- 32- (63-32), , , ah movzx 64- 32- , 64- (movzx r13d, ah ).

8-, 16- 32 64- rNN

8-, 16- 32 64- rNN :

rNNb - rNNw - rNNd - dword

, r10b, r10w, r10d.

    xor     r8d,dword ptr [r9+r10*4]
    .....
    xor     r8b, al
    .....
    xor     eax, r11d

: "h" rNN , : ah, bh, ch dh.

: 32- 64- 32 .

- , . Intel " " (OOE) (RR). , , , : Knights Landing Cannonlake. , , ( OOE RR):

movzx     rax, word ptr [rbp - 2]
movzx     r12, al
shr       rax, 8
mov       r13, rax

Knights Landing , CannonLake - Intel, , 8- 16- , 32- 64- CannonLake, .

OOB RR, .