Make compiler assume that all cases are handled in switch without default

Question

Let's start with some code. This is an extremely simplified version of my program.

#include <stdint.h>

volatile uint16_t dummyColorRecepient;

void updateColor(const uint8_t iteration)
{
    uint16_t colorData;
    switch(iteration)
    {
    case 0:
        colorData = 123;
        break;
    case 1:
        colorData = 234;
        break;
    case 2:
        colorData = 345;
        break;
    }
    dummyColorRecepient = colorData;
}

// dummy main function
int main()
{
    uint8_t iteration = 0;
    while (true)
    {
        updateColor(iteration);
        if (++iteration == 3)
            iteration = 0;
    }
}

The program compiles with a warning:

./test.cpp: In function ‘void updateColor(uint8_t)’:
./test.cpp:20:25: warning: ‘colorData’ may be used uninitialized in this function [-Wmaybe-uninitialized]
     dummyColorRecepient = colorData;
     ~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~

As you can see, there is an absolute certainty that the variable iteration is always 0, 1 or 2. However, the compiler doesn't know that and it assumes that switch may not initialize colorData. (Any amount of static analysis during compilation won't help here because the real program is spread over multiple files.)

Of course I could just add a default statement, like default: colorData = 0; but this adds additional 24 bytes to the program. This is a program for a microcontroller and I have very strict limits for its size.

I would like to inform the compiler that this switch is guaranteed to cover all possible values of iteration.

Answer 1

I'm going to extend the Lightness Races in Orbit's answer.

The code I'm using currently is:

#ifdef __GNUC__
__builtin_unreachable();
#else
__assume(false);
#endif

__builtin_unreachable() works in GCC and Clang but not MSVC. I used __GNUC__ to check whether it is one of the first two (or another compatible compiler) and used __assume(false) for MSVC instead.

Update for C++23

C++23 has introduced a function std::unreachable() (in the header <utility>) which does this in a portable way.

Answer 2

Well, if you are sure you won't have to handle other possible values, you can just use arithmetic. Gets rid of he branching and the load.

void updateColor(const uint8_t iteration)
{
    dummyColorRecepient = 123 + 111 * iteration;
}

Answer 3

I know there have been some good solutions, but alternatively If your values are going to be known at compile time, instead of a switch statement you can use constexpr with a static function template and a couple of enumerators; it would look something like this within a single class:

#include <iostream>

class ColorInfo {
public:
    enum ColorRecipient {
        CR_0 = 0,
        CR_1,
        CR_2
    };

    enum ColorType {
        CT_0 = 123,
        CT_1 = 234,
        CT_2 = 345
    };

    template<const uint8_t Iter>
    static constexpr uint16_t updateColor() {

        if constexpr (Iter == CR_0) {
            std::cout << "ColorData updated to: " << CT_0 << '\n';
            return CT_0;
        }

        if constexpr (Iter == CR_1) {
            std::cout << "ColorData updated to: " << CT_1 << '\n';
            return CT_1;
        }

        if constexpr (Iter == CR_2) {
            std::cout << "ColorData updated to: " << CT_2 << '\n';
            return CT_2;
        }
    }
};

int main() {
    const uint16_t colorRecipient0 = ColorInfo::updateColor<ColorInfo::CR_0>();
    const uint16_t colorRecipient1 = ColorInfo::updateColor<ColorInfo::CR_1>();
    const uint16_t colorRecipient2 = ColorInfo::updateColor<ColorInfo::CR_2>();

    std::cout << "\n--------------------------------\n";
    std::cout << "Recipient0: " << colorRecipient0 << '\n'
              << "Recipient1: " << colorRecipient1 << '\n'
              << "Recipient2: " << colorRecipient2 << '\n';

    return 0;
}

The cout statements within the if constexpr are only added for testing purposes, but this should illustrate another possible way to do this without having to use a switch statement provided your values will be known at compile time. If these values are generated at runtime I'm not completely sure if there is a way to use constexpr to achieve this type of code structure, but if there is I'd appreciate it if someone else with a little more experience could elaborate on how this could be done with constexpr using runtime values. However, this code is very readable as there are no magic numbers and the code is quite expressive.

---

-Update-

After reading more about constexpr it has come to my attention that they can be used to generate compile time constants. I also learned that they can not generate runtime constants but they can be used within a runtime function. We can take the above class structure and use it within a runtime function as such by adding this static function to the class:

static uint16_t colorUpdater(const uint8_t input) {
    // Don't forget to offset input due to std::cin with ASCII value.
    if ( (input - '0') == CR_0)
        return updateColor<CR_0>();
    if ( (input - '0') == CR_1)
        return updateColor<CR_1>();
    if ( (input - '0') == CR_2)
        return updateColor<CR_2>();

    return updateColor<CR_2>(); // Return the default type
}

However I want to change the naming conventions of the two functions. The first function I will name colorUpdater() and this new function that I just shown above I will name it updateColor() as it seems more intuitive this way. So the updated class will now look like this:

class ColorInfo {
public:
    enum ColorRecipient {
        CR_0 = 0,
        CR_1,
        CR_2
    };

    enum ColorType {
        CT_0 = 123,
        CT_1 = 234,
        CT_2 = 345
    };

    static uint16_t updateColor(uint8_t input) {
        if ( (input - '0') == CR_0 ) {
            return colorUpdater<CR_0>();
        }
        if ( (input - '0') == CR_1 ) {
            return colorUpdater<CR_1>();
        }
        if ( (input - '0') == CR_2 ) {
            return colorUpdater<CR_2>();
        }

        return colorUpdater<CR_0>(); // Return the default type
    }

    template<const uint8_t Iter>
    static constexpr uint16_t colorUpdater() {

        if constexpr (Iter == CR_0) {
            std::cout << "ColorData updated to: " << CT_0 << '\n';
            return CT_0;
        }

        if constexpr (Iter == CR_1) {
            std::cout << "ColorData updated to: " << CT_1 << '\n';
            return CT_1;
        }

        if constexpr (Iter == CR_2) {
            std::cout << "ColorData updated to: " << CT_2 << '\n';
            return CT_2;
        }
    }
};

If you want to use this with compile time constants only you can use it just as before but with the function's updated name.

#include <iostream>

int main() {
    auto output0 = ColorInfo::colorUpdater<ColorInfo::CR_0>();
    auto output1 = ColorInfo::colorUpdater<ColorInfo::CR_1>();
    auto output2 = ColorInfo::colorUpdater<ColorInfo::CR_2>();

    std::cout << "\n--------------------------------\n";
    std::cout << "Recipient0: " << output0 << '\n'
              << "Recipient1: " << output1 << '\n'
              << "Recipient2: " << output2 << '\n';
    return 0;
}

And if you want to use this mechanism with runtime values you can simply do the following:

int main() {
    uint8_t input;
    std::cout << "Please enter input value [0,2]\n";
    std::cin >> input;

    auto output = ColorInfo::updateColor(input);

    std::cout << "Output: " << output << '\n';

    return 0;
}

And this will work with runtime values.

Answer 4

You can get this to compile without warnings simply by adding a default label to one of the cases:

switch(iteration)
{
case 0:
    colorData = 123;
    break;
case 1:
    colorData = 234;
    break;
case 2: default:
    colorData = 345;
    break;
}

Alternatively:

uint16_t colorData = 345;
switch(iteration)
{
case 0:
    colorData = 123;
    break;
case 1:
    colorData = 234;
    break;
}

Try both, and use the shorter of the two.

Answer 5

As you can see, there is an absolute certainty that the variable iteration is always 0, 1 or 2.

From the perspective of the toolchain, this is not true. You can call this function from someplace else, even from another translation unit. The only place that your constraint is enforced is in main, and even there it's done in a such a way that might be difficult for the compiler to reason about.

For our purposes, though, let's take as read that you're not going to link any other translation units, and that we want to tell the toolchain about that. Well, fortunately, we can!

If you don't mind being unportable, then there's GCC's __builtin_unreachable built-in to inform it that the default case is not expected to be reached, and should be considered unreachable. My GCC is smart enough to know that this means colorData is never going to be left uninitialised unless all bets are off anyway.

#include <stdint.h>

volatile uint16_t dummyColorRecepient;

void updateColor(const uint8_t iteration)
{
    uint16_t colorData;
    switch(iteration)
    {
    case 0:
        colorData = 123;
        break;
    case 1:
        colorData = 234;
        break;
    case 2:
        colorData = 345;
        break;

    // Comment out this default case to get the warnings back!
    default:
        __builtin_unreachable();
    }
    dummyColorRecepient = colorData;
}

// dummy main function
int main()
{
    uint8_t iteration = 0;
    while (true)
    {
        updateColor(iteration);
        if (++iteration == 3)
            iteration = 0;
    }
}

(live demo)

This won't add an actual default branch, because there's no "code" inside it. In fact, when I plugged this into Godbolt using x86_64 GCC with -O2, the program was smaller with this addition than without it — logically, you've just added a major optimisation hint.

There's actually a proposal to make this a standard attribute in C++ so it could be an even more attractive solution in the future.

Answer 6

Use the "immediately invoked lambda expression" idiom and an assert:

void updateColor(const uint8_t iteration)
{
    const auto colorData = [&]() -> uint16_t
    {
        switch(iteration)
        {
            case 0: return 123;
            case 1: return 234;
        }

        assert(iteration == 2);
        return 345;
    }();

    dummyColorRecepient = colorData;
}

• The lambda expression allows you to mark colorData as const. const variables must always be initialized.

• The combination of assert + return statements allows you to avoid warnings and handle all possible cases.

• assert doesn't get compiled in release mode, preventing overhead.

---

You can also factor out the function:

uint16_t getColorData(const uint8_t iteration)
{
    switch(iteration)
    {
        case 0: return 123;
        case 1: return 234;
    }

    assert(iteration == 2);
    return 345;
}

void updateColor(const uint8_t iteration)
{
    const uint16_t colorData = getColorData(iteration);
    dummyColorRecepient = colorData;
}