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

[via llvm-bugs]

https://bugs.llvm.org/show_bug.cgi?id=33188

            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
ChakraCore:
https://github.com/Microsoft/ChakraCore/blob/master/lib/Common/CommonPal.h#L647

    __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;
        asm(
            "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;
#else
        return _bittestandset(_BitBase, _BitPos);
#endif
    }

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
mode).
• 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>