哪个更快:x<<1或x<<10?

x << 3 ((x << 1) << 1) << 1

2. x << 10

3. x << 1

add x,x

my favorite CPU x<<2 x<<1

      shift-expression:
              additive-expression
              shift-expression <<  additive-expression
              shift-expression >>  additive-expression

x = y << z;

x = y >> z;

x<<1 x<<10

byte1 = (byte1 << 1) | (byte2 >> 7)
byte2 = (byte2 << 1)

byte1 = (byte2 << 2)
byte2 = 0

x<<1

x << 1 x+x

Intel Haswell add shl http://agner.org/optimize/ x86

cl shl eax,1 add eax,eax shl eax,10

int arr[]; arr[x<<1]

x edi eax x<<10

LEA instruction lets you shift-and-add

gcc and clang both optimize these functions the same way, as you can see on the Godbolt compiler explorer

int shl1(int x) { return x<<1; }
    lea     eax, [rdi+rdi]   # 1 cycle latency, 1 uop
    ret

int shl2(int x) { return x<<2; }
    lea     eax, [4*rdi]    # longer encoding: needs a disp32 of 0 because there's no base register, only scaled-index.
    ret

int times5(int x) { return x * 5; }
    lea     eax, [rdi + 4*rdi]
    ret

int shl10(int x) { return x<<10; }
    mov     eax, edi         # 1 uop, 0 or 1 cycle latency
    shl     eax, 10          # 1 uop, 1 cycle latency
    ret

lea eax, [rdi + rsi + 123] Why is this C++ code faster than my hand-written assembly for testing the Collatz conjecture?

mov Can x86's MOV really be "free"? Why can't I reproduce this at all?

How to multiply a register by 37 using only 2 consecutive leal instructions in x86?

if(x<<1) { } and test test eax, 0x7fffffff jz .false shl eax,1 / jz

move