Add seek support into llvm::raw_ostream that can be conditionally enabled.

[clayborg]

Summary

While working on a patch for GSYM: https://reviews.llvm.org/D63828 there is a FileWriter class that is being used to write binary data to a stand alone file. The patch was directly using a std::ostream to do the writing, and multiple people in the comments of the patch suggested that we use llvm::raw_ostream. In order to be able to use raw_ostream in the patch we need to be able to seek to locations in the the stream when writing binary data to apply fixes to offsets.

This patch puts the ability to support seeking into llvm::raw_ostream so that we can end up using it in the FileWriter class in the unit tests. It does this by adding two virtual methods to llvm::raw_ostream:

/// Seek support is optional.
virtual bool supportsSeeking() { return false; }
 
/// Optional seek support. Defaults to not changing the file position.
virtual uint64_t seek(uint64_t off) { return current_pos(); };

There are default implementations that return false and current_pos() respectively so only changes need to be made to raw_ostream subclasses that need to add seek support. It also fixed raw_fd_ostream and raw_os_ostream to override these methods.

[MaskRay]

include/llvm/Support/raw_os_ostream.h

31

return OS.tellp() != -1;

[dblaikie]

Would raw_pwrite_stream suffice?

[clayborg]

In D65096#1596337, @dblaikie wrote:

Would raw_pwrite_stream suffice?

It actually would as I only need to fixup a few things for FileWriter in GSYM. Keeping this patch does allow us to use raw_ostream more file a seekable file, where the pwrite forces you to just do minimal fixups here and there. I am fine abandoning this if no one else thinks it is useful. Comments?

[dblaikie]

In D65096#1596357, @clayborg wrote:

In D65096#1596337, @dblaikie wrote:

Would raw_pwrite_stream suffice?

It actually would as I only need to fixup a few things for FileWriter in GSYM. Keeping this patch does allow us to use raw_ostream more file a seekable file, where the pwrite forces you to just do minimal fixups here and there. I am fine abandoning this if no one else thinks it is useful. Comments?

I think if we want more seekable file API - might be more suitable to expand/rename raw_pwrite_stream - so the seekability is part of the static type rather than a dynamically queried property, etc.

(but yeah, doesn't seem like a super high priority for this extra functionality)

[clayborg]

Abandoning since GSYM's FileWriter can get by with llvm::raw_pwrite_stream

include/llvm/Support/raw_os_ostream.h

 /// simple adaptor class.  It does not check for output errors; clients should
 /// use the underlying stream to detect errors.
 class raw_os_ostream : public raw_ostream {
   std::ostream &OS;
 
   /// write_impl - See raw_ostream::write_impl.
   void write_impl(const char *Ptr, size_t Size) override;
 
+  /// Implement optional seek support.
+  bool supportsSeeking() override { return true; }
+
+  /// Implement optional seek support.
+  uint64_t seek(uint64_t off) override;
+
   /// current_pos - Return the current position within the stream, not
   /// counting the bytes currently in the buffer.
   uint64_t current_pos() const override;
 
 public:
   raw_os_ostream(std::ostream &O) : OS(O) {}
   ~raw_os_ostream() override;
 };
 
 } // end llvm namespace
 
 #endif

include/llvm/Support/raw_ostream.h

explicit raw_ostream(bool unbuffered = false)
     OutBufStart = OutBufEnd = OutBufCur = nullptr;
   }
 
   raw_ostream(const raw_ostream &) = delete;
   void operator=(const raw_ostream &) = delete;
 
   virtual ~raw_ostream();
 
+  /// Seek support is optional.
+  virtual bool supportsSeeking() { return false; }
+
+  /// Optional seek support. Defaults to not changing the file position.
+  virtual uint64_t seek(uint64_t off) { return current_pos(); };
+
   /// tell - Return the current offset with the file.
   uint64_t tell() const { return current_pos() + GetNumBytesInBuffer(); }
 
   //===--------------------------------------------------------------------===//
   // Configuration Interface
   //===--------------------------------------------------------------------===//
 
   /// Set the stream to be buffered, with an automatically determined buffer
public:
   raw_fd_ostream(int fd, bool shouldClose, bool unbuffered=false);
 
   ~raw_fd_ostream() override;
 
   /// Manually flush the stream and close the file. Note that this does not call
   /// fsync.
   void close();
 
-  bool supportsSeeking() { return SupportsSeeking; }
+  bool supportsSeeking() override { return SupportsSeeking; }
 
   /// Flushes the stream and repositions the underlying file descriptor position
   /// to the offset specified from the beginning of the file.
-  uint64_t seek(uint64_t off);
+  uint64_t seek(uint64_t off) override;
 
   raw_ostream &changeColor(enum Colors colors, bool bold=false,
                            bool bg=false) override;
   raw_ostream &resetColor() override;
 
   raw_ostream &reverseColor() override;
 
   bool is_displayed() const override;

lib/Support/raw_os_ostream.cpp

 raw_os_ostream::~raw_os_ostream() {
   flush();
 }
 
 void raw_os_ostream::write_impl(const char *Ptr, size_t Size) {
   OS.write(Ptr, Size);
 }
 
+uint64_t raw_os_ostream::seek(uint64_t off) { 
+  OS.seekp(off); 
+  return current_pos();
+};
+
 uint64_t raw_os_ostream::current_pos() const { return OS.tellp(); }