[llvm-bugs] [Bug 33188] New: Clang's _bittest* MSVC intrinsics are incorrect for values outside [0, 31]

via llvm-bugs llvm-bugs at lists.llvm.org
Fri May 26 15:15:28 PDT 2017


            Bug ID: 33188
           Summary: Clang's _bittest* MSVC intrinsics are incorrect for
                    values outside [0, 31]
           Product: clang
           Version: unspecified
          Hardware: PC
                OS: Windows NT
            Status: NEW
          Severity: enhancement
          Priority: P
         Component: Headers
          Assignee: unassignedclangbugs at nondot.org
          Reporter: rnk at google.com
                CC: llvm-bugs at lists.llvm.org

I discovered this while staring at Microsoft's platform adaption layer code in

    __forceinline unsigned char _BitTestAndSet(LONG *_BitBase, int _BitPos)
#if defined(__clang__) && !defined(_ARM_)
        // Clang doesn't expand _bittestandset intrinic to bts, and it's
implemention also doesn't work for _BitPos >= 32
        unsigned char retval = 0;
            "bts %[_BitPos], %[_BitBase]\n\t"
            "setc %b[retval]\n\t"
            : [_BitBase] "+m" (*_BitBase), [retval] "+rm" (retval)
            : [_BitPos] "ri" (_BitPos)
            : "cc" // clobber condition code
        return retval;
        return _bittestandset(_BitBase, _BitPos);

It's a shame that nobody filed this bug upstream. :(

The Intel manual supports confirms this view:
BT—Bit Test
Selects the bit in a bit string (specified with the first operand, called the
bit base) at the bit-position designated by
the bit offset (specified by the second operand) and stores the value of the
bit in the CF flag. The bit base operand
can be a register or a memory location; the bit offset operand can be a
register or an immediate value:
• If the bit base operand specifies a register, the instruction takes the
modulo 16, 32, or 64 of the bit offset
operand (modulo size depends on the mode and register size; 64-bit operands are
available only in 64-bit
• If the bit base operand specifies a memory location, the operand represents
the address of the byte in memory
that contains the bit base (bit 0 of the specified byte) of the bit string. The
range of the bit position that can be
referenced by the offset operand depends on the operand size.
See also: Bit(BitBase, BitOffset) on page 3-11. 

We either need to codegen this with an intrinsic or inline asm that will
reliably select to bts, or we need to do an array indexing operation first.

You are receiving this mail because:
You are on the CC list for the bug.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-bugs/attachments/20170526/2c5be1ad/attachment.html>

More information about the llvm-bugs mailing list