Set n highest bits twiddling - c

Question

I have the following function that sets the N highest bits, e.g. set_n_high(8) == 0xff00000000000000
uint64_t set_n_high(int n)
{
uint64_t v = 0;
int i;
for (i = 63 ; i > 63 - n; i--) {
v |= (1llu << i);
}
return v;
}
Now just out of curiosity, is there any way in C to accomplish the same without using a loop (or a lookup table) ?
EDIT: n = 0 and n = 64 are cases to be handled, just as the loop variant does.

Answer 1

If you're OK with the n = 0 case not working, you can simplify it to
uint64_t set_n_high(int n)
{
return ~UINT64_C(0) << (64 - n);
}
If, in addition to that, you're OK with "weird shift counts" (undefined behaviour, but Works On My Machine), you can simplify that even further to
uint64_t set_n_high(int n)
{
return ~UINT64_C(0) << -n;
}
If you're OK with the n = 64 case not working, you can simplify it to
uint64_t set_n_high(int n)
{
return ~(~UINT64_C(0) >> n);
}
If using this means that you have to validate n, it won't be faster. Otherwise, it might be.
If you're not OK with either case not working, it gets trickier. Here's a suggestion (there may be a better way)
uint64_t set_n_high(int n)
{
return ~(~UINT64_C(0) >> (n & 63)) | -(uint64_t)(n >> 6);
}
Note that negating an unsigned number is perfectly well-defined.

Answer 2

uint64_t set_n_high(int n) {
return ((1llu << n) - 1) << (64-n);
}

Answer 3

Use a conditional to handle n == 0 and then it becomes trivial.
uint64_t set_n_high(int n) {
/* optional error checking:
if (n < 0 || n > 64) do something */
if (n == 0) return 0;
return -(uint64_t)1 << 64 - n;
}
There’s really no good reason to do anything more complicated than that. The cast from int to uint64_t is fully specified, as are the negation and shift (because the shift amount is guaranteed to lie in [0,63] if n is in [0,64]).

Answer 4

well taking #harold's answer and changing it a little:
uint64_t set_n_high(int n)
{
int carry = n>>6;
return ~((~0uLL >> (n-carry)) >> carry);
}

Answer 5

For what it's worth, of the posts so far (that handle n of 0-64), this one produces the least amount of assembly on an x86_64 and a raspberry pi (and does 1 branch operation) (with gcc 4.8.2). It looks fairly readable too.
uint64_t set_n_high2(int n)
{
uint64_t v = 0;
if (n != 0) {
v = ~UINT64_C(0) << (64 - n);
}
return v;
}

Answer 6

Well I'm presenting a weird-looking one.
:)
/* works for 0<=n<=64 */
uint64_t set_n_high(int n)
{
return ~0llu << ((64 - n) / 4) << ((64 - n) * 3 / 4);
}