macro  memcpy src, dest, size {
       ..copy  = 0

       if      src  eq          esi
       else
              mov  esi,src
       end     if

       if      dest eq     edi
       else
              mov  edi,dest
       end     if

       if      size eqtype 0
              ..copy  = 1
         if      (size mod 4) = 0
                    mov  ecx,(size shr 2)
                       rep  movsd
          else
                mov  ecx,(size shr 2)
                       rep  movsd
                  mov  ecx,(size mod 4)
                       rep  movsb
          end     if
       end     if

       if      ..copy  =    0
        if      size    eq     ecx
          else
                mov  ecx,size
               end     if

              push    ecx
         shr     ecx,2
               rep     movsd
               pop     ecx
         and     ecx,3
               rep     movsb
       end     if
}

memcpy esi,edi,ecx
memcpy [pointer1],[pointer2],[size]
memcpy eax,[hMappedFile],edx
    

                    mov  ecx,(size mod 4)
                       rep  movsb
    

align 4

MemCopy proc public uses esi edi Source:PTR BYTE,Dest:PTR BYTE,ln:DWORD

    ; ---------------------------------------------------------
    ; Copy ln bytes of memory from Source buffer to Dest buffer
    ;      ~~                      ~~~~~~           ~~~~
    ; USAGE:
    ; invoke MemCopy,ADDR Source,ADDR Dest,4096
    ;
    ; NOTE: Dest buffer must be at least as large as the source
    ;       buffer otherwise a page fault will be generated.
    ; ---------------------------------------------------------

    cld
    mov esi, [Source]
    mov edi, [Dest]
    mov ecx, [ln]

    shr ecx, 2
    rep movsd

    mov ecx, [ln]
    and ecx, 3
    rep movsb

    ret

MemCopy endp
    

Code:

    [...]
    shr ecx, 2
    rep movsd

    mov ecx, [ln]
    and ecx, 3
    rep movsb
    [...]
    

I guess you didn't look precisely at my macro. Look at your code Vortex:

Matrix: I can't move it to main, because, a procedure gets parameters from stack and my macro makes some operations on the number of bytes to copy if it's a constant value. Such operations are impossible if given on a stack.

But the address of each double word may not be aligned on 4 boundary. For example when you start moving from address 10001h, it might be good to use one MOVSB first, then as much of (aligned) MOVSD instructions as fit, and then fill the rest with MOVSB instructions again.