Support: Simplify endian stream interface. NFCI.

[pcc]

Summary

Provide some free functions to reduce verbosity of endian-writing
a single value, and replace the endianness template parameter with
a field.

Part of PR37466.

[pcc]

• Remove unused function

[ruiu]

LGTM

If I were to design this from scratch, I'd perhaps define two classes, LEWriter and BEWriter, instead of giving the endianness as an argument. But that's an off-topic.

[pcc]

In D47032#1104861, @ruiu wrote:

LGTM

If I were to design this from scratch, I'd perhaps define two classes, LEWriter and BEWriter, instead of giving the endianness as an argument. But that's an off-topic.

Maybe, but it will need to be an argument in a few other places, such as ELFObjectWriter (see D47040). Though maybe we could somehow template it on ELFT as we do in lld... but that's another separate discussion.

[zturner]

Note that the endianness values can be passed in to the llvm functions at
runtime, there are non template versions of the write functions that accept
endianness as arguments (that may be exactly what you used, btw, I didn’t
read the patch in detail).

It’s a shame this object hierarchy was developed separately from the
BinaryStream / StreamReader / StreamWriter interfaces, because it seems
like there’s some overlap and it would serve this use case nicely

clang/lib/Frontend/CacheTokens.cpp

public:
   StringRef getString() const {
     return Kind == IsFE ? FE->getName() : StringRef(PathPtr, PathSize);
   }
 
   unsigned getKind() const { return (unsigned) Kind; }
 
   void EmitData(raw_ostream& Out) {
     using namespace llvm::support;
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     switch (Kind) {
     case IsFE: {
       // Emit stat information.
       llvm::sys::fs::UniqueID UID = FE->getUniqueID();
       LE.write<uint64_t>(UID.getFile());
       LE.write<uint64_t>(UID.getDevice());
       LE.write<uint64_t>(FE->getModificationTime());
       LE.write<uint64_t>(FE->getSize());
public:
   static hash_value_type ComputeHash(PTHEntryKeyVariant V) {
     return llvm::djbHash(V.getString());
   }
 
   static std::pair<unsigned,unsigned>
   EmitKeyDataLength(raw_ostream& Out, PTHEntryKeyVariant V,
                     const PTHEntry& E) {
     using namespace llvm::support;
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
 
     unsigned n = V.getString().size() + 1 + 1;
     LE.write<uint16_t>(n);
 
     unsigned m = V.getRepresentationLength() + (V.isFile() ? 4 + 4 : 0);
     LE.write<uint8_t>(m);
 
     return std::make_pair(n, m);
   }
 
   static void EmitKey(raw_ostream& Out, PTHEntryKeyVariant V, unsigned n){
     using namespace llvm::support;
     // Emit the entry kind.
-    endian::Writer<little>(Out).write<uint8_t>((unsigned)V.getKind());
+    Out << char(V.getKind());
     // Emit the string.
     Out.write(V.getString().data(), n - 1);
   }
 
   static void EmitData(raw_ostream& Out, PTHEntryKeyVariant V,
                        const PTHEntry& E, unsigned) {
     using namespace llvm::support;
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
 
     // For file entries emit the offsets into the PTH file for token data
     // and the preprocessor blocks table.
     if (V.isFile()) {
       LE.write<uint32_t>(E.getTokenOffset());
       LE.write<uint32_t>(E.getPPCondTableOffset());
     }
 
class PTHWriter {
 
   //// Get the persistent id for the given IdentifierInfo*.
   uint32_t ResolveID(const IdentifierInfo* II);
 
   /// Emit a token to the PTH file.
   void EmitToken(const Token& T);
 
   void Emit8(uint32_t V) {
-    using namespace llvm::support;
-    endian::Writer<little>(Out).write<uint8_t>(V);
+    Out << char(V);
   }
 
   void Emit16(uint32_t V) {
     using namespace llvm::support;
-    endian::Writer<little>(Out).write<uint16_t>(V);
+    endian::write<uint16_t>(Out, V, little);
   }
 
   void Emit32(uint32_t V) {
     using namespace llvm::support;
-    endian::Writer<little>(Out).write<uint32_t>(V);
+    endian::write<uint32_t>(Out, V, little);
   }
 
   void EmitBuf(const char *Ptr, unsigned NumBytes) {
     Out.write(Ptr, NumBytes);
   }
 
   void EmitString(StringRef V) {
     using namespace llvm::support;
-    endian::Writer<little>(Out).write<uint16_t>(V.size());
+    endian::write<uint16_t>(Out, V.size(), little);
     EmitBuf(V.data(), V.size());
   }
 
   /// EmitIdentifierTable - Emits two tables to the PTH file.  The first is
   ///  a hashtable mapping from identifier strings to persistent IDs.
   ///  The second is a straight table mapping from persistent IDs to string data
   ///  (the keys of the first table).
   std::pair<Offset, Offset> EmitIdentifierTable();
void PTHWriter::EmitToken(const Token& T) {
   // can reconstruct its SourceLocation.
   Emit32(PP.getSourceManager().getFileOffset(T.getLocation()));
 }
 
 PTHEntry PTHWriter::LexTokens(Lexer& L) {
   // Pad 0's so that we emit tokens to a 4-byte alignment.
   // This speed up reading them back in.
   using namespace llvm::support;
-  endian::Writer<little> LE(Out);
+  endian::Writer LE(Out, little);
   uint32_t TokenOff = Out.tell();
   for (uint64_t N = llvm::OffsetToAlignment(TokenOff, 4); N; --N, ++TokenOff)
     LE.write<uint8_t>(0);
 
   // Keep track of matching '#if' ... '#endif'.
   typedef std::vector<std::pair<Offset, unsigned> > PPCondTable;
   PPCondTable PPCond;
   std::vector<unsigned> PPStartCond;
public:
   static hash_value_type ComputeHash(PTHIdKey* key) {
     return llvm::djbHash(key->II->getName());
   }
 
   static std::pair<unsigned,unsigned>
   EmitKeyDataLength(raw_ostream& Out, const PTHIdKey* key, uint32_t) {
     using namespace llvm::support;
     unsigned n = key->II->getLength() + 1;
-    endian::Writer<little>(Out).write<uint16_t>(n);
+    endian::write<uint16_t>(Out, n, little);
     return std::make_pair(n, sizeof(uint32_t));
   }
 
   static void EmitKey(raw_ostream& Out, PTHIdKey* key, unsigned n) {
     // Record the location of the key data.  This is used when generating
     // the mapping from persistent IDs to strings.
     key->FileOffset = Out.tell();
     Out.write(key->II->getNameStart(), n);
   }
 
   static void EmitData(raw_ostream& Out, PTHIdKey*, uint32_t pID,
                        unsigned) {
     using namespace llvm::support;
-    endian::Writer<little>(Out).write<uint32_t>(pID);
+    endian::write<uint32_t>(Out, pID, little);
   }
 };
 } // end anonymous namespace
 
 /// EmitIdentifierTable - Emits two tables to the PTH file.  The first is
 ///  a hashtable mapping from identifier strings to persistent IDs.  The second
 ///  is a straight table mapping from persistent IDs to string data (the
 ///  keys of the first table).

clang/lib/Serialization/ASTWriter.cpp

hash_value_type ComputeHash(key_type_ref key) {
       // change the form of the name. However, complete path is still the key.
       return llvm::hash_combine(key.Size, key.ModTime);
     }
 
     std::pair<unsigned, unsigned>
     EmitKeyDataLength(raw_ostream& Out, key_type_ref key, data_type_ref Data) {
       using namespace llvm::support;
 
-      endian::Writer<little> LE(Out);
+      endian::Writer LE(Out, little);
       unsigned KeyLen = key.Filename.size() + 1 + 8 + 8;
       LE.write<uint16_t>(KeyLen);
       unsigned DataLen = 1 + 2 + 4 + 4;
       for (auto ModInfo : Data.KnownHeaders)
         if (Writer.getLocalOrImportedSubmoduleID(ModInfo.getModule()))
           DataLen += 4;
       if (Data.Unresolved.getPointer())
         DataLen += 4;
       LE.write<uint8_t>(DataLen);
       return std::make_pair(KeyLen, DataLen);
     }
 
     void EmitKey(raw_ostream& Out, key_type_ref key, unsigned KeyLen) {
       using namespace llvm::support;
 
-      endian::Writer<little> LE(Out);
+      endian::Writer LE(Out, little);
       LE.write<uint64_t>(key.Size);
       KeyLen -= 8;
       LE.write<uint64_t>(key.ModTime);
       KeyLen -= 8;
       Out.write(key.Filename.data(), KeyLen);
     }
 
     void EmitData(raw_ostream &Out, key_type_ref key,
                   data_type_ref Data, unsigned DataLen) {
       using namespace llvm::support;
 
-      endian::Writer<little> LE(Out);
+      endian::Writer LE(Out, little);
       uint64_t Start = Out.tell(); (void)Start;
 
       unsigned char Flags = (Data.HFI.isImport << 5)
                           | (Data.HFI.isPragmaOnce << 4)
                           | (Data.HFI.DirInfo << 1)
                           | Data.HFI.IndexHeaderMapHeader;
       LE.write<uint8_t>(Flags);
       LE.write<uint16_t>(Data.HFI.NumIncludes);
void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) {
   // Create the on-disk hash table in a buffer.
   SmallString<4096> TableData;
   uint32_t BucketOffset;
   {
     using namespace llvm::support;
 
     llvm::raw_svector_ostream Out(TableData);
     // Make sure that no bucket is at offset 0
-    endian::Writer<little>(Out).write<uint32_t>(0);
+    endian::write<uint32_t>(Out, 0, little);
     BucketOffset = Generator.Emit(Out, GeneratorTrait);
   }
 
   // Create a blob abbreviation
   using namespace llvm;
 
   auto Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(HEADER_SEARCH_TABLE));
static hash_value_type ComputeHash(Selector Sel) {
     return serialization::ComputeHash(Sel);
   }
 
   std::pair<unsigned, unsigned>
     EmitKeyDataLength(raw_ostream& Out, Selector Sel,
                       data_type_ref Methods) {
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4);
     LE.write<uint16_t>(KeyLen);
     unsigned DataLen = 4 + 2 + 2; // 2 bytes for each of the method counts
     for (const ObjCMethodList *Method = &Methods.Instance; Method;
          Method = Method->getNext())
       if (Method->getMethod())
         DataLen += 4;
     for (const ObjCMethodList *Method = &Methods.Factory; Method;
          Method = Method->getNext())
       if (Method->getMethod())
         DataLen += 4;
     LE.write<uint16_t>(DataLen);
     return std::make_pair(KeyLen, DataLen);
   }
 
   void EmitKey(raw_ostream& Out, Selector Sel, unsigned) {
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     uint64_t Start = Out.tell();
     assert((Start >> 32) == 0 && "Selector key offset too large");
     Writer.SetSelectorOffset(Sel, Start);
     unsigned N = Sel.getNumArgs();
     LE.write<uint16_t>(N);
     if (N == 0)
       N = 1;
     for (unsigned I = 0; I != N; ++I)
       LE.write<uint32_t>(
           Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I)));
   }
 
   void EmitData(raw_ostream& Out, key_type_ref,
                 data_type_ref Methods, unsigned DataLen) {
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     uint64_t Start = Out.tell(); (void)Start;
     LE.write<uint32_t>(Methods.ID);
     unsigned NumInstanceMethods = 0;
     for (const ObjCMethodList *Method = &Methods.Instance; Method;
          Method = Method->getNext())
       if (Method->getMethod())
         ++NumInstanceMethods;
 
// Create and write out the blob that contains selectors and the method pool.
     SmallString<4096> MethodPool;
     uint32_t BucketOffset;
     {
       using namespace llvm::support;
 
       ASTMethodPoolTrait Trait(*this);
       llvm::raw_svector_ostream Out(MethodPool);
       // Make sure that no bucket is at offset 0
-      endian::Writer<little>(Out).write<uint32_t>(0);
+      endian::write<uint32_t>(Out, 0, little);
       BucketOffset = Generator.Emit(Out, Trait);
     }
 
     // Create a blob abbreviation
     auto Abbrev = std::make_shared<BitCodeAbbrev>();
     Abbrev->Add(BitCodeAbbrevOp(METHOD_POOL));
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
if (isInterestingIdentifier(II, MacroOffset)) {
                                        DEnd = IdResolver.end();
              D != DEnd; ++D)
           DataLen += 4;
       }
     }
 
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
 
     assert((uint16_t)DataLen == DataLen && (uint16_t)KeyLen == KeyLen);
     LE.write<uint16_t>(DataLen);
     // We emit the key length after the data length so that every
     // string is preceded by a 16-bit length. This matches the PTH
     // format for storing identifiers.
     LE.write<uint16_t>(KeyLen);
     return std::make_pair(KeyLen, DataLen);
void EmitKey(raw_ostream& Out, const IdentifierInfo* II,
 
     Out.write(II->getNameStart(), KeyLen);
   }
 
   void EmitData(raw_ostream& Out, IdentifierInfo* II,
                 IdentID ID, unsigned) {
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
 
     auto MacroOffset = Writer.getMacroDirectivesOffset(II);
     if (!isInterestingIdentifier(II, MacroOffset)) {
       LE.write<uint32_t>(ID << 1);
       return;
     }
 
     LE.write<uint32_t>((ID << 1) | 0x01);
// strings.
     // Create the on-disk hash table in a buffer.
     SmallString<4096> IdentifierTable;
     uint32_t BucketOffset;
     {
       using namespace llvm::support;
 
       llvm::raw_svector_ostream Out(IdentifierTable);
       // Make sure that no bucket is at offset 0
-      endian::Writer<little>(Out).write<uint32_t>(0);
+      endian::write<uint32_t>(Out, 0, little);
       BucketOffset = Generator.Emit(Out, Trait);
     }
 
     // Create a blob abbreviation
     auto Abbrev = std::make_shared<BitCodeAbbrev>();
     Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_TABLE));
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
public:
   }
 
   void EmitFileRef(raw_ostream &Out, ModuleFile *F) const {
     assert(Writer.hasChain() &&
            "have reference to loaded module file but no chain?");
 
     using namespace llvm::support;
 
-    endian::Writer<little>(Out)
-        .write<uint32_t>(Writer.getChain()->getModuleFileID(F));
+    endian::write<uint32_t>(Out, Writer.getChain()->getModuleFileID(F), little);
   }
 
   std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
                                                   DeclarationNameKey Name,
                                                   data_type_ref Lookup) {
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     unsigned KeyLen = 1;
     switch (Name.getKind()) {
     case DeclarationName::Identifier:
     case DeclarationName::ObjCZeroArgSelector:
     case DeclarationName::ObjCOneArgSelector:
     case DeclarationName::ObjCMultiArgSelector:
     case DeclarationName::CXXLiteralOperatorName:
     case DeclarationName::CXXDeductionGuideName:
std::pair<unsigned, unsigned> EmitKeyDataLength(raw_ostream &Out,
     LE.write<uint16_t>(DataLen);
 
     return std::make_pair(KeyLen, DataLen);
   }
 
   void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) {
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     LE.write<uint8_t>(Name.getKind());
     switch (Name.getKind()) {
     case DeclarationName::Identifier:
     case DeclarationName::CXXLiteralOperatorName:
     case DeclarationName::CXXDeductionGuideName:
       LE.write<uint32_t>(Writer.getIdentifierRef(Name.getIdentifier()));
       return;
     case DeclarationName::ObjCZeroArgSelector:
void EmitKey(raw_ostream &Out, DeclarationNameKey Name, unsigned) {
 
     llvm_unreachable("Invalid name kind?");
   }
 
   void EmitData(raw_ostream &Out, key_type_ref, data_type Lookup,
                 unsigned DataLen) {
     using namespace llvm::support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     uint64_t Start = Out.tell(); (void)Start;
     for (unsigned I = Lookup.first, N = Lookup.second; I != N; ++I)
       LE.write<uint32_t>(DeclIDs[I]);
     assert(Out.tell() - Start == DataLen && "Data length is wrong");
   }
 };
 
 } // namespace
if (Chain) {
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
     unsigned ModuleOffsetMapAbbrev = Stream.EmitAbbrev(std::move(Abbrev));
     SmallString<2048> Buffer;
     {
       llvm::raw_svector_ostream Out(Buffer);
       for (ModuleFile &M : Chain->ModuleMgr) {
         using namespace llvm::support;
 
-        endian::Writer<little> LE(Out);
+        endian::Writer LE(Out, little);
         LE.write<uint8_t>(static_cast<uint8_t>(M.Kind));
         StringRef Name =
           M.Kind == MK_PrebuiltModule || M.Kind == MK_ExplicitModule
           ? M.ModuleName
           : M.FileName;
         LE.write<uint16_t>(Name.size());
         Out.write(Name.data(), Name.size());
 

clang/lib/Serialization/GlobalModuleIndex.cpp

public:
 
   static hash_value_type ComputeHash(key_type_ref Key) {
     return llvm::djbHash(Key);
   }
 
   std::pair<unsigned,unsigned>
   EmitKeyDataLength(raw_ostream& Out, key_type_ref Key, data_type_ref Data) {
     using namespace llvm::support;
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     unsigned KeyLen = Key.size();
     unsigned DataLen = Data.size() * 4;
     LE.write<uint16_t>(KeyLen);
     LE.write<uint16_t>(DataLen);
     return std::make_pair(KeyLen, DataLen);
   }
 
   void EmitKey(raw_ostream& Out, key_type_ref Key, unsigned KeyLen) {
     Out.write(Key.data(), KeyLen);
   }
 
   void EmitData(raw_ostream& Out, key_type_ref Key, data_type_ref Data,
                 unsigned DataLen) {
     using namespace llvm::support;
     for (unsigned I = 0, N = Data.size(); I != N; ++I)
-      endian::Writer<little>(Out).write<uint32_t>(Data[I]);
+      endian::write<uint32_t>(Out, Data[I], little);
   }
 };
 
 }
 
 bool GlobalModuleIndexBuilder::writeIndex(llvm::BitstreamWriter &Stream) {
   for (auto MapEntry : ImportedModuleFiles) {
     auto *File = MapEntry.first;
// Write the identifier -> module file mapping.
 
     // Create the on-disk hash table in a buffer.
     SmallString<4096> IdentifierTable;
     uint32_t BucketOffset;
     {
       using namespace llvm::support;
       llvm::raw_svector_ostream Out(IdentifierTable);
       // Make sure that no bucket is at offset 0
-      endian::Writer<little>(Out).write<uint32_t>(0);
+      endian::write<uint32_t>(Out, 0, little);
       BucketOffset = Generator.Emit(Out, Trait);
     }
 
     // Create a blob abbreviation
     auto Abbrev = std::make_shared<BitCodeAbbrev>();
     Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_INDEX));
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32));
     Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));

clang/lib/Serialization/MultiOnDiskHashTable.h

public:
   void emit(llvm::SmallVectorImpl<char> &Out, WriterInfo &Info,
             const BaseTable *Base) {
     using namespace llvm::support;
 
     llvm::raw_svector_ostream OutStream(Out);
 
     // Write our header information.
     {
-      endian::Writer<little> Writer(OutStream);
+      endian::Writer Writer(OutStream, little);
 
       // Reserve four bytes for the bucket offset.
       Writer.write<uint32_t>(0);
 
       if (auto *Merged = Base ? Base->getMergedTable() : nullptr) {
         // Write list of overridden files.
         Writer.write<uint32_t>(Merged->Files.size());
         for (const auto &F : Merged->Files)

lld/wasm/WriterUtils.cpp

 
 void wasm::writeU8(raw_ostream &OS, uint8_t Byte, const Twine &Msg) {
   debugWrite(OS.tell(), Msg + " [0x" + utohexstr(Byte) + "]");
   OS << Byte;
 }
 
 void wasm::writeU32(raw_ostream &OS, uint32_t Number, const Twine &Msg) {
   debugWrite(OS.tell(), Msg + "[0x" + utohexstr(Number) + "]");
-  support::endian::Writer<support::little>(OS).write(Number);
+  support::endian::write(OS, Number, support::little);
 }
 
 void wasm::writeValueType(raw_ostream &OS, uint8_t Type, const Twine &Msg) {
   writeU8(OS, Type, Msg + "[type: " + valueTypeToString(Type) + "]");
 }
 
 void wasm::writeSig(raw_ostream &OS, const WasmSignature &Sig) {
   writeU8(OS, WASM_TYPE_FUNC, "signature type");

llvm/include/llvm/MC/MCObjectWriter.h

public:
 
   /// @}
   /// \name Binary Output
   /// @{
 
   void write8(uint8_t Value) { *OS << char(Value); }
 
   void writeLE16(uint16_t Value) {
-    support::endian::Writer<support::little>(*OS).write(Value);
+    support::endian::write(*OS, Value, support::little);
   }
 
   void writeLE32(uint32_t Value) {
-    support::endian::Writer<support::little>(*OS).write(Value);
+    support::endian::write(*OS, Value, support::little);
   }
 
   void writeLE64(uint64_t Value) {
-    support::endian::Writer<support::little>(*OS).write(Value);
+    support::endian::write(*OS, Value, support::little);
   }
 
   void writeBE16(uint16_t Value) {
-    support::endian::Writer<support::big>(*OS).write(Value);
+    support::endian::write(*OS, Value, support::big);
   }
 
   void writeBE32(uint32_t Value) {
-    support::endian::Writer<support::big>(*OS).write(Value);
+    support::endian::write(*OS, Value, support::big);
   }
 
   void writeBE64(uint64_t Value) {
-    support::endian::Writer<support::big>(*OS).write(Value);
+    support::endian::write(*OS, Value, support::big);
   }
 
   void write16(uint16_t Value) {
     if (IsLittleEndian)
       writeLE16(Value);
     else
       writeBE16(Value);
   }

llvm/include/llvm/Support/EndianStream.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace support {
 
 namespace endian {
-/// Adapter to write values to a stream in a particular byte order.
-template <endianness endian> struct Writer {
-  raw_ostream &OS;
-  Writer(raw_ostream &OS) : OS(OS) {}
-  template <typename value_type> void write(ArrayRef<value_type> Vals) {
-    for (value_type V : Vals)
-      write(V);
-  }
-  template <typename value_type> void write(value_type Val) {
-    Val = byte_swap<value_type, endian>(Val);
-    OS.write((const char *)&Val, sizeof(value_type));
-  }
-};
+
+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));
 
 template <>
-template <>
-inline void Writer<little>::write<float>(float Val) {
-  write(FloatToBits(Val));
+inline void write<float>(raw_ostream &os, float value, endianness endian) {
+  write(os, FloatToBits(value), endian);
 }
 
 template <>
-template <>
-inline void Writer<little>::write<double>(double Val) {
-  write(DoubleToBits(Val));
+inline void write<double>(raw_ostream &os, double value,
+                          endianness endian) {
+  write(os, DoubleToBits(value), endian);
 }
 
-template <>
-template <>
-inline void Writer<big>::write<float>(float Val) {
-  write(FloatToBits(Val));
+template <typename value_type>
+inline void write(raw_ostream &os, ArrayRef<value_type> vals,
+                  endianness endian) {
+  for (value_type v : vals)
+    write(os, v, endian);
 }
 
-template <>
-template <>
-inline void Writer<big>::write<double>(double Val) {
-  write(DoubleToBits(Val));
+/// Adapter to write values to a stream in a particular byte order.
+struct Writer {
+  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);
   }
+};
 
 } // end namespace endian
 
 } // end namespace support
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/OnDiskHashTable.h

offset_type Emit(raw_ostream &Out) {
     return Emit(Out, InfoObj);
   }
 
   /// Emit the table to Out, which must not be at offset 0.
   ///
   /// Uses the provided Info instead of a stack allocated one.
   offset_type Emit(raw_ostream &Out, Info &InfoObj) {
     using namespace llvm::support;
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
 
     // Now we're done adding entries, resize the bucket list if it's
     // significantly too large. (This only happens if the number of
     // entries is small and we're within our initial allocation of
     // 64 buckets.) We aim for an occupancy ratio in [3/8, 3/4).
     //
     // As a special case, if there are two or fewer entries, just
     // form a single bucket. A linear scan is fine in that case, and

llvm/lib/MC/ELFObjectWriter.cpp

public:
   void WriteWord(uint64_t W) {
     if (is64Bit())
       write64(W);
     else
       write32(W);
   }
 
   template <typename T> void write(T Val) {
-    if (IsLittleEndian)
-      support::endian::Writer<support::little>(getStream()).write(Val);
-    else
-      support::endian::Writer<support::big>(getStream()).write(Val);
+    support::endian::write(getStream(), Val,
+                           IsLittleEndian ? support::little : support::big);
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void writeSymbol(SymbolTableWriter &Writer, uint32_t StringIndex,
                    ELFSymbolData &MSD, const MCAsmLayout &Layout);
 
   // Start and end offset of each section

llvm/lib/MC/MCCodeView.cpp

for (size_t I = 0, E = Frag.getRanges().size(); I != E;) {
     for (; J != E; ++J) {
       unsigned GapAndRangeSize = GapAndRangeSizes[J].first + GapAndRangeSizes[J].second;
       if (RangeSize + GapAndRangeSize > MaxDefRange)
         break;
       RangeSize += GapAndRangeSize;
     }
     unsigned NumGaps = J - I - 1;
 
-    support::endian::Writer<support::little> LEWriter(OS);
+    support::endian::Writer LEWriter(OS, support::little);
 
     unsigned Bias = 0;
     // We must split the range into chunks of MaxDefRange, this is a fundamental
     // limitation of the file format.
     do {
       uint16_t Chunk = std::min((uint32_t)MaxDefRange, RangeSize);
 
       const MCSymbolRefExpr *SRE = MCSymbolRefExpr::create(RangeBegin, Ctx);

llvm/lib/MC/MCDwarf.cpp

 }
 
 void MCDwarfFrameEmitter::EncodeAdvanceLoc(MCContext &Context,
                                            uint64_t AddrDelta,
                                            raw_ostream &OS) {
   // Scale the address delta by the minimum instruction length.
   AddrDelta = ScaleAddrDelta(Context, AddrDelta);
 
+  support::endianness E =
+      Context.getAsmInfo()->isLittleEndian() ? support::little : support::big;
   if (AddrDelta == 0) {
   } else if (isUIntN(6, AddrDelta)) {
     uint8_t Opcode = dwarf::DW_CFA_advance_loc | AddrDelta;
     OS << Opcode;
   } else if (isUInt<8>(AddrDelta)) {
     OS << uint8_t(dwarf::DW_CFA_advance_loc1);
     OS << uint8_t(AddrDelta);
   } else if (isUInt<16>(AddrDelta)) {
     OS << uint8_t(dwarf::DW_CFA_advance_loc2);
-    if (Context.getAsmInfo()->isLittleEndian())
-      support::endian::Writer<support::little>(OS).write<uint16_t>(AddrDelta);
-    else
-      support::endian::Writer<support::big>(OS).write<uint16_t>(AddrDelta);
+    support::endian::write<uint16_t>(OS, AddrDelta, E);
   } else {
     assert(isUInt<32>(AddrDelta));
     OS << uint8_t(dwarf::DW_CFA_advance_loc4);
-    if (Context.getAsmInfo()->isLittleEndian())
-      support::endian::Writer<support::little>(OS).write<uint32_t>(AddrDelta);
-    else
-      support::endian::Writer<support::big>(OS).write<uint32_t>(AddrDelta);
+    support::endian::write<uint32_t>(OS, AddrDelta, E);
   }
 }

llvm/lib/Object/ArchiveWriter.cpp

static bool isBSDLike(object::Archive::Kind Kind) {
   case object::Archive::K_COFF:
     break;
   }
   llvm_unreachable("not supported for writting");
 }
 
 template <class T>
 static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) {
-  if (isBSDLike(Kind))
-    support::endian::Writer<support::little>(Out).write(Val);
-  else
-    support::endian::Writer<support::big>(Out).write(Val);
+  support::endian::write(Out, Val,
+                         isBSDLike(Kind) ? support::little : support::big);
 }
 
 static void printRestOfMemberHeader(
     raw_ostream &Out, const sys::TimePoint<std::chrono::seconds> &ModTime,
     unsigned UID, unsigned GID, unsigned Perms, unsigned Size) {
   printWithSpacePadding(Out, sys::toTimeT(ModTime), 12);
 
   // The format has only 6 chars for uid and gid. Truncate if the provided

llvm/lib/ProfileData/InstrProfWriter.cpp

 };
 
 namespace llvm {
 
 // A wrapper class to abstract writer stream with support of bytes
 // back patching.
 class ProfOStream {
 public:
-  ProfOStream(raw_fd_ostream &FD) : IsFDOStream(true), OS(FD), LE(FD) {}
+  ProfOStream(raw_fd_ostream &FD)
+      : IsFDOStream(true), OS(FD), LE(FD, support::little) {}
   ProfOStream(raw_string_ostream &STR)
-      : IsFDOStream(false), OS(STR), LE(STR) {}
+      : IsFDOStream(false), OS(STR), LE(STR, support::little) {}
 
   uint64_t tell() { return OS.tell(); }
   void write(uint64_t V) { LE.write<uint64_t>(V); }
 
   // \c patch can only be called when all data is written and flushed.
   // For raw_string_ostream, the patch is done on the target string
   // directly and it won't be reflected in the stream's internal buffer.
   void patch(PatchItem *P, int NItems) {
if (IsFDOStream) {
       }
     }
   }
 
   // If \c OS is an instance of \c raw_fd_ostream, this field will be
   // true. Otherwise, \c OS will be an raw_string_ostream.
   bool IsFDOStream;
   raw_ostream &OS;
-  support::endian::Writer<support::little> LE;
+  support::endian::Writer LE;
 };
 
 class InstrProfRecordWriterTrait {
 public:
   using key_type = StringRef;
   using key_type_ref = StringRef;
 
   using data_type = const InstrProfWriter::ProfilingData *const;
public:
   static hash_value_type ComputeHash(key_type_ref K) {
     return IndexedInstrProf::ComputeHash(K);
   }
 
   static std::pair<offset_type, offset_type>
   EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V) {
     using namespace support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
 
     offset_type N = K.size();
     LE.write<offset_type>(N);
 
     offset_type M = 0;
     for (const auto &ProfileData : *V) {
       const InstrProfRecord &ProfRecord = ProfileData.second;
       M += sizeof(uint64_t); // The function hash
public:
 
   void EmitKey(raw_ostream &Out, key_type_ref K, offset_type N) {
     Out.write(K.data(), N);
   }
 
   void EmitData(raw_ostream &Out, key_type_ref, data_type_ref V, offset_type) {
     using namespace support;
 
-    endian::Writer<little> LE(Out);
+    endian::Writer LE(Out, little);
     for (const auto &ProfileData : *V) {
       const InstrProfRecord &ProfRecord = ProfileData.second;
       SummaryBuilder->addRecord(ProfRecord);
 
       LE.write<uint64_t>(ProfileData.first); // Function hash
       LE.write<uint64_t>(ProfRecord.Counts.size());
       for (uint64_t I : ProfRecord.Counts)
         LE.write<uint64_t>(I);

llvm/lib/Target/AArch64/MCTargetDesc/AArch64MCCodeEmitter.cpp

if (MI.getOpcode() == AArch64::TLSDESCCALL) {
     Fixups.push_back(MCFixup::create(0, MI.getOperand(0).getExpr(), Fixup));
     return;
   } else if (MI.getOpcode() == AArch64::CompilerBarrier) {
     // This just prevents the compiler from reordering accesses, no actual code.
     return;
   }
 
   uint64_t Binary = getBinaryCodeForInstr(MI, Fixups, STI);
-  support::endian::Writer<support::little>(OS).write<uint32_t>(Binary);
+  support::endian::write<uint32_t>(OS, Binary, support::little);
   ++MCNumEmitted; // Keep track of the # of mi's emitted.
 }
 
 unsigned
 AArch64MCCodeEmitter::fixMulHigh(const MCInst &MI,
                                  unsigned EncodedValue,
                                  const MCSubtargetInfo &STI) const {
   // The Ra field of SMULH and UMULH is unused: it should be assembled as 31

llvm/lib/Target/AMDGPU/MCTargetDesc/R600MCCodeEmitter.cpp

if ((STI.getFeatureBits()[AMDGPU::FeatureR600ALUInst]) &&
       Inst &= ~(0x3FFULL << 39);
       Inst |= ISAOpCode << 1;
     }
     Emit(Inst, OS);
   }
 }
 
 void R600MCCodeEmitter::Emit(uint32_t Value, raw_ostream &OS) const {
-  support::endian::Writer<support::little>(OS).write(Value);
+  support::endian::write(OS, Value, support::little);
 }
 
 void R600MCCodeEmitter::Emit(uint64_t Value, raw_ostream &OS) const {
-  support::endian::Writer<support::little>(OS).write(Value);
+  support::endian::write(OS, Value, support::little);
 }
 
 unsigned R600MCCodeEmitter::getHWReg(unsigned RegNo) const {
   return MRI.getEncodingValue(RegNo) & HW_REG_MASK;
 }
 
 uint64_t R600MCCodeEmitter::getMachineOpValue(const MCInst &MI,
                                               const MCOperand &MO,

llvm/lib/Target/BPF/MCTargetDesc/BPFMCCodeEmitter.cpp

 
 void BPFMCCodeEmitter::encodeInstruction(const MCInst &MI, raw_ostream &OS,
                                          SmallVectorImpl<MCFixup> &Fixups,
                                          const MCSubtargetInfo &STI) const {
   verifyInstructionPredicates(MI,
                               computeAvailableFeatures(STI.getFeatureBits()));
 
   unsigned Opcode = MI.getOpcode();
-  support::endian::Writer<support::little> LE(OS);
-  support::endian::Writer<support::big> BE(OS);
+  support::endian::Writer OSE(OS,
+                              IsLittleEndian ? support::little : support::big);
 
   if (Opcode == BPF::LD_imm64 || Opcode == BPF::LD_pseudo) {
     uint64_t Value = getBinaryCodeForInstr(MI, Fixups, STI);
-    LE.write<uint8_t>(Value >> 56);
+    OS << char(Value >> 56);
     if (IsLittleEndian)
-      LE.write<uint8_t>((Value >> 48) & 0xff);
+      OS << char((Value >> 48) & 0xff);
     else
-      LE.write<uint8_t>(SwapBits((Value >> 48) & 0xff));
-    LE.write<uint16_t>(0);
-    if (IsLittleEndian)
-      LE.write<uint32_t>(Value & 0xffffFFFF);
-    else
-      BE.write<uint32_t>(Value & 0xffffFFFF);
+      OS << char(SwapBits((Value >> 48) & 0xff));
+    OSE.write<uint16_t>(0);
+    OSE.write<uint32_t>(Value & 0xffffFFFF);
 
     const MCOperand &MO = MI.getOperand(1);
     uint64_t Imm = MO.isImm() ? MO.getImm() : 0;
-    LE.write<uint8_t>(0);
-    LE.write<uint8_t>(0);
-    LE.write<uint16_t>(0);
-    if (IsLittleEndian)
-      LE.write<uint32_t>(Imm >> 32);
-    else
-      BE.write<uint32_t>(Imm >> 32);
+    OSE.write<uint8_t>(0);
+    OSE.write<uint8_t>(0);
+    OSE.write<uint16_t>(0);
+    OSE.write<uint32_t>(Imm >> 32);
   } else {
     // Get instruction encoding and emit it
     uint64_t Value = getBinaryCodeForInstr(MI, Fixups, STI);
-    LE.write<uint8_t>(Value >> 56);
-    if (IsLittleEndian) {
-      LE.write<uint8_t>((Value >> 48) & 0xff);
-      LE.write<uint16_t>((Value >> 32) & 0xffff);
-      LE.write<uint32_t>(Value & 0xffffFFFF);
-    } else {
-      LE.write<uint8_t>(SwapBits((Value >> 48) & 0xff));
-      BE.write<uint16_t>((Value >> 32) & 0xffff);
-      BE.write<uint32_t>(Value & 0xffffFFFF);
-    }
+    OS << char(Value >> 56);
+    if (IsLittleEndian)
+      OS << char((Value >> 48) & 0xff);
+    else
+      OS << char(SwapBits((Value >> 48) & 0xff));
+    OSE.write<uint16_t>((Value >> 32) & 0xffff);
+    OSE.write<uint32_t>(Value & 0xffffFFFF);
   }
 }
 
 // Encode BPF Memory Operand
 uint64_t BPFMCCodeEmitter::getMemoryOpValue(const MCInst &MI, unsigned Op,
                                             SmallVectorImpl<MCFixup> &Fixups,
                                             const MCSubtargetInfo &STI) const {
   uint64_t Encoding;

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCCodeEmitter.cpp

if (Opc >= Hexagon::DuplexIClass0 && Opc <= Hexagon::DuplexIClassF) {
     unsigned SubBits0 = getBinaryCodeForInstr(*Sub0, Fixups, STI);
     // Get subinstruction slot 1.
     State.SubInst1 = true;
     unsigned SubBits1 = getBinaryCodeForInstr(*Sub1, Fixups, STI);
     State.SubInst1 = false;
 
     Binary |= SubBits0 | (SubBits1 << 16);
   }
-  support::endian::Writer<support::little>(OS).write<uint32_t>(Binary);
+  support::endian::write<uint32_t>(OS, Binary, support::little);
   ++MCNumEmitted;
 }
 
 LLVM_ATTRIBUTE_NORETURN
 static void raise_relocation_error(unsigned Width, unsigned Kind) {
   std::string Text;
   raw_string_ostream Stream(Text);
   Stream << "Unrecognized relocation combination: width=" << Width

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp

void encodeInstruction(const MCInst &MI, raw_ostream &OS,
 
     unsigned Opcode = MI.getOpcode();
     const MCInstrDesc &Desc = MCII.get(Opcode);
 
     uint64_t Bits = getBinaryCodeForInstr(MI, Fixups, STI);
 
     // Output the constant in big/little endian byte order.
     unsigned Size = Desc.getSize();
+    support::endianness E = IsLittleEndian ? support::little : support::big;
     switch (Size) {
     case 0:
       break;
     case 4:
-      if (IsLittleEndian) {
-        support::endian::Writer<support::little>(OS).write<uint32_t>(Bits);
-      } else {
-        support::endian::Writer<support::big>(OS).write<uint32_t>(Bits);
-      }
+      support::endian::write<uint32_t>(OS, Bits, E);
       break;
     case 8:
       // If we emit a pair of instructions, the first one is
       // always in the top 32 bits, even on little-endian.
-      if (IsLittleEndian) {
-        uint64_t Swapped = (Bits << 32) | (Bits >> 32);
-        support::endian::Writer<support::little>(OS).write<uint64_t>(Swapped);
-      } else {
-        support::endian::Writer<support::big>(OS).write<uint64_t>(Bits);
-      }
+      support::endian::write<uint32_t>(OS, Bits >> 32, E);
+      support::endian::write<uint32_t>(OS, Bits, E);
       break;
     default:
       llvm_unreachable("Invalid instruction size");
     }
     
     ++MCNumEmitted;  // Keep track of the # of mi's emitted.
   }
 

llvm/lib/Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp

void RISCVMCCodeEmitter::expandFunctionCall(const MCInst &MI, raw_ostream &OS,
   const MCExpr *CallExpr =
       RISCVMCExpr::create(Expr, RISCVMCExpr::VK_RISCV_CALL, Ctx);
 
   // Emit AUIPC Ra, Func with R_RISCV_CALL relocation type.
   TmpInst = MCInstBuilder(RISCV::AUIPC)
                 .addReg(Ra)
                 .addOperand(MCOperand::createExpr(CallExpr));
   Binary = getBinaryCodeForInstr(TmpInst, Fixups, STI);
-  support::endian::Writer<support::little>(OS).write(Binary);
+  support::endian::write(OS, Binary, support::little);
 
   // Emit JALR Ra, Ra, 0
   TmpInst = MCInstBuilder(RISCV::JALR).addReg(Ra).addReg(Ra).addImm(0);
   Binary = getBinaryCodeForInstr(TmpInst, Fixups, STI);
-  support::endian::Writer<support::little>(OS).write(Binary);
+  support::endian::write(OS, Binary, support::little);
 }
 
 void RISCVMCCodeEmitter::encodeInstruction(const MCInst &MI, raw_ostream &OS,
                                            SmallVectorImpl<MCFixup> &Fixups,
                                            const MCSubtargetInfo &STI) const {
   const MCInstrDesc &Desc = MCII.get(MI.getOpcode());
   // Get byte count of instruction.
   unsigned Size = Desc.getSize();
 
   if (MI.getOpcode() == RISCV::PseudoCALL ||
       MI.getOpcode() == RISCV::PseudoTAIL) {
     expandFunctionCall(MI, OS, Fixups, STI);
     MCNumEmitted += 2;
     return;
   }
 
   switch (Size) {
   default:
     llvm_unreachable("Unhandled encodeInstruction length!");
   case 2: {
     uint16_t Bits = getBinaryCodeForInstr(MI, Fixups, STI);
-    support::endian::Writer<support::little>(OS).write<uint16_t>(Bits);
+    support::endian::write<uint16_t>(OS, Bits, support::little);
     break;
   }
   case 4: {
     uint32_t Bits = getBinaryCodeForInstr(MI, Fixups, STI);
-    support::endian::Writer<support::little>(OS).write(Bits);
+    support::endian::write(OS, Bits, support::little);
     break;
   }
   }
 
   ++MCNumEmitted; // Keep track of the # of mi's emitted.
 }
 
 unsigned

llvm/lib/Target/Sparc/MCTargetDesc/SparcMCCodeEmitter.cpp

 
 void SparcMCCodeEmitter::encodeInstruction(const MCInst &MI, raw_ostream &OS,
                                            SmallVectorImpl<MCFixup> &Fixups,
                                            const MCSubtargetInfo &STI) const {
   verifyInstructionPredicates(MI,
                               computeAvailableFeatures(STI.getFeatureBits()));
 
   unsigned Bits = getBinaryCodeForInstr(MI, Fixups, STI);
-
-  if (Ctx.getAsmInfo()->isLittleEndian()) {
-    // Output the bits in little-endian byte order.
-    support::endian::Writer<support::little>(OS).write<uint32_t>(Bits);
-  } else {
-    // Output the bits in big-endian byte order.
-    support::endian::Writer<support::big>(OS).write<uint32_t>(Bits);
-  }
+  support::endian::write(OS, Bits,
+                         Ctx.getAsmInfo()->isLittleEndian() ? support::little
+                                                            : support::big);
   unsigned tlsOpNo = 0;
   switch (MI.getOpcode()) {
   default: break;
   case SP::TLS_CALL:   tlsOpNo = 1; break;
   case SP::TLS_ADDrr:
   case SP::TLS_ADDXrr:
   case SP::TLS_LDrr:
   case SP::TLS_LDXrr:  tlsOpNo = 3; break;

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCCodeEmitter.cpp

if (MO.isReg()) {
              "Unexpected floating-point immediate as a non-fixed operand");
       assert(Desc.TSFlags == 0 &&
              "WebAssembly variable_ops floating point ops don't use TSFlags");
       const MCOperandInfo &Info = Desc.OpInfo[i];
       if (Info.OperandType == WebAssembly::OPERAND_F32IMM) {
         // TODO: MC converts all floating point immediate operands to double.
         // This is fine for numeric values, but may cause NaNs to change bits.
         float f = float(MO.getFPImm());
-        support::endian::Writer<support::little>(OS).write<float>(f);
+        support::endian::write<float>(OS, f, support::little);
       } else {
         assert(Info.OperandType == WebAssembly::OPERAND_F64IMM);
         double d = MO.getFPImm();
-        support::endian::Writer<support::little>(OS).write<double>(d);
+        support::endian::write<double>(OS, d, support::little);
       }
     } else if (MO.isExpr()) {
       const MCOperandInfo &Info = Desc.OpInfo[i];
       llvm::MCFixupKind FixupKind;
       size_t PaddedSize = 5;
       if (Info.OperandType == WebAssembly::OPERAND_I32IMM) {
         FixupKind = MCFixupKind(WebAssembly::fixup_code_sleb128_i32);
       } else if (Info.OperandType == WebAssembly::OPERAND_I64IMM) {

llvm/tools/llvm-xray/xray-converter.cpp

void TraceConverter::exportAsYAML(const Trace &Records, raw_ostream &OS) {
   }
   Output Out(OS, nullptr, 0);
   Out << Trace;
 }
 
 void TraceConverter::exportAsRAWv1(const Trace &Records, raw_ostream &OS) {
   // First write out the file header, in the correct endian-appropriate format
   // (XRay assumes currently little endian).
-  support::endian::Writer<support::endianness::little> Writer(OS);
+  support::endian::Writer Writer(OS, support::endianness::little);
   const auto &FH = Records.getFileHeader();
   Writer.write(FH.Version);
   Writer.write(FH.Type);
   uint32_t Bitfield{0};
   if (FH.ConstantTSC)
     Bitfield |= 1uL;
   if (FH.NonstopTSC)
     Bitfield |= 1uL << 1;

llvm/unittests/Support/EndianStreamTest.cpp

 
 namespace {
 
 TEST(EndianStream, WriteInt32LE) {
   SmallString<16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<little> LE(OS);
+    endian::Writer LE(OS, little);
     LE.write(static_cast<int32_t>(-1362446643));
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xCD);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xB6);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xCA);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0xAE);
 }
 
 TEST(EndianStream, WriteInt32BE) {
   SmallVector<char, 16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<big> BE(OS);
+    endian::Writer BE(OS, big);
     BE.write(static_cast<int32_t>(-1362446643));
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xAE);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xCA);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xB6);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0xCD);
 }
 
 
 TEST(EndianStream, WriteFloatLE) {
   SmallString<16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<little> LE(OS);
+    endian::Writer LE(OS, little);
     LE.write(12345.0f);
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0x00);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xE4);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0x40);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x46);
 }
 
 TEST(EndianStream, WriteFloatBE) {
   SmallVector<char, 16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<big> BE(OS);
+    endian::Writer BE(OS, big);
     BE.write(12345.0f);
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0x46);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0x40);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xE4);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x00);
 }
 
 TEST(EndianStream, WriteInt64LE) {
   SmallString<16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<little> LE(OS);
+    endian::Writer LE(OS, little);
     LE.write(static_cast<int64_t>(-136244664332342323));
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xCD);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xAB);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xED);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x1B);
   EXPECT_EQ(static_cast<uint8_t>(data[4]), 0x33);
   EXPECT_EQ(static_cast<uint8_t>(data[5]), 0xF6);
   EXPECT_EQ(static_cast<uint8_t>(data[6]), 0x1B);
   EXPECT_EQ(static_cast<uint8_t>(data[7]), 0xFE);
 }
 
 TEST(EndianStream, WriteInt64BE) {
   SmallVector<char, 16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<big> BE(OS);
+    endian::Writer BE(OS, big);
     BE.write(static_cast<int64_t>(-136244664332342323));
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xFE);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0x1B);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xF6);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x33);
   EXPECT_EQ(static_cast<uint8_t>(data[4]), 0x1B);
   EXPECT_EQ(static_cast<uint8_t>(data[5]), 0xED);
   EXPECT_EQ(static_cast<uint8_t>(data[6]), 0xAB);
   EXPECT_EQ(static_cast<uint8_t>(data[7]), 0xCD);
 }
 
 TEST(EndianStream, WriteDoubleLE) {
   SmallString<16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<little> LE(OS);
+    endian::Writer LE(OS, little);
     LE.write(-2349214918.58107);
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0x20);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0x98);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0xD2);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0x98);
   EXPECT_EQ(static_cast<uint8_t>(data[4]), 0xC5);
   EXPECT_EQ(static_cast<uint8_t>(data[5]), 0x80);
   EXPECT_EQ(static_cast<uint8_t>(data[6]), 0xE1);
   EXPECT_EQ(static_cast<uint8_t>(data[7]), 0xC1);
 }
 
 TEST(EndianStream, WriteDoubleBE) {
   SmallVector<char, 16> data;
 
   {
     raw_svector_ostream OS(data);
-    endian::Writer<big> BE(OS);
+    endian::Writer BE(OS, big);
     BE.write(-2349214918.58107);
   }
 
   EXPECT_EQ(static_cast<uint8_t>(data[0]), 0xC1);
   EXPECT_EQ(static_cast<uint8_t>(data[1]), 0xE1);
   EXPECT_EQ(static_cast<uint8_t>(data[2]), 0x80);
   EXPECT_EQ(static_cast<uint8_t>(data[3]), 0xC5);
   EXPECT_EQ(static_cast<uint8_t>(data[4]), 0x98);
   EXPECT_EQ(static_cast<uint8_t>(data[5]), 0xD2);
   EXPECT_EQ(static_cast<uint8_t>(data[6]), 0x98);
   EXPECT_EQ(static_cast<uint8_t>(data[7]), 0x20);
 }
 
 TEST(EndianStream, WriteArrayLE) {
   SmallString<16> Data;
 
   {
     raw_svector_ostream OS(Data);
-    endian::Writer<little> LE(OS);
+    endian::Writer LE(OS, little);
     LE.write<uint16_t>({0x1234, 0x5678});
   }
 
   EXPECT_EQ(static_cast<uint8_t>(Data[0]), 0x34);
   EXPECT_EQ(static_cast<uint8_t>(Data[1]), 0x12);
   EXPECT_EQ(static_cast<uint8_t>(Data[2]), 0x78);
   EXPECT_EQ(static_cast<uint8_t>(Data[3]), 0x56);
 }
 
 TEST(EndianStream, WriteVectorLE) {
   SmallString<16> Data;
 
   {
     raw_svector_ostream OS(Data);
-    endian::Writer<little> LE(OS);
+    endian::Writer LE(OS, little);
     std::vector<uint16_t> Vec{0x1234, 0x5678};
     LE.write<uint16_t>(Vec);
   }
 
   EXPECT_EQ(static_cast<uint8_t>(Data[0]), 0x34);
   EXPECT_EQ(static_cast<uint8_t>(Data[1]), 0x12);
   EXPECT_EQ(static_cast<uint8_t>(Data[2]), 0x78);
   EXPECT_EQ(static_cast<uint8_t>(Data[3]), 0x56);
 }
 
 TEST(EndianStream, WriteFloatArrayLE) {
   SmallString<16> Data;
 
   {
     raw_svector_ostream OS(Data);
-    endian::Writer<little> LE(OS);
+    endian::Writer LE(OS, little);
     LE.write<float>({12345.0f, 12346.0f});
   }
 
   EXPECT_EQ(static_cast<uint8_t>(Data[0]), 0x00);
   EXPECT_EQ(static_cast<uint8_t>(Data[1]), 0xE4);
   EXPECT_EQ(static_cast<uint8_t>(Data[2]), 0x40);
   EXPECT_EQ(static_cast<uint8_t>(Data[3]), 0x46);
 
   EXPECT_EQ(static_cast<uint8_t>(Data[4]), 0x00);
   EXPECT_EQ(static_cast<uint8_t>(Data[5]), 0xE8);
   EXPECT_EQ(static_cast<uint8_t>(Data[6]), 0x40);
   EXPECT_EQ(static_cast<uint8_t>(Data[7]), 0x46);
 }
 
 
 } // end anon namespace