I expect the multiply_by_pow_of_2 function below to have a more optimized code for multiplication since I used the [[ assume( std::has_single_bit( multiplier ) ) ]]; which is supposed to tell the compiler that 2nd parameter multiplier is always a power of 2. So maybe it could generate faster code. However it generates the same code (using imul):

multiply_by_pow_of_2(unsigned int, unsigned int):
        mov     eax, esi
        imul    eax, edi
        ret

With that said, calling this function in main and comparing its generated code with that of argc * 8 shows that both change to the usual lea (and not to something like a shift left):

        lea     esi, [0+rdi*8]

Here (live):

#include <bit>
#include <cstdio>


unsigned multiply_by_pow_of_2( unsigned num, unsigned multiplier ) noexcept
{
    [[ assume( std::has_single_bit( multiplier ) ) ]];
    return num * multiplier;
}

int main( int argc, char* argv[ ] )
{
    unsigned result;

    if constexpr ( true )
    {
        result = multiply_by_pow_of_2( argc, 8 );
    }
    else
    {
        result = argc * 8;
    }

    std::printf( "%dn", result );
}

which gives (using -O3):

multiply_by_pow_of_2(unsigned int, unsigned int):
        mov     eax, esi
        imul    eax, edi
        ret
.LC0:
        .string "%dn"
main:
        sub     rsp, 8
        lea     esi, [0+rdi*8] ; <- here
        xor     eax, eax
        mov     edi, OFFSET FLAT:.LC0
        call    printf
        xor     eax, eax
        add     rsp, 8
        ret

The function’s code remains the same with or without the assumption statement. Am I failing to convince the compiler that multiplier is a power of 2? How can this be done?