According to the Intel 8086 instruction set manual, MOV instruction can move data from these locations:

MOV REGISTER,REGISTER                   ; example mov ax,bx
MOV REGISTER,IMMEDIATE                  ; example mov ax,5h
MOV MEMORY,REGISTER                     ; example mov arr,ax
MOV REGISTER,MEMORY                     ; example mov ax,arr
MOV MEMORY,IMMEDIATE                    ; example mov arr,20h

REGISTER  : means any register.
MEMORY    : means any byte (8-bit) or word (16-bit) in memory (variable).
IMMEDIATE : means any immediate value (0Ah, 10d).

Kol Register in 8086 assembly lih est3maloh el 5as, here is what the standard mentions:

AX = Accumulator register, used to contain result of arithmetic equations, return values from subroutines, and I/O devices' data.
BX = Base register, used to contain the base address of data structures.
CX = Counter register, used to contain counter values in loops, and shifting values in bitwise operations.
DX = Data register, like AX, used to contain result of arithmetic equations, and I/O devices' data.

IP = Instruction pointer, used to contain the address of the next instruction to be executed in the Code Segment.
SP = Stack pointer, points at the top address of the stack.
BP = Base pointer, points at the base of a stack frame.

SI = Source index, used to contain index values.
DI = Destination index, used to contain index values.

CS = Code segment, used to contain the base address of the Code Segment (dih el 7eta ely fiha el code beta3 el bernameg beta3na ba3d mabyt3malo load fel memory).
DS = Data segment, used to contain the base address of the Data Segment (dih el 7eta ely fiha el initialized data).
SS = Stack segment, used to contain the base address of the region of memory used as a stack.
ES = Extra data segment, used to contain the base address of a part of memory which has the uninitialized data, or more initialized data when DS is full.

FLAGS = flags register, used to contain el state beta3et el application beta3y, wel results of arithmetic and comparison instructions.

---------------------------------------------------------------------------
So now, nigi netaba2 el klam ely maktob fel standard 3ala sho3'lna.

shofna fel awel 5ales MOV instruction, MEMORY hena ma3naha ay accessible memory location, we katbna mabein parenthesis variable, ya3ny MEMORY hena means a variable.
Data structures are considered variables too.
An array is a data structure.
Linked List is a data structure.
A tree is a data structure.
and Stack also is a data structure.

In assembly, 3alshan ne-access data structure, bena5od el base beta3et el structure dih into a register, we ben-access el elements wel members beto3ha men 5elal el DI wel SI.
So, nestanteg men kda en el registers ely ne2dar nesta5demha m3a ba3d homa:
BX with SI and DI.
DS with SI and DI (sometimes BX could be used for large indexes).
ES with SI and DI (sometimes BX could be used for large indexes).

Also, fel assembly, lama a3mel call le subroutine (same as function in C), wana gowa el function, ba2dar a-access el function parameters men 5elal el SP wel BP.
So, nestanteg men kda en el registers ely ne2dar nesta5demha m3a ba3d homa:
BP with SI and DI.
DS with BP.
ES with BP.

----------------------------------------------------
How parameters are passed to functions in assembly:
***************************************************

- hena hanwada7 isA ezay el BP is used to access function parameters in assembly.
- In assembly, bady el parameters lel functions by pushing them into the stack abl ma-call el function beta3ty.
- Let's take that assembly snippet of code as an example, hena hane3mel function esmaha mul_me(x,y), beta5od 2 parameters, we bet-return their multiplication:

mov cx,05h
mov dx,10h
push cx
push dx
call mul_me
hlt

mul_me:
push bp
mov  bp,sp
mov  bh,[bp+04h]      ;bh now contains dx (10h)
mov  al,[bp+06h]      ;al now contains cx (05h)
mul  bh               ;AX = AL*BH
pop bp
ret


- Now, zay ma7na shayfeen, 7atena values gowa el CX wel DX, we 3amalnalhom push into the Stack, we zay ma7na 3arfeen, stack pointer grows downward, bema3na en kol data bene3melaha push, el SP bey2el bel size ely 3amalnaloh push, hena e7na 3amlna push lel cx, fa beltaly el SP = SP-2 (since CX is a register, and registers are 2 bytes), we ba3dein 3amlna push lel dx, fabeltaly na2sna another 2 bytes men el SP, faba2et SP = SP-4.

law 7abena neshoof el stack 3amla ezay le7ad el line ely abl el CALL (lesa mad5lnash fel function), hanla2y el stack manzarha 3amel kda:

|            |<- 0x0000
|            |
|	     |
|____________|<- SP points here, which is -4 from the top of the stack
|____10h_____|
|____05h_____|<- 0xFFFF (top of the stack)
|            |
|            |

ba3d man-execute el CALL instruction, CALL instruction automatically pushes the value of IP (instruction pointer) into the stack, we ba3d mad5lna fel function, 3amlna push lel BP 3alshan nesta3melha in accessing function parameters, tab3an momken nesta3'na 3an el 5atwa dih en e7na nesta3mel 3alatool SP 3alshan ne-access el parameters (CX and DX), bas fel assembly ben7awel man3'ayarsh el SP bekadr el mostata3 3alshan dih beyt3malaha increment we decrement automatically, fa3lshan manla5batsh el denya, we 3alshan man3melsh overwrite lel data beshakl mofage2 aw bel3'alat, fa bena5od el value beta3et el SP gowa el BP (mov bp,sp), we benet7akem bekol 7aga men 5elal el BP.

Now, ba3d awel 2 lines fel function, el stack manzarha kda:

|            |<- 0x0000
|            |
|____________|<- SP and BP points here now.
|____BP______|
|____IP______|<- If we want to access this word, BP+2h
|____10h_____|<- If we want to access this word, BP+4h
|____05h_____|<- If we want to access this word, BP+6h
|            |
|            |

So, here 3erefna ne-access el parameters men 5elal el BP register, fa3mlna mov lel parameters gowa el BH wel AL, we 3amalnalhom multiply, we ba3dein 3amlna pop el BP (since en e7na fy awel el function 3'ayarna el value beta3et el BP, fa lazem abl manetla3 menha nerag3ha lel value beta3et-ha ely 3amlnlha push on the stack).