How can I work around GCC optimization-miss bug 90271?

Question

GCC versions released before May 2019 (and maybe later) fail to optimize this piece of code:

// Replace the k'th byte within an int
int replace_byte(int v1 ,char v2, size_t k) 
{
   memcpy( (void*) (((char*)&v1)+k) , &v2 , sizeof(v2) );
   return v1;
}

as can be seen here (GodBolt): clang optimizes this code properly GCC and MSVC do not. This is GCC bug 90271, which will at some point be fixed. But - it won't be fixed for GCC versions that are out today, and I want to write this code today...

So: Is there a workaround which will make GCC generate the same code as clang for this function, or at least - code of comparable performance, keeping data in registers and not resorting to pointers and the stack?

Notes:

• I marked this as C, since the code snippet is in C. I assume a workaround, if one exists, can also be implemented in C.
• I'm interested in optimizing both the non-inlined function and the inlined version.
• This question is related to this one, but only regards GCC and the specific approach in the piece of code here; and is in C rather than C++.

Answer 1

This makes the non-inlined version a little longer, but the inlined version is optimized for all three compilers:

int replace_bytes(int v1 ,char v2, size_t k)
{
    return (v1 & ~(0xFF << k * 8)) | ((unsigned char)v2 << k * 8);
}

The cast of v2 to an unsigned char before the shift is necessary if char is a signed type. When that's the case, without the case v2 will be sign extended to an integer, which will cause unwanted bits to be set to 1 in the result.