%8 = %7.sign:1;
  %9 = %7.exp:8;

I am not 100% sure if this is correct or not.
It is also the reason why converting to it to C/C++ does not fully work.

Both the C and C++ front-ends access the bitfields using a smaller precision type first and then casts.
I wonder if that is the issue here.

Note you can dump the gimple with the extra -gimple option which will output something which could be more useful to use as a gimple fe testcase. So -fdump-tree-gimple-gimple and you might need some extra changes but with that you can plug it back into the C front-end with the extra -fgimple option.

I do see

  # DEBUG BEGIN_STMT
  _1 = $7.sign;
  $8 = (unsigned int) _1;
  # DEBUG BEGIN_STMT
  _2 = $7.exp;
  $9 = (unsigned int) _2;
  # DEBUG BEGIN_STMT
  _3 = $7.mant;
  $10 = (unsigned int) _3;

from the C frontend. I am not sure whether libgccjit should have done the same thing.

It maybe the case that the way GCCJIT frontend generates the code will allow backend to think this as an "access to the inactive union field", which is undefined. Although I am uncertain about the semantic difference between GCCJIT and C.

P.S. The code on godbolt was in C++, which indeed regards this as an undefined behavior. One should switch to a C compiler instead. However, I believe there is no difference for clang/gcc in this particular case.

Pointed out by @Lancern

GNU C and C++ has this as defined code though (it is undefined in standard C/C++ due to the activeness of an union field). https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Optimize-Options.html#index-fstrict-aliasing

The GIMPLE smeantics are the same with respect to an union access is the same as the GNU C too.

Even after I making Float the same size as others by padding long to its tail and utilizing bitcast to to convert union to target struct, the problem still exists.

Even a simple program like:

struct Int;

struct Int
{
  int A:17;
  int B:5;
  int C:10;
};

static void
from_int_to_bitfield (int %arg0, int %arg1)
{
  int %0;
  int %1;
  struct Int %2;
  int %3;
  bool %4;

bb0:
  %0 = %arg0;
  %1 = %arg1;
  %2 = bitcast(%0, struct Int);
  %3 = %2.A:17;
  %4 = %3 == %1;
  if (%4) goto bb1; else goto bb2;

bb1:
  return;

bb2:
  (void)__builtin_trap ();
  goto bb2;
}

extern int
main ()
{
  int %0;
  int %1;
  int %2;

bb0:
  %0 = (int)-559038737;
  %1 = (int)-16657;
  (void)from_int_to_bitfield (%0, %1);
  %2 = (int)0;
  return %2;
}

will be folded into ud2, which exits normally when the function is not internal