Is the C compiler allowed to emit spaghetti assembly for the sake of optimization? How can I get the compiler to perform such an optimization? [duplicate]

So I have the following code:

float param1 = SOME_VALUE;  
switch (State)
{
    case A:
    {
        foo(param1);
        statement1;
        break;
    }
    case B:
    {
        bar();
        statement2;
        break;
    }
    case C:
    {      
        float param2 = OTHER_VALUE;
        switch (Expression)
        {
            case D:
            {
                baz(param2);
                break;
            }
            case E:
            {
                foo(param2);
                statement1;
                break;
            }
            case F:
            {
                bar();
                statement2;
                break;
            }
        }
        break;
    }
}

SOME_VALUE and OTHER_VALUE are not constants, just to illustrate that parameters are being set every time this code is executed.

Is the compiler allowed to relocate case A to a temporary label between the end of case D and the beginning of case E with the following code:

param2 = param1

that falls through into case E? Since case A and case E effectively do the same thing. Setting param2 to a different value has no effect outside of its usage with function foo();

The code in the compiler's intermediate representation would then look like this:

float param1 = SOME_VALUE;  
switch (State)
{
    case A:
    {
        goto NewA;
    }
    case B:
    {
        bar();
        statement2;
        break;
    }
    case C:
    {      
        float param2 = OTHER_VALUE;
        switch (Expression)
        {
            case D:
            {
                baz(param2);
                break;
            }
            NewA:
            {
                param2 = param1;
            }
            /* FALL-THROUGH */
            case E:
            {
                foo(param2);
                statement1;
                break;
            }
            case F:
            {
                bar();
                statement2;
                break;
            }
        }
        break;
    }
}

This is effectively creating spaghetti code in the emitted assembly, but the functionality is the same.

I am building with -O3 and -flto with GCC 14.3. The ability to debug this code is already forgone.

Right now, bar() and baz() are being inlined by -flto but foo() is not, presumably because the compiler is emitting two function calls in this construct. I would like foo() to be called once, then subsequently inlined.

I can force the compiler to inline foo() using __attribute__((always_inline)) but then it inlines the function at both call sites, which significantly increases code size because it exists at both call sites, i.e., compiler is not performing the optimization I described.

I am working on a hard real-time embedded system where every cycle counts, force in-lining saves about a dozen cycles. The application is high frequency control for a power converter.

EDIT: I suppose my question now has a second component: How do I get the compiler to perform this optimization without manually writing spaghetti code? Are there optimization flags I am missing? There are additional independent statements, i.e., does not affect any function call or variable, in each case block, but those statements are identical for case A and case E as indicated in the code blocks; is the optimizer not sophisticated enough to perform this redundant code factoring / optimization? Or is it because redundant code factoring and function in-lining are performed as separate passes, so the optimizer is unable to find this optimization because either one on its own is not enough to be worthwhile? If optimized in the way I described above, it would improve execution speed without increasing code size.

Also, in response to @chqrlie's answer. foo() is used in the same way for both case A and case E. foo() is a fairly large function at 4KB. I cannot combine case A and case E because the usage of foo() in case E requires the assignment of param2.

An alternative would be to shove all of case C into case A and have a separate if block handle case C and its branch cases D, and F, with E falling through to case A's behavior, but that would arguably look worse.

Side note: case B and case F are also identical in behavior, but I am not as concerned with optimizing that as it is not part of the critical path. The compiler is currently not factoring and optimizing that either.

Finally, one option is simply not spend time fretting over every last cycle. I've already optimized the critical path down to <1200 cycles, so another 12 cycles is only a 1% improvement. My original concern was building enough cycle margin so that the inevitable scope creep doesn't slow the critical path down to a point where it no longer hits computational targets; this has happened a few times on previous projects I've worked on.