Add minidump exception iterator

Author: Jlalond

llvm/include/llvm/Object/Minidump.h

@@ -95,13 +95,6 @@ class MinidumpFile : public Binary {
     return getStreamFromDirectory<minidump::ExceptionStream>(Directory);
   }
 
-  /// Returns the contents of the Exception streams.  An error is returned if
-  /// any of the streams are smaller than the size of the ExceptionStream
-  /// structure. The internal consistency of the stream is not checked in any
-  /// way.
-  Expected<std::vector<const minidump::ExceptionStream *>>
-  getExceptionStreams() const;
-
   /// Returns the list of descriptors embedded in the MemoryList stream. The
   /// descriptors provide the content of interesting regions of memory at the
   /// time the minidump was taken. An error is returned if the file does not
@@ -226,8 +219,71 @@ class MinidumpFile : public Binary {
     bool IsEnd;
   };
 
+class ExceptionStreamsIterator {
+  public:
+
+    static ExceptionStreamsIterator begin(ArrayRef<minidump::Directory> Streams, const MinidumpFile *File) {
+      return ExceptionStreamsIterator(Streams, File);
+    }
+
+    static ExceptionStreamsIterator end() {
+      return ExceptionStreamsIterator();
+    }
+
+    bool operator==(const ExceptionStreamsIterator &R) const {
+      return Streams.empty() && R.Streams.empty();
+    }
+
+    bool operator!=(const ExceptionStreamsIterator &R) const { return !(*this == R); }
+
+    const Expected<const minidump::ExceptionStream &>
+    operator*() {
+      return ReadCurrent();
+    }
+
+    const Expected<const minidump::ExceptionStream &>
+    operator->() {
+      return ReadCurrent();
+    }
+
+    ExceptionStreamsIterator &
+    operator++ () {
+      if (!Streams.empty())
+        Streams = Streams.drop_front();
+
+
+      return *this;
+    }
+
+  private:
+    ExceptionStreamsIterator(ArrayRef<minidump::Directory> Streams, const MinidumpFile *File)
+      : Streams(Streams), File(File) {}
+
+    ExceptionStreamsIterator() : Streams(ArrayRef<minidump::Directory>()), File(nullptr) {}
+
+    ArrayRef<minidump::Directory> Streams;
+    const MinidumpFile *File;
+
+    Expected<const minidump::ExceptionStream&> ReadCurrent() {
+      assert(!Streams.empty());
+      Expected<const minidump::ExceptionStream &> ExceptionStream =
+          File->getExceptionStream(Streams.front());
+      if (!ExceptionStream)
+        return ExceptionStream.takeError();
+      
+      return ExceptionStream;
+    }
+  };
+
   using FallibleMemory64Iterator = llvm::fallible_iterator<Memory64Iterator>;
 
+  /// Returns an iterator that reads each exception stream independently. The 
+  /// contents of the exception strema are not validated before being read, an 
+  /// error will be returned if the stream is not large enough to contain an
+  /// exception stream, or if the stream points beyond the end of the file.
+  iterator_range<ExceptionStreamsIterator>
+  getExceptionStreams() const;
+
   /// Returns an iterator that pairs each descriptor with it's respective
   /// content from the Memory64List stream. An error is returned if the file
   /// does not contain a Memory64List stream, or if the descriptor data is
@@ -266,9 +322,10 @@ class MinidumpFile : public Binary {
 
   MinidumpFile(MemoryBufferRef Source, const minidump::Header &Header,
                ArrayRef<minidump::Directory> Streams,
-               DenseMap<minidump::StreamType, std::size_t> StreamMap)
+               DenseMap<minidump::StreamType, std::size_t> StreamMap,
+               std::vector<minidump::Directory> ExceptionStreams)
       : Binary(ID_Minidump, Source), Header(Header), Streams(Streams),
-        StreamMap(std::move(StreamMap)) {}
+        StreamMap(std::move(StreamMap)), ExceptionStreams(std::move(ExceptionStreams)) {}
 
   ArrayRef<uint8_t> getData() const {
     return arrayRefFromStringRef(Data.getBuffer());
@@ -293,6 +350,7 @@ class MinidumpFile : public Binary {
   const minidump::Header &Header;
   ArrayRef<minidump::Directory> Streams;
   DenseMap<minidump::StreamType, std::size_t> StreamMap;
+  std::vector<minidump::Directory> ExceptionStreams;
 };
 
 template <typename T>

llvm/lib/Object/Minidump.cpp

@@ -53,25 +53,10 @@ Expected<std::string> MinidumpFile::getString(size_t Offset) const {
   return Result;
 }
 
-Expected<std::vector<const minidump::ExceptionStream *>>
+iterator_range<llvm::object::MinidumpFile::ExceptionStreamsIterator>
 MinidumpFile::getExceptionStreams() const {
-
-  std::vector<const minidump::ExceptionStream *> exceptionStreamList;
-  for (const auto &directory : Streams) {
-    if (directory.Type == StreamType::Exception) {
-      llvm::Expected<minidump::ExceptionStream *> ExpectedStream =
-          getStreamFromDirectory<minidump::ExceptionStream *>(directory);
-      if (!ExpectedStream)
-        return ExpectedStream.takeError();
-
-      exceptionStreamList.push_back(ExpectedStream.get());
-    }
-  }
-
-  if (exceptionStreamList.empty())
-    return createError("No exception streams found");
-
-  return exceptionStreamList;
+  return make_range(ExceptionStreamsIterator::begin(ExceptionStreams, this),
+                    ExceptionStreamsIterator::end());
 }
 
 Expected<iterator_range<MinidumpFile::MemoryInfoIterator>>
@@ -149,7 +134,7 @@ MinidumpFile::create(MemoryBufferRef Source) {
     return ExpectedStreams.takeError();
 
   DenseMap<StreamType, std::size_t> StreamMap;
-  std::vector<std::size_t> ExceptionStreams;
+  std::vector<Directory> ExceptionStreams;
   for (const auto &StreamDescriptor : llvm::enumerate(*ExpectedStreams)) {
     StreamType Type = StreamDescriptor.value().Type;
     const LocationDescriptor &Loc = StreamDescriptor.value().Location;
@@ -171,7 +156,7 @@ MinidumpFile::create(MemoryBufferRef Source) {
     // streams that point back to their thread So we will omit them here, and
     // will find them when needed in the MinidumpFile.
     if (Type == StreamType::Exception) {
-      continue;
+      ExceptionStreams.push_back(StreamDescriptor.value());
     }
 
     if (Type == DenseMapInfo<StreamType>::getEmptyKey() ||
@@ -184,7 +169,7 @@ MinidumpFile::create(MemoryBufferRef Source) {
   }
 
   return std::unique_ptr<MinidumpFile>(
-      new MinidumpFile(Source, Hdr, *ExpectedStreams, std::move(StreamMap)));
+      new MinidumpFile(Source, Hdr, *ExpectedStreams, std::move(StreamMap), ExceptionStreams));
 }
 
 iterator_range<MinidumpFile::FallibleMemory64Iterator>