Add minidump support to obj2yaml

[labath]

Summary

This patch adds the code needed to parse a minidump file into the
MinidumpYAML model, and the necessary glue code so that obj2yaml can
recognise the minidump files and process them.

[labath]

James, do you have any thoughts on this? I think the minidump-specific changes are all pretty straight-forward here, so the thing I'm most interested in is whether this is ok from a obj2yaml perspective.

[jhenderson]

In D59634#1449621, @labath wrote:

James, do you have any thoughts on this? I think the minidump-specific changes are all pretty straight-forward here, so the thing I'm most interested in is whether this is ok from a obj2yaml perspective.

Sorry, I've been a bit snowed under with other stuff recently. I don't claim to be an expert on obj2yaml, but this LGTM.

[labath]

In D59634#1451182, @jhenderson wrote:

Sorry, I've been a bit snowed under with other stuff recently. I don't claim to be an expert on obj2yaml, but this LGTM.

No worries. You still have the fastest average response time for my code reviews/emails. :)

include/llvm/ObjectYAML/MinidumpYAML.h

 //===- MinidumpYAML.h - Minidump YAMLIO implementation ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECTYAML_MINIDUMPYAML_H
 #define LLVM_OBJECTYAML_MINIDUMPYAML_H
 
 #include "llvm/BinaryFormat/Minidump.h"
+#include "llvm/Object/Minidump.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 
 namespace llvm {
 namespace MinidumpYAML {
 
 /// The base class for all minidump streams. The "Type" of the stream
 /// corresponds to the Stream Type field in the minidump file. The "Kind" field
struct Stream {
   const StreamKind Kind;
   const minidump::StreamType Type;
 
   /// Get the stream Kind used for representing streams of a given Type.
   static StreamKind getKind(minidump::StreamType Type);
 
   /// Create an empty stream of the given Type.
   static std::unique_ptr<Stream> create(minidump::StreamType Type);
+
+  /// Create a stream from the given stream directory entry.
+  static Expected<std::unique_ptr<Stream>>
+  create(const minidump::Directory &StreamDesc,
+         const object::MinidumpFile &File);
 };
 
 /// A minidump stream represented as a sequence of hex bytes. This is used as a
 /// fallback when no other stream kind is suitable.
 struct RawContentStream : public Stream {
   yaml::BinaryRef Content;
   yaml::Hex32 Size;
 

 /// use the appropriate streaming operator on a yaml stream.
 struct Object {
   Object() = default;
   Object(const Object &) = delete;
   Object &operator=(const Object &) = delete;
   Object(Object &&) = default;
   Object &operator=(Object &&) = default;
 
+  Object(const minidump::Header &Header,
+         std::vector<std::unique_ptr<Stream>> Streams)
+      : Header(Header), Streams(std::move(Streams)) {}
+
   /// The minidump header.
   minidump::Header Header;
 
   /// The list of streams in this minidump object.
   std::vector<std::unique_ptr<Stream>> Streams;
+
+  static Expected<Object> create(const object::MinidumpFile &File);
 };
 
 /// Serialize the minidump file represented by Obj to OS in binary form.
 void writeAsBinary(Object &Obj, raw_ostream &OS);
 
 /// Serialize the yaml string as a minidump file to OS in binary form.
 Error writeAsBinary(StringRef Yaml, raw_ostream &OS);
 

lib/ObjectYAML/MinidumpYAML.cpp

Error MinidumpYAML::writeAsBinary(StringRef Yaml, raw_ostream &OS) {
   Object Obj;
   Input >> Obj;
   if (std::error_code EC = Input.error())
     return errorCodeToError(EC);
 
   writeAsBinary(Obj, OS);
   return Error::success();
 }
+
+Expected<std::unique_ptr<Stream>>
+Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) {
+  StreamKind Kind = getKind(StreamDesc.Type);
+  switch (Kind) {
+  case StreamKind::RawContent:
+    return make_unique<RawContentStream>(StreamDesc.Type,
+                                         File.getRawStream(StreamDesc));
+  case StreamKind::SystemInfo: {
+    auto ExpectedInfo = File.getSystemInfo();
+    if (!ExpectedInfo)
+      return ExpectedInfo.takeError();
+    return make_unique<SystemInfoStream>(*ExpectedInfo);
+  }
+  case StreamKind::TextContent:
+    return make_unique<TextContentStream>(
+        StreamDesc.Type, toStringRef(File.getRawStream(StreamDesc)));
+  }
+  llvm_unreachable("Unhandled stream kind!");
+}
+
+Expected<Object> Object::create(const object::MinidumpFile &File) {
+  std::vector<std::unique_ptr<Stream>> Streams;
+  Streams.reserve(File.streams().size());
+  for (const Directory &StreamDesc : File.streams()) {
+    auto ExpectedStream = Stream::create(StreamDesc, File);
+    if (!ExpectedStream)
+      return ExpectedStream.takeError();
+    Streams.push_back(std::move(*ExpectedStream));
+  }
+  return Object(File.header(), std::move(Streams));
+}

test/tools/obj2yaml/basic-minidump.yaml

+# RUN: yaml2obj %s | obj2yaml - | FileCheck %s
+
+--- !minidump
+Streams:         
+  - Type:            SystemInfo
+    Processor Arch:  ARM64
+    Platform ID:     Linux
+    CSD Version RVA: 0x01020304
+    CPU:             
+      CPUID:           0x05060708
+  - Type:            LinuxAuxv
+    Content:         DEADBEEFBAADF00D
+  - Type:            LinuxMaps
+    Text:             |
+      400d9000-400db000 r-xp 00000000 b3:04 227        /system/bin/app_process
+      400db000-400dc000 r--p 00001000 b3:04 227        /system/bin/app_process
+
+...
+
+# CHECK:      --- !minidump
+# CHECK-NEXT: Streams:         
+# CHECK-NEXT:   - Type:            SystemInfo
+# CHECK-NEXT:     Processor Arch:  ARM64
+# CHECK-NEXT:     Platform ID:     Linux
+# CHECK-NEXT:     CSD Version RVA: 0x01020304
+# CHECK-NEXT:     CPU:             
+# CHECK-NEXT:       CPUID:           0x05060708
+# CHECK-NEXT:   - Type:            LinuxAuxv
+# CHECK-NEXT:     Content:         DEADBEEFBAADF00D
+# CHECK-NEXT:   - Type:            LinuxMaps
+# CHECK-NEXT:     Text:             |
+# CHECK-NEXT:       400d9000-400db000 r-xp 00000000 b3:04 227        /system/bin/app_process
+# CHECK-NEXT:       400db000-400dc000 r--p 00001000 b3:04 227        /system/bin/app_process
+# CHECK-EMPTY:
+# CHECK-NEXT: ...

tools/obj2yaml/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   BinaryFormat
   DebugInfoCodeView
   DebugInfoDWARF
   Object
   ObjectYAML
   Support
   )
 
 add_llvm_tool(obj2yaml
   obj2yaml.cpp
   coff2yaml.cpp
   dwarf2yaml.cpp
   elf2yaml.cpp
   macho2yaml.cpp
+  minidump2yaml.cpp
   wasm2yaml.cpp
   Error.cpp
   )

tools/obj2yaml/minidump2yaml.cpp

+//===- minidump2yaml.cpp - Minidump to yaml conversion tool -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+#include "obj2yaml.h"
+#include "llvm/Object/Minidump.h"
+#include "llvm/ObjectYAML/MinidumpYAML.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace llvm;
+
+Error minidump2yaml(raw_ostream &Out, const object::MinidumpFile &Obj) {
+  auto ExpectedObject = MinidumpYAML::Object::create(Obj);
+  if (!ExpectedObject)
+    return ExpectedObject.takeError();
+  yaml::Output Output(Out);
+  Output << *ExpectedObject;
+  return llvm::Error::success();
+}

tools/obj2yaml/obj2yaml.h

 //===------ utils/obj2yaml.hpp - obj2yaml conversion tool -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 // This file declares some helper routines, and also the format-specific
 // writers. To add a new format, add the declaration here, and, in a separate
 // source file, implement it.
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_OBJ2YAML_OBJ2YAML_H
 #define LLVM_TOOLS_OBJ2YAML_OBJ2YAML_H
 
 #include "llvm/Object/COFF.h"
+#include "llvm/Object/Minidump.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
 std::error_code coff2yaml(llvm::raw_ostream &Out,
                           const llvm::object::COFFObjectFile &Obj);
 std::error_code elf2yaml(llvm::raw_ostream &Out,
                          const llvm::object::ObjectFile &Obj);
 std::error_code macho2yaml(llvm::raw_ostream &Out,
                            const llvm::object::Binary &Obj);
+llvm::Error minidump2yaml(llvm::raw_ostream &Out,
+                          const llvm::object::MinidumpFile &Obj);
 std::error_code wasm2yaml(llvm::raw_ostream &Out,
                           const llvm::object::WasmObjectFile &Obj);
 
 // Forward decls for dwarf2yaml
 namespace llvm {
 class DWARFContext;
 namespace DWARFYAML {
 struct Data;
 }
 }
 
 std::error_code dwarf2yaml(llvm::DWARFContext &DCtx, llvm::DWARFYAML::Data &Y);
 
 #endif

tools/obj2yaml/obj2yaml.cpp

 //===------ utils/obj2yaml.cpp - obj2yaml conversion tool -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "obj2yaml.h"
 #include "Error.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
+#include "llvm/Object/Minidump.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 static std::error_code dumpObject(const ObjectFile &Obj) {
   if (Obj.isCOFF())
static Error dumpInput(StringRef File) {
   Binary &Binary = *BinaryOrErr.get().getBinary();
   // Universal MachO is not a subclass of ObjectFile, so it needs to be handled
   // here with the other binary types.
   if (Binary.isMachO() || Binary.isMachOUniversalBinary())
     return errorCodeToError(macho2yaml(outs(), Binary));
   // TODO: If this is an archive, then burst it and dump each entry
   if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary))
     return errorCodeToError(dumpObject(*Obj));
+  if (MinidumpFile *Minidump = dyn_cast<MinidumpFile>(&Binary))
+    return minidump2yaml(outs(), *Minidump);
 
   return Error::success();
 }
 
 static void reportError(StringRef Input, Error Err) {
   if (Input == "-")
     Input = "<stdin>";
   std::string ErrMsg;