using buffer_ostream

Author: joaosaffran

llvm/include/llvm/MC/DXContainerRootSignature.h

@@ -6,9 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/IndexedMap.h"
 #include "llvm/BinaryFormat/DXContainer.h"
-#include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {

llvm/lib/MC/DXContainerRootSignature.cpp

@@ -9,104 +9,72 @@
 #include "llvm/MC/DXContainerRootSignature.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
-#include "llvm/Support/BinaryStreamWriter.h"
+#include "llvm/Support/EndianStream.h"
+#include "llvm/Support/Error.h"
 #include <cstdint>
-#include <sys/types.h>
 
 using namespace llvm;
 using namespace llvm::mcdxbc;
 
-Error setRewrite(BinaryStreamWriter &Stream, uint32_t &Offset) {
+void setRewrite(raw_ostream &Stream, uint32_t &Offset) {
   const uint32_t DummyValue = std::numeric_limits<uint32_t>::max();
-
-  Offset = Stream.getOffset();
-
-  if (Error Err = Stream.writeInteger(DummyValue))
-    return Err;
-
-  return Error::success();
+  Offset = Stream.tell();
+  support::endian::write(Stream, DummyValue, llvm::endianness::little);
 }
 
-Error rewriteOffset(BinaryStreamWriter &Stream, uint32_t Offset) {
-  uint64_t Value = Stream.getOffset();
-  Stream.setOffset(Offset);
-  if (Error Err = Stream.writeInteger((uint32_t)Value))
-    return Err;
-
-  Stream.setOffset(Value);
-
-  return Error::success();
+void rewriteOffset(buffer_ostream &Stream, uint32_t Offset) {
+  uint32_t Value = Stream.tell();
+  auto *InsertPoint = &Stream.buffer()[Offset];
+  support::endian::write(InsertPoint, Value, llvm::endianness::little);
 }
 
 Error RootSignatureDesc::write(raw_ostream &OS) const {
-  std::vector<uint8_t> Buffer(getSizeInBytes());
-  BinaryStreamWriter Writer(Buffer, llvm::endianness::little);
-
+  buffer_ostream Writer(OS);
   const uint32_t NumParameters = Parameters.size();
   const uint32_t Zero = 0;
 
-  if (Error Err = Writer.writeInteger(Header.Version))
-    return Err;
-
-  if (Error Err = Writer.writeInteger(NumParameters))
-    return Err;
+  support::endian::write(Writer, Header.Version, llvm::endianness::little);
+  support::endian::write(Writer, NumParameters, llvm::endianness::little);
 
   uint32_t HeaderPoint;
-  if (Error Err = setRewrite(Writer, HeaderPoint))
-    return Err;
-
-  // Static samplers still not implemented
-  if (Error Err = Writer.writeInteger(Zero))
-    return Err;
+  setRewrite(Writer, HeaderPoint);
 
-  if (Error Err = Writer.writeInteger(Zero))
-    return Err;
+  support::endian::write(Writer, Zero, llvm::endianness::little);
+  support::endian::write(Writer, Zero, llvm::endianness::little);
+  support::endian::write(Writer, Header.Flags, llvm::endianness::little);
 
-  if (Error Err = Writer.writeInteger(Header.Flags))
-    return Err;
-
-  if (Error Err = rewriteOffset(Writer, HeaderPoint))
-    return Err;
+  rewriteOffset(Writer, HeaderPoint);
 
   SmallVector<uint32_t> ParamsOffset;
   for (const auto &P : Parameters) {
-
-    if (Error Err = Writer.writeEnum(P.ParameterType))
-      return Err;
-
-    if (Error Err = Writer.writeEnum(P.ShaderVisibility))
-      return Err;
+    support::endian::write(Writer, P.ParameterType, llvm::endianness::little);
+    support::endian::write(Writer, P.ShaderVisibility,
+                           llvm::endianness::little);
 
     uint32_t Offset;
-    if (Error Err = setRewrite(Writer, Offset))
-      return Err;
+    setRewrite(Writer, Offset);
+
     ParamsOffset.push_back(Offset);
   }
 
   assert(NumParameters == ParamsOffset.size());
   for (size_t I = 0; I < NumParameters; ++I) {
-    if (Error Err = rewriteOffset(Writer, ParamsOffset[I]))
-      return Err;
-
+    rewriteOffset(Writer, ParamsOffset[I]);
     const auto &P = Parameters[I];
 
     switch (P.ParameterType) {
     case dxbc::RootParameterType::Constants32Bit: {
-      if (Error Err = Writer.writeInteger(P.Constants.ShaderRegister))
-        return Err;
-      if (Error Err = Writer.writeInteger(P.Constants.RegisterSpace))
-        return Err;
-      if (Error Err = Writer.writeInteger(P.Constants.Num32BitValues))
-        return Err;
+      support::endian::write(Writer, P.Constants.ShaderRegister,
+                             llvm::endianness::little);
+      support::endian::write(Writer, P.Constants.RegisterSpace,
+                             llvm::endianness::little);
+      support::endian::write(Writer, P.Constants.Num32BitValues,
+                             llvm::endianness::little);
     } break;
     case dxbc::RootParameterType::Empty:
       llvm_unreachable("Invalid RootParameterType");
     }
   }
 
-  llvm::ArrayRef<char> BufferRef(reinterpret_cast<char *>(Buffer.data()),
-                                 Buffer.size());
-  OS.write(BufferRef.data(), BufferRef.size());
-
   return Error::success();
 }