8469
12688
8484
12672
8485
12672    

797
547
797
531
797
531    

        mov     ecx, VALUE
        test    eax, eax
        cmovnz  eax, ecx
        xor     eax, ecx    

IF REG = 0 THEN
  REG = VALUE1
ELSE
  REG = VALUE2
END IF    

Interestingly, nobody questions usefulness of these transformations yet.

        neg     reg
        sbb     reg, reg
        and     reg, VALUE1 xor VALUE2
        xor     reg, VALUE1    

Double cmov will surely beat it for r/m.

test eax, eax
mov eax, [VALUE2]
cmovz eax, [VALUE1]    

cmp ebx,0
cmovnz eax,[ebx]    

If the condition is not sastisfied, the instruction has no effect.

include 'win32ax.inc'

begin:
       mov     ebx,0
       cmp     ebx,0
       cmovnz  eax,[ebx]
   invoke  ExitProcess,0

.end begin    

To put both in equal positions perhaps this should be simulated instead:

Code:

IF REG = 0 THEN
  REG = VALUE1
ELSE
  REG = VALUE2
END IF    

    test    eax, eax
    setnz   al
  movzx   eax, al
     mov     eax, [Values + 4*eax]    

     Values  dd VALUE1, VALUE2    

include    'win32ax.inc'

VALUE1   = 0xABC
VALUE2       = 0xDEF

start:
   test    eax, eax
    setnz   al
  movzx   eax, al
     mov     eax, [Values + 4*eax]
       
    invoke  ExitProcess, 0
      
    Values  dd VALUE1, VALUE2

.end start    

... I think I've read somewhere in the manual that the memory cycle initiates always but it is stopped just before making the read/write.

IMO this is a major flaw with cmov. And another flaw is no available encoding for immediate values. It could have been so much better. Oh well.

With CMOV: 6391 ms
Without CMOV: 10687 ms    

TEST_COUNT = 01FFFFFFFh
UNROLL = 7

format PE console
include 'win32a.inc'
entry start ; setPriority
section ".data" data readable writeable
szFormatCMOV   db 'With CMOV: %d ms', 10, 0
szFormatNoCMOV db 'Without CMOV: %d ms', 10, 0
_repeat    db 'Repeat Test?',0
_pause     db 'pause',0
align 16
Values dd 1, 0 ; To force alternation

section ".code" code readable executable
start:
;;;;;; TEST MHajduk
      mov       ebp, TEST_COUNT
      call      [GetTickCount]
      push      eax
      xor       edx, edx ; The cheat, but actually made no difference to the "mov eax, 0" approach
align 64
.TST1:
     repeat UNROLL
        test    eax, eax
      ;  mov     eax, 0 ; was faster doing this and removing movzx
        setnz   dl
;        movzx   eax, al
        mov     eax, [Values + 4*edx]
     end repeat

      sub       ebp, 1
      jnz       .TST1
      call      [GetTickCount]
      pop       ebx
      sub       eax, ebx
      push      eax
      push      szFormatNoCMOV

;;;;;; TEST baldr (well, double cmov, the code was not actually posted)
      mov       ebp, TEST_COUNT
      call      [GetTickCount]
      push      eax
align 64
.TST2:
     repeat UNROLL
        test    eax, eax
        cmovnz  eax, [Values + 4]
        cmovz   eax, [Values]
     end repeat

      sub       ebp, 1
      jnz       .TST2
      call      [GetTickCount]
      pop       ebx
      sub       eax, ebx
      push      eax
      push      szFormatCMOV

;;;;;;
      call      [printf]
      add       esp, 8
      call      [printf]
      add       esp, 8

      invoke    MessageBox, 0, _repeat, _repeat, MB_YESNO
      cmp       eax, IDYES
      je        start
      cinvoke   system, _pause
      invoke    ExitProcess, 0

setPriority:
      invoke   GetCurrentProcess
      mov      ebx, eax
      invoke   SetPriorityClass, eax, REALTIME_PRIORITY_CLASS
      invoke   GetCurrentThread
      invoke   SetThreadPriority, eax, THREAD_PRIORITY_TIME_CRITICAL
      jmp      start

 section '.idata' import data readable writeable
                library kernel,'KERNEL32.DLL',\
                        msvcrt,'msvcrt.dll',\
                        user,'USER32.DLL'
                 import kernel,\
                       GetCurrentProcess, 'GetCurrentProcess',\
                       SetPriorityClass, 'SetPriorityClass',\
                       GetCurrentThread, 'GetCurrentThread',\
                       SetThreadPriority, 'SetThreadPriority',\
                       GetTickCount,'GetTickCount',\
                       ExitProcess,'ExitProcess'
                 import msvcrt,\
                       printf,'printf',\
                       system,'system'
                 import user,\
                       wsprintf,'wsprintfA',\
                       MessageBox,'MessageBoxA'    

macro @setD result,reg,const,fbool {
 mov eax,result
 mov ecx,const
 neg reg
 sbb edx,edx
 cmovnz reg,ecx
 match =FALSE,fbool \{
  xor reg,ecx
 \}
}
    

macro @set reg,const,fbool {
 mov ecx,const
 neg reg
 cmovnz reg,ecx
 sbb edx,edx
 match =FALSE,fbool \{
  xor reg,ecx
 \}
}