PureBasic Forums - English

Code: Select all

Procedure JIT(asm.s)    
  Protected oldProtection;
  Protected fn,*asm 
  Protected fasmpath.s = #PB_Compiler_Home + "Compilers" + #PS$ + "FAsm.exe" 
  Inputfile.s = GetTemporaryDirectory() + "PBJit.txt"  
  outputfile.s = GetTemporaryDirectory() + "PBJit.bin"  
  fn = CreateFile(-1,outputfile) 
  CloseFile(fn) 
  fn = CreateFile(-1,Inputfile) 
  If fn 
    *asm= UTF8(asm) 
    WriteData(fn,*asm,MemorySize(*asm)) 
    CloseFile(fn) 
    OpenConsole()  
    fasm =  RunProgram(fasmpath,Inputfile,"", #PB_Program_Open | #PB_Program_Read)
    If fasm 
      While ProgramRunning(fasm)
        If AvailableProgramOutput(fasm) 
          PrintN(ReadProgramString(fasm))
        EndIf 
      Wend    
    EndIf    
    FreeMemory(*asm) 
    
    If FileSize(outputfile) 
      fn = OpenFile(-1,outputfile)    
      len = Lof(fn) 
      *asm = AllocateMemory(Len)
      ReadData(fn,*asm,len)
      CloseFile(fn) 
      
      Protected *buffer = VirtualAlloc_(#Null, len, #MEM_COMMIT, #PAGE_READWRITE);
      CopyMemory(*asm,*buffer,len)
      FreeMemory(*asm) ;
      VirtualProtect_(*buffer, len, #PAGE_EXECUTE_READ, @oldProtection)          ;
      ProcedureReturn *buffer 
      
    EndIf 
  EndIf   
      
 EndProcedure 
   
 Prototype FastHash64(*Buffer, Len, Seed.q=0)
 Global *FastHash64.FastHash64
 
 Procedure JiTFastHash64()
         
   ; FastHash64 algorithm by Zilong Tan ported by wilbert
   Protected asm.s 
   asm + "use64 " + #LF$
   asm + "MOV    qword [rsp+8],rcx"+ #LF$
   asm + "MOV    qword [rsp+16],rdx"+ #LF$
   asm + "MOV    qword [rsp+24],r8"+ #LF$
   asm + "PS20=48"+ #LF$
   asm + "SUB    rsp,40"+ #LF$
   
   asm + "p.v_Seed equ rsp+PS20+16" + #LF$
   asm + "p.v_Len equ rsp+PS20+8"+ #LF$
   asm + "p.p_Buffer equ rsp+PS20+0"+ #LF$
      
   asm + "mov r10, 0x2127599bf4325c37" + #LF$ 
   asm + "mov r11, 0x880355f21e6d1965" + #LF$ 
   asm + "mov rdx, [p.p_Buffer]" + #LF$ 
   asm + "mov rcx, [p.v_Len]" + #LF$ 
   asm + "mov rax, rcx" + #LF$       ; h = seed ^ (len * m);
   asm + "imul rax, r11" + #LF$ 
   asm + "xor rax, [p.v_Seed]" + #LF$ 
   asm + "sub rcx, 8" + #LF$ 
   asm + "jc .l1" + #LF$ 
   ; 8 byte loop  
   asm + ".l0: " + #LF$ 
   asm + "mov r8, [rdx]" + #LF$         ; v = *pos++;
   asm + "add rdx, 8" + #LF$ 
   ; -- mix(v) start --
   asm + "mov r9, r8" + #LF$ 
   asm + "shr r9, 23" + #LF$ 
   asm + "xor r8, r9" + #LF$ 
   asm + "imul r8, r10" + #LF$ 
   asm + "mov r9, r8" + #LF$ 
   asm + "shr r9, 47" + #LF$ 
   asm + "xor r8, r9" + #LF$ 
   ; -- mix end --
   asm + "xor rax, r8" + #LF$           ; h ^= mix(v);
   asm + "imul rax, r11" + #LF$         ; h *= m;
   asm + "sub rcx, 8" + #LF$ 
   asm + "jnc .l0" + #LF$ 
   ; remaining bytes
   asm + ".l1: " + #LF$ 
   asm + "add rcx, 8" + #LF$ 
   asm + "jz .l5" + #LF$ 
   asm + "xor r8, r8" + #LF$ 
   asm + "test rcx, 4" + #LF$ 
   asm + "jz .l2" + #LF$ 
   ; get 4 bytes
   asm + "mov r8d, [rdx]" + #LF$ 
   asm + "add rdx, 4" + #LF$ 
   asm + "ror r8, 32" + #LF$ 
   asm + ".l2: " + #LF$ 
   asm + "test rcx, 2" + #LF$ 
   asm + "jz .l3" + #LF$ 
   ; get 2 bytes
   asm + "movzx r9d, word [rdx]" + #LF$ 
   asm + "add rdx, 2" + #LF$ 
   asm + "xor r8, r9" + #LF$ 
   asm + "ror r8, 16" + #LF$ 
   asm + ".l3: " + #LF$ 
   asm + "test rcx, 1" + #LF$ 
   asm + "jz .l4" + #LF$ 
   ; get 1 byte
   asm + "movzx r9d, byte [rdx]" + #LF$ 
   asm + "xor r8, r9" + #LF$ 
   asm + "ror r8, 8" + #LF$ 
   asm + ".l4: ";  + #LF$ 
   asm + "and rcx, 7" + #LF$ 
   asm + "shl rcx, 3" + #LF$ 
   asm + "rol r8, cl" + #LF$ 
   ; -- mix(v) start --
   asm + "mov r9, r8" + #LF$ 
   asm + "shr r9, 23" + #LF$ 
   asm + "xor r8, r9" + #LF$ 
   asm + "imul r8, r10" + #LF$ 
   asm + "mov r9, r8" + #LF$ 
   asm + "shr r9, 47" + #LF$ 
   asm + "xor r8, r9" + #LF$ 
   ; -- mix end --
   asm + "xor rax, r8" + #LF$           ; h ^= mix(v);
   asm + "imul rax, r11" + #LF$         ; h *= m;
   ; -- mix(h) start --
   asm + ".l5: " + #LF$ 
   asm + "mov r9, rax" + #LF$ 
   asm + "shr r9, 23" + #LF$ 
   asm + "xor rax, r9" + #LF$ 
   asm + "imul rax, r10" + #LF$ 
   asm + "mov r9, rax" + #LF$ 
   asm + "shr r9, 47" + #LF$ 
   asm + "xor rax, r9" + #LF$ 
   asm + "add rsp,40"+ #LF$ 
   asm + "ret" + #LF$  
   
   ProcedureReturn JIT(asm)   
   
 EndProcedure
 
  Procedure.q FastHash64C(*buf,len,Seed.q=0)
    Protected result.q  
    ;FastHash64 algorithm by Zilong Tan
    !typedef unsigned long long uint64_t; 
    
    !#define mix(h) ({				      	  \
    !			(h) ^= (h) >> 23;		          \
    !			(h) *= 0x2127599bf4325c37ULL;	\
    !			(h) ^= (h) >> 47; })
    !
    
    !	const uint64_t m = 0x880355f21e6d1965ULL;
    !	const uint64_t *pos = (const uint64_t *)p_buf;
    !	const uint64_t *end = pos + (v_len / 8);
    !	const unsigned char *pos2;
    !	uint64_t h = v_seed ^ (v_len * m);
    !	uint64_t v;
    ! uint64_t result; 
    
    !	while (pos != end) {
    !		v  = *pos++;
    !		h ^= mix(v);
    !		h *= m;
    !	}
    
    !	pos2 = (const unsigned char*)pos;
    !	v = 0;
    
    !	switch (v_len & 7) {
    !	case 7: v ^= (uint64_t)pos2[6] << 48;
    !	case 6: v ^= (uint64_t)pos2[5] << 40;
    !	case 5: v ^= (uint64_t)pos2[4] << 32;
    !	case 4: v ^= (uint64_t)pos2[3] << 24;
    !	case 3: v ^= (uint64_t)pos2[2] << 16;
    !	case 2: v ^= (uint64_t)pos2[1] << 8;
    !	case 1: v ^= (uint64_t)pos2[0];
    !		h ^= mix(v);
    !		h *= m;
    !	}
    !
    !	v_result = mix(h);
    
    ProcedureReturn result 
  EndProcedure  
 
 Global str.s = "Hello JIT function" 
 
 *FastHash64 = JiTFastHash64()
 If *FastHash64 
   Debug *FastHash64(@str,StringByteLength(str)) 
 EndIf 
 
 Debug FastHash64C(@str,StringByteLength(str))