serialization: Don't use a union for type punning (undefined behaviour)

practicalswift · practicalswift · commit 2aafe7c60f6e · 2018-10-14T12:11:41.000+02:00
diff --git a/src/serialize.h b/src/serialize.h
@@ -126,27 +126,31 @@ template<typename Stream> inline uint64_t ser_readdata64(Stream &s)
 }
 inline uint64_t ser_double_to_uint64(double x)
 {
-    union { double x; uint64_t y; } tmp;
-    tmp.x = x;
-    return tmp.y;
+    static_assert(sizeof(uint64_t) == sizeof(double), "Floating-point width assumption");
+    uint64_t y;
+    memcpy(&y, &x, sizeof(y));
+    return y;
 }
 inline uint32_t ser_float_to_uint32(float x)
 {
-    union { float x; uint32_t y; } tmp;
-    tmp.x = x;
-    return tmp.y;
+    static_assert(sizeof(uint32_t) == sizeof(float), "Floating-point width assumption");
+    uint32_t y;
+    memcpy(&y, &x, sizeof(y));
+    return y;
 }
 inline double ser_uint64_to_double(uint64_t y)
 {
-    union { double x; uint64_t y; } tmp;
-    tmp.y = y;
-    return tmp.x;
+    static_assert(sizeof(double) == sizeof(uint64_t), "Floating-point width assumption");
+    double x;
+    memcpy(&x, &y, sizeof(x));
+    return x;
 }
 inline float ser_uint32_to_float(uint32_t y)
 {
-    union { float x; uint32_t y; } tmp;
-    tmp.y = y;
-    return tmp.x;
+    static_assert(sizeof(float) == sizeof(uint32_t), "Floating-point width assumption");
+    float x;
+    memcpy(&x, &y, sizeof(x));
+    return x;
 }
 
 

Original file line number	Diff line number	Diff line change
`@@ -126,27 +126,31 @@ template<typename Stream> inline uint64_t ser_readdata64(Stream &s)`
`126`	`126`	`}`
`127`	`127`	`inline uint64_t ser_double_to_uint64(double x)`
`128`	`128`	`{`
`129`		`- union { double x; uint64_t y; } tmp;`
`130`		`- tmp.x = x;`
`131`		`- return tmp.y;`
	`129`	`+ static_assert(sizeof(uint64_t) == sizeof(double), "Floating-point width assumption");`
	`130`	`+ uint64_t y;`
	`131`	`+ memcpy(&y, &x, sizeof(y));`
	`132`	`+ return y;`
`132`	`133`	`}`
`133`	`134`	`inline uint32_t ser_float_to_uint32(float x)`
`134`	`135`	`{`
`135`		`- union { float x; uint32_t y; } tmp;`
`136`		`- tmp.x = x;`
`137`		`- return tmp.y;`
	`136`	`+ static_assert(sizeof(uint32_t) == sizeof(float), "Floating-point width assumption");`
	`137`	`+ uint32_t y;`
	`138`	`+ memcpy(&y, &x, sizeof(y));`
	`139`	`+ return y;`
`138`	`140`	`}`
`139`	`141`	`inline double ser_uint64_to_double(uint64_t y)`
`140`	`142`	`{`
`141`		`- union { double x; uint64_t y; } tmp;`
`142`		`- tmp.y = y;`
`143`		`- return tmp.x;`
	`143`	`+ static_assert(sizeof(double) == sizeof(uint64_t), "Floating-point width assumption");`
	`144`	`+ double x;`
	`145`	`+ memcpy(&x, &y, sizeof(x));`
	`146`	`+ return x;`
`144`	`147`	`}`
`145`	`148`	`inline float ser_uint32_to_float(uint32_t y)`
`146`	`149`	`{`
`147`		`- union { float x; uint32_t y; } tmp;`
`148`		`- tmp.y = y;`
`149`		`- return tmp.x;`
	`150`	`+ static_assert(sizeof(float) == sizeof(uint32_t), "Floating-point width assumption");`
	`151`	`+ float x;`
	`152`	`+ memcpy(&x, &y, sizeof(x));`
	`153`	`+ return x;`
`150`	`154`	`}`
`151`	`155`
`152`	`156`