bitfield mask calculation macro

Question

We have a set of C macros, here, for using the preprocessor to do bitfield operations, and we run into warnings when attempting to use these macros in visual studio. The problem can be demonstrated very easily:

#define BITFIELD_WIDTHMASK(Width) \
    ((Width) >= 32 ? ~0x0ul : (1ul << (Width)) - 1)

unsigned long foo(void)
{
    return BITFIELD_WIDTHMASK(32);
}

Compiling this with MSVC yields the warning:

test.c(12) : warning C4293: '<<' : shift count negative or too big, undefined behavior

This isn't a behavior problem - the << operator won't be used in this case, and that should be detected at compile time. But does anyone have any suggestions about how to rewrite the macro to avoid the warning? Or, failing that, how to redesign the macro interface for this?

Thanks in advance

Answer 1

#define BITFIELD_WIDTHMASK(Width) (((0x80000000ul >> (32-Width)) << 1) - 1)

Or to handle width of 0 as well as requested...

#define BITFIELD_WIDTHMASK(Width) \
  ((Width) >= 32 \
  ? ~0x0ul \
  : (((1ul << ((Width)/2)) << ((Width)/2)) << ((Width)&1)) - 1)

Answer 2

The preprocessor not the compiler evaluates the expression when Width is a literal constant, and it is too dumb not to evaluate both sides on the ?: expression. I guess because it does not process it at all but rather inserts an ?: expression with constant operands!

If a width of zero is not required, the following is a simplification that works for 1 to 32:

#define BITFIELD_WIDTHMASK(Width) (~0ul >> (32-(Width)))

It seems to me that if you know the width is zero, (perhaps to disable a feature), which is implicit if you use a literal zero constant, it would be reasonable to just use zero rather than invoke the macro.

Answer 3

What about:

#define BITFIELD_WIDTHMASK(Width) \
    ((Width) >= 32 ? ~0x0ul : (1ul << (Width % 32)) - 1)

?