The MASM Forum

I want to test for a negative number so I can convert to an absolute value but would like to not use a conditional like below or jump. How would I do that?
edited for clarification...
; Check for a negative number
.if ax & 08000h
     neg ax
.endif


Tim

Hello,

You can check the most significant bit of ax :

include    \masm32\include\masm32rt.inc

.data

msg1        db 'Postive',0
msg2        db 'Negative',0

.code

start:

    mov   ax,-9
    test  ax,8000h
    jnz   NegResult

    invoke  StdOut,ADDR msg1
    jmp    _exit

NegResult:

    invoke  StdOut,ADDR msg2
   
_exit:

    invoke  ExitProcess,0

END start


QuoteIn the x86 assembly language, the TEST instruction performs a bitwise AND on two operands. The flags SF, ZF, PF are modified while the result of the AND is discarded. The OF and CF flags are set to 0, while AF flag is undefined.

https://en.wikipedia.org/wiki/TEST_(x86_instruction)

Well, Vortex, the correct (and simplest) answer to the OP's question would have been "yes":
.if ax & 08000h
    neg ax
.endif
does the same thing as TEST (which as you pointed out is a non-destructive AND).

I want to do it without branching.

What about this?

.if ax > 08000h
add ax, 1        ; add 1 since we get a 1s compliment from below
.endif
mov bx, ax
sar bx, 15
xor ax, bx


Quote from: tda0626 on May 25, 2024, 05:32:07 AMI want to do it without branching.

What about this?

Code Select Expand

.if ax > 08000h
        add ax, 1        ; add 1 since we get a 1s compliment from below
    .endif


Well, that's a branch right there.
(1s complement)

The shortest (and usually fastest) version:

test ax, ax
.if Sign?
   ...

Quote from: tda0626 on May 25, 2024, 05:32:07 AMI want to do it without branching.

What about this?

Code Select Expand

.if ax > 08000h
        add ax, 1        ; add 1 since we get a 1s compliment from below
    .endif
    mov bx, ax
    sar bx, 15
    xor ax, bx


Check replace j** with set** after cmp or test
Set** sets a register to 1 or 0 depending on cmp result instead  j**

Quote from: daydreamer on May 25, 2024, 07:04:38 PMSet** sets a register to 1 or 0 depending on cmp result

That is correct, and I've used the "branchless" set* instruction sometimes. However, it's quite limited, as a) it sets the byte, not the DWORD, i.e. al, not eax, and b) you get only 0 or 1. If that is sufficient, perfect.

Quote from: tda0626 on May 25, 2024, 04:06:09 AMI want to test for a negative number and can't seem to find any documentation on it but was wondering if this was ok.

Code Select Expand

; Check for a negative number
.if ax & 08000h
     neg ax
.endif


Tim

  mov dx,ax
  neg dx
  bt ax,15
  cmovc ax,dx


Hi all!

So far I understand, branchless means that you don't use any conditional instruction.

See code:
include    \masm32\include\masm32rt.inc

.data
    msg1        db 'Postive',0
    msg2        db 'Negative',0
    table  dd offset msg1
           dd offset msg2
.code

start:
    mov eax,  0
    mov  ax, -9        ; value to test
    shr  ax, 15

    lea edx, table
    mov ecx, [edx+eax*4]

    print ecx, 13,10

    inkey

    invoke  ExitProcess,0

END start
In this case I used Vortex example. But usually table contains address to jump.

Regards, HSE.

I figured branchless = no jumps

Quote from: sinsi on May 26, 2024, 02:02:11 AMI figured branchless = no jumps

Correctamundo.

I believe this is the canonical easiest way to implement a branch-less abs(), which is what the OP is after (16-bit version):
  CWD               ;Sign-extend AX to DX:AX
  XOR  AX, DX
  SUB  AX, DX


Couldn't see the forest for the trees, was blinded by the question and didn't follow the code.

Did you mean CWD?

Whoops, yeah: should be
  CWD              ;Sign-extend AX to DX:AX
  XOR  AX, DX
  SUB  AX, DX

Quote from: NoCforMe on May 26, 2024, 03:06:57 AMI believe this is the canonical easiest way to implement a branch-less abs(), which is what the OP is after (16-bit version):

Code Select Expand

  CBW              ;Sign-extend AX to DX:AX
  XOR  AX, DX
  SUB  AX, DX


:biggrin:

More easy:

and ax, 7FFFh

Quote from: jj2007 on May 25, 2024, 11:18:08 PM

Quote from: daydreamer on May 25, 2024, 07:04:38 PMSet** sets a register to 1 or 0 depending on cmp result

That is correct, and I've used the "branchless" set* instruction sometimes. However, it's quite limited, as a) it sets the byte, not the DWORD, i.e. al, not eax, and b) you get only 0 or 1. If that is sufficient, perfect.

You can use movd xmm0,eax so you can use sse2 instruction set for byte,word,dword sized branchless cmp
Result in 0 or 0ffffffffh mask you can use for example conditional add
Mov ebx,speed
And ebx,mask
Add edx,ebx
Similar thinking in basic
X=x+(inkey=right arrow)*speed

Neg = not eax
Inc eax

Quote from: HSE on May 26, 2024, 04:09:49 AMMore easy:

Code Select Expand

and ax, 7FFFh

Dang.
I didn't believe you. Then I coded up a li'l testbed. It works.
So why do people use that more complicated method that I posted when all you got to do is get rid of the high bit?
Are there any corner cases where this doesn't work?

---

Yes; it doesn't work.
[e:\programming stuff\assembly language\windows\snippets]abstest
abs(-832) = 2147482816     - WRONG
abs(832) = 832
abs(-1) = 2147483647       - WRONG
abs(-2147483648) = 0       - WRONG

(last value was 80000000h (32-bit test))

So there's a reason to use the more complex one.

Well, my method works. Sort of:
[e:\programming stuff\assembly language\windows\snippets]abstest
abs(-832) = 832
abs(832) = 832
abs(-1) = 1
abs(-2147483648) = -2147483648
Last value tested was 80000000h. Why didn't that work?
I'm using wsprintf() to display everything. Format string is
ResultFmt        DB "abs(%d) = %d", $CRLF, 0
%d shows a DWORD as a signed value, right?

So [dumb question]: what is the (signed decimal) value of 80000000h? Or is that not a valid twos-complement number?

Guess there are many ways to do this and appreciate the examples. Came along this one at Stack Overflow:


AT&T syntax


movl  -8(%rbp), %eax    # -8(%rbp) is memory for x on stack
  sarl  $31, %eax         #  shift arithmetic right: x >> 31, eax now represents y
  movl  %eax, %edx        # 
  xorl  -8(%rbp), %edx    #  %edx = x XOR y
  movl  %edx, -4(%rbp)    # -4(%rbp) is memory for output on stack
  subl  %eax, -4(%rbp)    # (x XOR y) - y


OK, the answer is (drumroll, please):

Quote0x80000000 is + 2,147,483,648 which doesn't fit in a 32-bit signed int but does in a 32-bit unsigned int

Another blind spot of mine; I still have problems wrapping my head around twos-complement arithmetic.

So the largest 32-bit signed value is 7FFFFFFFh (2147483647). But what is the smallest (negative) value)?

---

Testbed program gives the answer: it's 80000001h (-2147483647). OK, good to know.

Quote from: tda0626 on May 26, 2024, 05:13:54 AMGuess there are many ways to do this and appreciate the examples. Came along this one at Stack Overflow:

Code Select Expand

movl  -8(%rbp), %eax    # -8(%rbp) is memory for x on stack
  sarl  $31, %eax         #  shift arithmetic right: x >> 31, eax now represents y
  movl  %eax, %edx        # 
  xorl  -8(%rbp), %edx    #  %edx = x XOR y
  movl  %edx, -4(%rbp)    # -4(%rbp) is memory for output on stack
  subl  %eax, -4(%rbp)    # (x XOR y) - y


If you check, this is just a (needlessly) more complex version of what I posted above.

Quote from: NoCforMe on May 26, 2024, 05:19:10 AM

Quote from: tda0626 on May 26, 2024, 05:13:54 AMGuess there are many ways to do this and appreciate the examples. Came along this one at Stack Overflow:

Code Select Expand

movl  -8(%rbp), %eax    # -8(%rbp) is memory for x on stack
  sarl  $31, %eax         #  shift arithmetic right: x >> 31, eax now represents y
  movl  %eax, %edx        # 
  xorl  -8(%rbp), %edx    #  %edx = x XOR y
  movl  %edx, -4(%rbp)    # -4(%rbp) is memory for output on stack
  subl  %eax, -4(%rbp)    # (x XOR y) - y


If you check, this is just a (needlessly) more complex version of what I posted above.

Ok good to know.

Quote from: NoCforMe on May 26, 2024, 04:53:21 AMYes; it doesn't work.

:eusa_clap:

The probability to have same error in test was close to 0, I was a little worried  :biggrin: