Multiply Two 64 bit Numbers Using 32 Bit Words

Pretend you're multiplying two 2-digit numbers by hand.

You can multiply two 2-register-wide numbers in Exactly the same way.

Let's assume that you have two 64-bit numbers: Z1 and Z2. Their multiplication with give you 128-bit result.
You can multiply 32-bit on 32-bit.
So declare Z1 = Y1 0 + X1 (where X1 is lower 32-bit and Y1 is higher 32-bit)
Z2 = Y2 0 + X2
Then Z1 * Z2 = (Y1 0 + X1 ) * (Y2 0 + X2)
And you need to find only 32-bit multiplications BUT for example Y1 0 * Y2 0 = Y1*Y2 0 0 (where Y1 * Y2 is upper 64-bit value of 128-bit result).

Hope it will help you...

x86, very fast and efficient, any number size (>= 64 bits):

BNMul      proc      lpBNResult:DWORD, lpBN1:DWORD, lpBN2:DWORD
;--T:BOOL
;--G:Multiplies two Big Numbers and stores the result to lpBNResult. Returns -1 on overflow.
;--H:
      local      lpBNLocal:DWORD
      local      lpBNRes:DWORD
      local      dwValue:DWORD
      
      mov            eax,0
      
      pushad

      PUSH_STACK_BN      lpBNLocal
      PUSH_STACK_BN      lpBNRes
      
      ;clears lpBNResult
      mov            eax,0

      mov            ecx,dwArraySize

      ;unrolled BNSet0 >>>>>
      mov            edi,lpBNResult
      push      ecx
      rep            stosd
      pop            ecx
      ;<<<<<<<<<<<<<<<<<<<<<
      
      ;tests if lpBN1 or lpBN2 are 0, if so, exit
      ;unrolled BNIs0 >
      mov            edi,lpBN1
      push      ecx
      repz      scasd
      pop            ecx
      .if ZERO?
            jmp            @F
      .endif
      ;<<<<<<<<<<<<<<<<

      ;unrolled BNIs0 >
      mov            edi,lpBN2
      push      ecx
      repz      scasd
      pop            ecx
      .if ZERO?
            jmp            @F
      .endif
      ;<<<<<<<<<<<<<<<<
      
      ;copies lpBN1 to lpBNLocal, which is then shifted to the left
      ;unrolled BNCopy >>>>
      mov            esi,lpBN1
      mov            edi,lpBNLocal
      push      ecx
      rep            movsd
      pop            ebx                                          ;holds the iteration count
      ;<<<<<<<<<<<<<<<<<<<<
      
      ;computes the number of bits of the multiplier, which are the
      ;iterations - 1
      dec            ebx
      mov            ecx,lpBN2                              ;holds the DWORD offset
      
      .repeat
            ;tests if the DWORD is set
            .if dword ptr [ecx]
                  ;if it is, multiply lpBNLocal by dword ptr [ecx] and
                  ;add lpBNRes to lpBNResult
                  mov            eax,[ecx]
                  mov            dwValue,eax
                  ;unrolled BNMulByDWORD >>
                  pushad
                  mov            ebx,0                                    ;Carry
                  mov            ecx,dwArraySize
                  mov            edi,lpBNRes
                  ;unrolled BNCopy
                  mov            esi,lpBNLocal
                  push      ecx
                  push      edi
                  rep            movsd
                  pop            edi
                  pop            ecx
                  ;<<<<<<<<<<<<<<<
                  dec            ecx
                  .repeat
                        mov            eax,[edi]
                        mul            dwValue
                        add            eax,ebx
                        mov            ebx,0
                        mov            [edi],eax
                        lea            edi,[edi+4]
                        adc            ebx,edx
                        dec            ecx
                  .until SIGN?
                  ;check for overflow
;                  .if dword ptr [edi-4] & 80000000h
;                        retv      -1
;                  .endif
                  .if ebx
                        retv      -1
                  .endif
                  popad
                  ;<<<<<<<<<<<<<<<<<<<<<<<<
                  ;unrolled BNAddEx >>>>>
                  pushad
                  mov            ecx,dwArraySize
                  mov            esi,lpBNRes
                  mov            edi,lpBNResult
                  sub            ecx,1                        ;dec ecx|and eax,eax
                  .repeat
                        mov            eax,[esi]
                        lea            esi,[esi+4]
                        adc            [edi],eax
                        lea            edi,[edi+4]
                        dec            ecx
                  .until SIGN?
                  popad
                  ;<<<<<<<<<<<<<<<<<<<<<<
                  .if CARRY?
                        retv      -1
                  .endif
            .endif
            ;shift lpBNLocal (ex lpBN1) 32 bits to the left, ignore CARRY
            ;unrolled BNShl32Ex >>>>>
            push      ecx
            push      esi
            push      edi
            mov            ecx,dwArraySize
            mov            esi,lpBNLocal
            dec            ecx
            lea            edi,[esi+ecx*4]
            lea            esi,[esi+ecx*4-4]
            std
            rep            movsd
            cld
            mov            dword ptr [edi],0
            pop            edi
            pop            esi
            pop            ecx
            ;<<<<<<<<<<<<<<<<<<<<<<<
            lea            ecx,[ecx+4]                        ;DWORD offset
            dec            ebx                                    ;iterations
      .until SIGN?
      
@@:
      POP_STACK_BN
      POP_STACK_BN
      popad
      
      ret
BNMul      endp