std::byte overhead from integer promotion

Consider an unsigned char v that goes through a series of bit-wise operations with the result stored back to v. Under the hood, it is integer promoted once, undergoes a series of operations, and the result is truncated and stored back to v.

With std::byte v, however, for each and every operation, the operand is first integer promoted, undergoes the operation, and the (intermediate) result is truncated and stored back to some std::byte. That would be many back-and-forth promotion and truncation. This is all conceptual, but would it cause real overhead in practice?

Artificial Example

// `mask` and `lshf` are of type `unsigned`
unsigned char v = ...;
v = (v & mask) << lshf; // one promotion at `&` and one truncation at `=`

// `mask` and `lshf` are of type `std::byte` and `unsigned`
std::byte v = ...;
v = (v & mask) << lshf;

// It would be like
// byte(unsigned(byte(unsigned(v) & unsigned(mask))) << lshf)

Real-Case Example

Let's say we want to zero out the leading 3 bits of a byte.

unsigned char v = ...;
v = (v << 3 & 0xff) >> 3;

vs.

std::byte v = ...;
v = v << 3 >> 3;