pText             db "tasking", 0 ;out hash is 0x6431452F21E4F77A
FNV1Hash:
dqSizeText =7
        mov rax,14695981039346656037 ;rax = offset_basis - set to 14695981039346656037 for FNV-1
        mov rcx, dqSizeText
        mov r8, pText

        mov r9, 0100000001B3h     ;r9 = FNV_64_PRIME = 1099511628211
        xor rbx, rbx              ;rbx = 0
nextbyte:
        mul r9                    ;rax = rax * FNV_64_PRIME
        mov bl, [r8]              ;bl = byte from r8
        xor rax, rbx              ;al = al xor bl
        inc r8                    ;inc buffer pos
        dec rcx                   ;rcx = rcx - 1 (counter)
        jnz nextbyte              ;if rcx != 0, jmp to nextbyte
        ret                       ;rax = fnv1 hash
    

Hash:
  label .result.low  dword at esp + 0
  label .result.high dword at esp + 4
  label .lpszText    dword at esp + 24
  label .cchText     dword at esp + 28
    push ebx
    push esi
    push edi
    push [.hash.high]
    push [.hash.low]
    mov  ebx, [.mult.low]
    mov  edi, [.mult.high]
    mov  esi, [.lpszText]
    mov  ecx, [.cchText]

  .loop:
    mov  eax, [.result.high]
    mul  edi
    xchg eax, [.result.high]
    mul  ebx
    add  edx, [.result.high]
    xchg eax, [.result.low]
    push eax
    mul  edi
    mov  edx, eax
    pop  eax
    add  [.result.low], edx
    mul  ebx
    add  [.result.low], eax
    adc  [.result.high], edx
    xor  al, byte [esi]
    inc  esi
    loop .loop
    pop  eax ; mov  eax, [.result.low]
    pop  edx ; mov  edx, [.result.high]
             ; add  esp, 8
    pop  edi
    pop  esi
    pop  ebx
    retn 8
label .hash.low  dword
label .hash.high dword at .hash.low + 4
.hash         dq 14695981039346656037
label .mult.low  dword
label .mult.high dword at .mult.low + 4
.mult         dq 0100000001B3h    

How about VPMULLQ ?
Multiply the packed qword signed integers in xmm2 and xmm3/m128/m64bcst and store the low 64 bits of each product in xmm1 under writemask k1.

For a 64-bit program, this check may not be performed because most processors capable of operating in 64-bit mode can work with SSE4.1

My 64-bit CPU doesn't have SSE4.

My 64-bit CPU doesn't have SSE4.

MUL64_MEMORY:
     mov eax, [val1high]
     mov esi, [val1low]
     mov ecx, [val2high]
     mov ebx, [val2low]

     mul ebx
     xchg eax, ebx  ; partial product top 32 bits
     mul esi
     xchg esi, eax ; partial product lower 32 bits
     add ebx, edx
     mul ecx
     add ebx, eax  ; final upper 32 bits
; answer here in EBX:ESI    

Hash:
  label .lpszText    dword at esp + 20
  label .cchText     dword at esp + 24
    push ebp
    push ebx
    push esi
    push edi
    mov  ebx, [.hash.low]
    mov  ebp, [.hash.high]
    mov  esi, [.lpszText]
    mov  ecx, [.cchText]

  .loop:
    mov  eax, ebp
    mul  [.mult.high]
    xchg eax, ebp
    mul  [.mult.low]
    add  ebp, edx
    xchg eax, ebx
    mov  edi, eax
    mul  [.mult.high]
    add  ebx, eax
    mov  eax, ebp
    mul  [.mult.low]
    add  ebx, eax
    adc  ebp, edx
    lods byte [esi]
    xor  bl, al
    loop .loop

    mov  eax, ebx
    mov  edx, ebp
    pop  edi
    pop  esi
    pop  ebx
    pop  ebp
    retn 8

align 16
label .hash.low  dword
label .hash.high dword at .hash.low + 4
.hash         dq 14695981039346656037
label .mult.low  dword
label .mult.high dword at .mult.low + 4
.mult         dq 0100000001B3h    

hash64:
    push rbx
    mov  rax, [.base_value]
    mov  r8,  rdx
    mov  r9,  [.mult_value]
    xor  rbx, rbx
  .loop:
    mul  r9
    mov  bl, [r8]
    xor  rax, rbx
    inc  r8
    loop .loop
    pop  rbx
    retn

align 8
  .base_value dq 14695981039346656037
  .mult_value dq 0100000001B3h    

hash32: ; ecx = cchLength, edx = lpszText
    push ebp
    push ebx
    push esi
    push edi
    mov  ebx, [.base_value.low]
    mov  ebp, [.base_value.high]
    mov  esi, edx

  .loop:
    mov  eax, [.mult_value.high]
    mov  edi, [.mult_value.low]
    mul  ebx
    xchg eax, ebx
    mul  edi
    xchg edi, eax
    add  ebx, edx
    mul  ebp
    lea  ebp, [ebx+eax]
    mov  ebx, edi
    lods byte [esi]
    xor  bl, al
    loop .loop
    mov  eax, ebx
    mov  edx, ebp
    pop  edi
    pop  esi
    pop  ebx
    pop  ebp
    retn

align 8
  label .base_value.low  dword
  label .base_value.high dword at $ + 4
  .base_value dq 14695981039346656037
  label .mult_value.low  dword
  label .mult_value.high dword at $ + 4
  .mult_value dq 0100000001B3h    

; string db 'tasking'
; hash32 = 0xC408FE07C248E99E
; hash64 = 0xC408FE07C248E99E