Add bittest intrinsics

[MSxDOS]

This is a feature request to add bittest intrinsics. I'm particularly interested in _bittest64.

[gnzlbg]

The intrinsics are:

unsigned char _bittest (__int32* a, __int32 b)
unsigned char _bittest64 (__int64* a, __int64 b)
unsigned char _bittestandcomplement (__int32* a, __int32 b)
unsigned char _bittestandcomplement64 (__int64* a, __int64 b)
unsigned char _bittestandreset (__int32* a, __int32 b)
unsigned char _bittestandreset64 (__int64* a, __int64 b)
unsigned char _bittestandset (__int32* a, __int32 b)
unsigned char _bittestandset64 (__int64* a, __int64 b)

they do not require any target features available. I'd suggest putting them in a bt.rs module in the x86/x86_64 arch modules. Their Rust signature would be (EDIT: the following has been updating according to alex comment - it used to contain *mut instead of &mut:

/// Return the bit at index `b` of 32-bit integer `a`.
#[cfg_attr(test, assert_instr(bt))]
unsafe fn _bittest(a: &i32, b: i32) -> u8;
/// Return the bit at index `b` of 64-bit integer `a`.
#[cfg_attr(test, assert_instr(bt))]
unsafe fn _bittest64(a: &i64, b: i64) -> u8;
/// Return the bit at index `b` of 32-bit integer `a`, and set that bit to its complement.
#[cfg_attr(test, assert_instr(btc))]
unsafe fn _bittestandcomplement(a: &mut i32, b: i32) -> u8;
/// Return the bit at index `b` of 64-bit integer `a`, and set that bit to its complement.
#[cfg_attr(test, assert_instr(btc))]
unsafe fn _bittestandcomplement64(a: &mut i64, b: i64) -> u8;
/// Return the bit at index `b` of 32-bit integer `a`, and set that bit to zero.
#[cfg_attr(test, assert_instr(btr))]
unsafe fn _bittestandreset(a: &mut i32, b: i32) -> u8;
/// Return the bit at index `b` of 64-bit integer `a`, and set that bit to zero.
#[cfg_attr(test, assert_instr(btr))]
unsafe fn _bittestandreset64(a: &mut i64, b: i64) -> u8;
/// Return the bit at index `b` of 32-bit integer `a`, and set that bit to one.
#[cfg_attr(test, assert_instr(bts))]
unsafe fn _bittestandset(a: &mut i32, b: i32) -> u8;
/// Return the bit at index `b` of 64-bit integer `a`, and set that bit to one.
#[cfg_attr(test, assert_instr(bts))]
unsafe fn _bittestandset64(a: &mut i64, b: i64) -> u8;

cc @alexcrichton I don't recall whether we should stick here to raw pointers, or whether we should use & and &mut. I guess the verification tool will let us know.

[gnzlbg]

I can't find these in clang, so I don't really know how easy / hard their implementation would be. I'd suggest using bitwise operations and letting the tests run to see if the appropriate instructions are generated. If that's not the case, we should fill in an LLVM bug for that, and work around it using inline assembly.

[alexcrichton]

I think it's fine to expose &mut as I think we've done it for at least one other intrinsic