Es std:: memcpy entre diferentes tipos trivialmente copiables comportamiento indefinido?

He estado usando std::memcpy para eludir el alias estricto durante mucho tiempo.

Por ejemplo, inspeccionando un float, como esto :

float f = ...;
uint32_t i;
static_assert(sizeof(f)==sizeof(i));
std::memcpy(&i, &f, sizeof(i));
// use i to extract f's sign, exponent & significand

Sin embargo, esta vez, he comprobado el estándar, no he encontrado nada que valide esto. Todo lo que encontré es esto :

Para cualquier objeto (que no sea un subobjeto potencialmente superpuesto) de tipo T, independientemente de que el objeto tenga o no un valor válido de tipo T, el subyacente bytes ([intro.memoria]) que compone el objeto se puede copiar en una matriz de char, char sin signo, o std:: byte ([cstddef.syn]).⁴⁰ Si el contenido de esa matriz se copia de nuevo en el objeto, el objeto, luego mantenga su valor original. [ Ejemplo:

#define N sizeof(T)
char buf[N];
T obj;                          // obj initialized to its original value
std::memcpy(buf, &obj, N);      // between these two calls to std​::​memcpy, obj might be modified
std::memcpy(&obj, buf, N);      // at this point, each subobject of obj of scalar type holds its original value

- ejemplo final]

Y esto :

Para cualquier tipo trivialmente copiable T, si dos punteros a T apuntan a objetos T distintos obj1 y obj2, donde ni obj1 ni obj2 es un subobjeto potencialmente superpuesto, si los bytes subyacentes ([intro.memoria]) que componen obj1 se copian en obj2,⁴¹ obj2 tendrá posteriormente el mismo valor que obj1. [ Ejemplo:

T* t1p;
T* t2p;
// provided that t2p points to an initialized object ...
std::memcpy(t1p, t2p, sizeof(T));
// at this point, every subobject of trivially copyable type in *t1p contains
// the same value as the corresponding subobject in *t2p

- ejemplo final]

Entonces, std::memcpy ing a float a/desde char[]está permitido, y std::memcpy ing entre los mismos tipos triviales también está permitido.

¿Está bien definido mi primer ejemplo (y la respuesta vinculada)? O la forma correcta de inspeccionar un float es std::memcpy en un unsigned char[]buffer, y usando shifts y or s para construir un uint32_t a partir de él?

Nota: mirar las garantías de std::memcpy puede no responder a esta pregunta. Por lo que sé, podría reemplazar std::memcpy con un simple bucle de copia de bytes, y la pregunta será la misma.