Index: include/llvm/Support/EndianStream.h
===================================================================
--- include/llvm/Support/EndianStream.h
+++ include/llvm/Support/EndianStream.h
@@ -18,16 +18,46 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cmath>
 
 namespace llvm {
 namespace support {
 
 namespace endian {
 
-template <typename value_type>
-inline void write(raw_ostream &os, value_type value, endianness endian) {
-  value = byte_swap<value_type>(value, endian);
-  os.write((const char *)&value, sizeof(value_type));
+namespace detail {
+  template <typename from_type, typename to_type>
+  using enable_if_convertible =
+      typename std::enable_if<std::is_same<to_type, void>::value ||
+                              std::is_convertible<from_type, to_type>::value>;
+} // end namespace detail
+
+template <typename serialized_type = void, typename value_type>
+inline typename detail::enable_if_convertible<value_type, serialized_type>::type
+write(raw_ostream &os, value_type value, endianness endian) {
+  constexpr bool wantsCheck = !std::is_same<serialized_type, void>::value;
+  using actual_serialized_type =
+      typename std::conditional<wantsCheck, serialized_type, value_type>::type;
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wsign-compare"
+#endif
+  // Disable -Wsign-compare on this check; too much existing code converts
+  // from signed to unsigned integers without thinking about it.
+  auto serializedValue = static_cast<actual_serialized_type>(value);
+  assert(serializedValue == value && "value was truncated");
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+  serializedValue = byte_swap<actual_serialized_type>(serializedValue, endian);
+  os.write((const char *)&serializedValue, sizeof(actual_serialized_type));
+}
+
+template <>
+inline void write<void>(raw_ostream &os, float value, endianness endian) {
+  write(os, FloatToBits(value), endian);
 }
 
 template <>
@@ -36,11 +66,27 @@
 }
 
 template <>
-inline void write<double>(raw_ostream &os, double value,
-                          endianness endian) {
+inline void write<double>(raw_ostream &os, float value, endianness endian) {
+  write(os, DoubleToBits(static_cast<double>(value)), endian);
+}
+
+template <>
+inline void write<void>(raw_ostream &os, double value, endianness endian) {
+  write(os, DoubleToBits(value), endian);
+}
+
+template <>
+inline void write<double>(raw_ostream &os, double value, endianness endian) {
   write(os, DoubleToBits(value), endian);
 }
 
+template <>
+inline void write<float>(raw_ostream &os, double value, endianness endian) {
+  assert(std::isinf(value) == std::isinf(static_cast<float>(value)) &&
+         "magnitude of double value is too large to be stored as a float");
+  write(os, FloatToBits(static_cast<float>(value)), endian);
+}
+
 template <typename value_type>
 inline void write(raw_ostream &os, ArrayRef<value_type> vals,
                   endianness endian) {
@@ -53,11 +99,15 @@
   raw_ostream &OS;
   endianness Endian;
   Writer(raw_ostream &OS, endianness Endian) : OS(OS), Endian(Endian) {}
+
   template <typename value_type> void write(ArrayRef<value_type> Val) {
     endian::write(OS, Val, Endian);
   }
-  template <typename value_type> void write(value_type Val) {
-    endian::write(OS, Val, Endian);
+
+  template <typename serialized_type = void, typename value_type>
+  typename detail::enable_if_convertible<value_type, serialized_type>::type
+  write(value_type Val) {
+    endian::write<serialized_type, value_type>(OS, Val, Endian);
   }
 };
 
Index: unittests/Support/EndianStreamTest.cpp
===================================================================
--- unittests/Support/EndianStreamTest.cpp
+++ unittests/Support/EndianStreamTest.cpp
@@ -204,5 +204,52 @@
   EXPECT_EQ(static_cast<uint8_t>(Data[7]), 0x46);
 }
 
+#ifndef NDEBUG
+
+TEST(EndianStream, AssertOnTruncation_uint8) {
+  SmallString<16> Data;
+  raw_svector_ostream OS(Data);
+  endian::Writer LE(OS, little);
+  LE.write<uint8_t>(255);
+  EXPECT_DEATH({ LE.write<uint8_t>(256); }, "value was truncated");
+}
+
+TEST(EndianStream, AssertOnTruncation_int8_Positive) {
+  SmallString<16> Data;
+  raw_svector_ostream OS(Data);
+  endian::Writer LE(OS, little);
+  LE.write<int8_t>(127);
+  EXPECT_DEATH({ LE.write<int8_t>(128); }, "value was truncated");
+}
+
+TEST(EndianStream, AssertOnTruncation_int8_Negative) {
+  SmallString<16> Data;
+  raw_svector_ostream OS(Data);
+  endian::Writer LE(OS, little);
+  LE.write<int8_t>(-128);
+  EXPECT_DEATH({ LE.write<int8_t>(-129); }, "value was truncated");
+}
+
+TEST(EndianStream, AssertOnFloatOverflow_Positive) {
+  SmallString<16> Data;
+  raw_svector_ostream OS(Data);
+  endian::Writer LE(OS, little);
+  LE.write<float>(std::numeric_limits<double>::infinity());
+  LE.write<float>(std::numeric_limits<double>::min());
+  EXPECT_DEATH({ LE.write<float>(std::numeric_limits<double>::max()); },
+      "magnitude of double value is too large to be stored as a float");
+}
+
+TEST(EndianStream, AssertOnFloatOverflow_Negative) {
+  SmallString<16> Data;
+  raw_svector_ostream OS(Data);
+  endian::Writer LE(OS, little);
+  LE.write<float>(-std::numeric_limits<double>::infinity());
+  LE.write<float>(-std::numeric_limits<double>::min());
+  EXPECT_DEATH({ LE.write<float>(-std::numeric_limits<double>::max()); },
+      "magnitude of double value is too large to be stored as a float");
+}
+
+#endif // NDEBUG
 
 } // end anon namespace