mov rdx,not (1 shl 63)
and rax,rdx
;
mov rdx,1 shl 63
andn rax,rdx,rax
;
shl rax,1
clc
rcr rax,1    

shl rax, 1
shr rax, 1    

bt qword [rax],rcx    

The shr rax, 1 is faster than clc followed by rcr rax, 1.

SeproMan wrote:

The shr rax, 1 is faster than clc followed by rcr rax, 1.

This might correct in some cases. There are many other things that can affect the runtime that can overwhelm the execution time of an extra instruction.

All we can really say by just reading the code is that it uses one fewer instruction. Anything else is speculation.

Probably because it has more latency and same/less throughput, on most (or all?) CPUs.

bt* instructions are super fast as long as you don't use memory operands. It's only the memory operand versions that are slow and micro-coded (mostly because of what macomics wrote about them addressing more than 8 bytes).

Furs wrote:

bt* instructions are super fast as long as you don't use memory operands. It's only the memory operand versions that are slow and micro-coded (mostly because of what macomics wrote about them addressing more than 8 bytes).

I am familiar with this disadvantage. That's why instructions are not so popular for working with bit strings. It is much easier to work with memory with ordinary logical commands. But the initial idea of the command with the receiver in memory was good. As always, the implementation failed.

I obviously understand that sometimes the offset or mask are already there, just asking about the common case.

; rdx - bit string pointer, rcx - bit number
mov ah, cl
mov al, 1
and cl, 7
shl al, cl
mov cl, ah
xor al, -1
shr rcx, 3
and [rdx + rcx], al

; or

btr qword [rdx], rcx    

Perhaps you will do something more optimal, but btr can generally be replaced with this code

Code:

; rdx - bit string pointer, rcx - bit number
mov ah, cl
mov al, 1
and cl, 7
shl al, cl
mov cl, ah
xor al, -1
shr rcx, 3
and [rdx + rcx], al

; or

btr qword [rdx], rcx    

Q. clearing the bit 63 of a register
A. SHR reg,1

rol reg, 1
shr reg, 1    

If you don't test then you don't know.

Science:
1. Make a hypothesis
2. Test the hypothesis
3. Use the results to update your knowledge..

Religion
1. Make a hypothesis.
2. Assume it is true.
3. Fight to the death to defend your beliefs.

Please, make sure you’ve read the disclaimer specifically targeted at you. Thanks.

... and the possibility of multiple instructions running faster than a single one is limited to the processor’s internals, especially the number of pipeline stages and pipelines

value dq 0x...

and byte [value+7], 0x7F
mov reg64, [value]