quickest way to retrieve HO and LO words of a dword ?

[gelatine1]

I implemented this piece of code and I was wondering if there isn't a quicker/ better way to do this:

Code Select Expand


;variables used in code below
;x2 dd ?
;y2 dd ?

mov eax,lParam ;Get coords from lParam and store in x2 and y2
and eax,0FFFFh ;retrieve LO word
mov x2,eax
mov eax,lParam
and eax,0FFFF0000h ;retrieve HO word
ror eax,16 ;put HO word as LO word
mov y2,eax


Thanks in advance,
Jannes

[hutch--]

Code Select Expand


; DWORD in EAX
mov CX, AX
rol EAX, 16
mov DX, AX


[qWord]

low word = WORD ptr lParam
high word = WORD ptr lParam[2]

[gelatine1]

thanks , but do those work ? since I need to have the low word and high word stored in a dword and not just in a word like your codes are implying ?

[qWord]

use movzx or movsx according to the type.
e.g.:

Code Select Expand

movsx eax,WORD ptr lParam
movsx edx,WORD ptr lParam[2]
mov x,eax
mov y,edx

[gelatine1]

Thank you :exclaim:

[Gunther]

Hi gelatine1,

both solutions (Hutch and qWord) should work fine. It could be that Hutch's code gets a few penalty cycles inside a 32-bit segment. But that's all.

Gunther

[hutch--]

You got it in the form of 16 bit because that is what you asked for, the HI and LO WORDS of a dword.

[Tedd]

What's wrong with the classic:

Code Select Expand


    mov eax,lParam
    mov edx,eax
    shr eax,16      ;high word
    and edx,0FFFFh  ;low word
    mov y2,eax
    mov x2,edx


[jj2007]

What's wrong with the classic...

42% longer maybe?

[dedndave]

undoubtedly faster, too

[hutch--]

These are my 2, I would normally use the first.

Code Select Expand


    LOCAL tx    :DWORD
    LOCAL ty    :DWORD

  ; ------------------------------------- 1

    movsx eax, WORD PTR [lParam]
    movsx ecx, WORD PTR [lParam+2]
    mov tx, eax
    mov ty, ecx

    print uhex$(tx),"h  loword",13,10
    print uhex$(ty),"h  hiword",13,10

  ; ------------------------------------- 2

    mov edx, lParam
    movzx eax, dx
    rol edx, 16
    movzx ecx, dx
    mov tx, eax
    mov ty, ecx

    print uhex$(tx),"h  loword",13,10
    print uhex$(ty),"h  hiword",13,10

  ; -------------------------------------


[Gunther]

These are my 2, I would normally use the first.

yes, me to. It's a fast and clear solution.

Gunther

[jj2007]

Speed-wise I can't see much of a difference. Anyway, in a WndProc it won't matter if it's 2 cycles or 1.8 ( ::) )

Intel(R) Core(TM) i5-2450M CPU @ 2.50GHz (SSE4)

997     cycles for 500 * movzx
879     cycles for 500 * shr & and FFFFh
899     cycles for 500 * movsx

994     cycles for 500 * movzx
874     cycles for 500 * shr & and FFFFh
897     cycles for 500 * movsx

970     cycles for 500 * movzx
871     cycles for 500 * shr & and FFFFh
898     cycles for 500 * movsx

17      bytes for movzx
23      bytes for shr & and FFFFh
17      bytes for movsx

[dedndave]

a bit disappointed with the movzx/movsx speed
I wonder how much of that may be attributed to the unaligned word
my sister's machine: (I'm in Michigan this week)

Code Select Expand

Intel(R) Core(TM)2 Duo CPU     T7700  @ 2.40GHz (SSE4)

2035    cycles for 500 * movzx
1042    cycles for 500 * shr & and FFFFh
2042    cycles for 500 * movsx

2040    cycles for 500 * movzx
1042    cycles for 500 * shr & and FFFFh
2115    cycles for 500 * movsx

2034    cycles for 500 * movzx
1052    cycles for 500 * shr & and FFFFh
2041    cycles for 500 * movsx