3 files changed, 71 insertions, 37 deletions

diff --git a/src/parsing.h b/src/parsing.h
index 31099571b..817355e92 100644
--- a/src/parsing.h
+++ b/src/parsing.h
@@ -19,9 +19,10 @@
 
 #include <sstream>
 
-#include "wasm.h"
-#include "shared-constants.h"
 #include "mixed_arena.h"
+#include "shared-constants.h"
+#include "support/utilities.h"
+#include "wasm.h"
 
 namespace wasm {
 
@@ -65,39 +66,33 @@ Expression* parseConst(cashew::IString s, WasmType type, MixedArena& allocator)
       assert(modifier ? positive[4] == '0' && positive[5] == 'x' : 1);
       switch (type) {
         case f32: {
-          union {
-            uint32_t pattern;
-            float f;
-          } u;
+          uint32_t pattern;
           if (modifier) {
             std::istringstream istr(modifier);
-            istr >> std::hex >> u.pattern;
-            u.pattern |= 0x7f800000;
+            istr >> std::hex >> pattern;
+            pattern |= 0x7f800000U;
           } else {
-            u.pattern = 0x7fc00000;
+            pattern = 0x7fc00000U;
           }
-          if (negative) u.pattern |= 0x80000000;
-          if (!isnan(u.f)) u.pattern |= 1;
-          assert(isnan(u.f));
-          ret->value.f32 = u.f;
+          if (negative) pattern |= 0x80000000U;
+          if (!isnan(bit_cast<float>(pattern))) pattern |= 1U;
+          ret->value.f32 = bit_cast<float>(pattern);
+          assert(isnan(ret->value.f32));
           break;
         }
         case f64: {
-          union {
-            uint64_t pattern;
-            double d;
-          } u;
+          uint64_t pattern;
           if (modifier) {
             std::istringstream istr(modifier);
-            istr >> std::hex >> u.pattern;
-            u.pattern |= 0x7ff0000000000000LL;
+            istr >> std::hex >> pattern;
+            pattern |= 0x7ff0000000000000ULL;
           } else {
-            u.pattern = 0x7ff8000000000000L;
+            pattern = 0x7ff8000000000000UL;
           }
-          if (negative) u.pattern |= 0x8000000000000000LL;
-          if (!isnan(u.d)) u.pattern |= 1;
-          assert(isnan(u.d));
-          ret->value.f64 = u.d;
+          if (negative) pattern |= 0x8000000000000000ULL;
+          if (!isnan(bit_cast<double>(pattern))) pattern |= 1ULL;
+          ret->value.f64 = bit_cast<double>(pattern);
+          assert(isnan(ret->value.f64));
           break;
         }
         default: return nullptr;
diff --git a/src/support/utilities.h b/src/support/utilities.h
new file mode 100644
index 000000000..77263a78e
--- /dev/null
+++ b/src/support/utilities.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2016 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef wasm_support_utilities_h
+#define wasm_support_utilities_h
+
+#include <cstring>
+#include <type_traits>
+
+namespace wasm {
+
+// Type punning needs to be done through this function to avoid undefined
+// behavior: unions and reinterpret_cast aren't valid approaches.
+template <class Destination, class Source>
+inline Destination bit_cast(const Source& source) {
+  static_assert(sizeof(Destination) == sizeof(Source),
+                "bit_cast needs to be between types of the same size");
+  static_assert(std::is_pod<Destination>::value, "non-POD bit_cast undefined");
+  static_assert(std::is_pod<Source>::value, "non-POD bit_cast undefined");
+  Destination destination;
+  std::memcpy(&destination, &source, sizeof(destination));
+  return destination;
+}
+
+}  // namespace wasm
+
+#endif   // wasm_support_utilities_h
diff --git a/src/wasm.h b/src/wasm.h
index 91c318034..97e0bfc12 100644
--- a/src/wasm.h
+++ b/src/wasm.h
@@ -58,6 +58,7 @@
 #include "emscripten-optimizer/simple_ast.h"
 #include "mixed_arena.h"
 #include "pretty_printing.h"
+#include "support/utilities.h"
 
 namespace wasm {
 
@@ -190,12 +191,11 @@ struct Literal {
 
   static void printFloat(std::ostream &o, float f) {
     if (isnan(f)) {
-      union {
-        float ff;
-        uint32_t ll;
-      } u;
-      u.ff = f;
-      o << "nan:0x" << std::hex << u.ll << std::dec;
+      const char *sign = std::signbit(f) ? "-" : "";
+      o << sign << "nan";
+      if (uint32_t payload = ~0xffc00000u & bit_cast<uint32_t>(f)) {
+        o << ":0x" << std::hex << payload << std::dec;
+      }
       return;
     }
     printDouble(o, f);
@@ -207,16 +207,15 @@ struct Literal {
       return;
     }
     if (isnan(d)) {
-      union {
-        double dd;
-        uint64_t ll;
-      } u;
-      u.dd = d;
-      o << "nan:0x" << std::hex << u.ll << std::dec;
+      const char *sign = std::signbit(d) ? "-" : "";
+      o << sign << "nan";
+      if (uint64_t payload = ~0xfff8000000000000ull & bit_cast<uint64_t>(d)) {
+        o << ":0x" << std::hex << payload << std::dec;
+      }
       return;
     }
     if (!std::isfinite(d)) {
-      o << (d < 0 ? "-infinity" : "infinity");
+      o << (std::signbit(d) ? "-infinity" : "infinity");
       return;
     }
     const char *text = cashew::JSPrinter::numToString(d);