[lldb] Add YAML traits for ArchSpec and ProcessInstanceInfo

[JDevlieghere]

Summary

Add YAML traits for ArchSpec and ProcessInstanceInfo so they can be serialized for the reproducers.

[labath]

Looks good. The mapping vs sequence traits thingy is not that important, but since we do have the "dump" command, it may be worthwhile to spent a bit of time implementing a slightly more complicated traits class so that the yaml output looks nicer. (Another reason against wrapping standard containters in custom XXXList classes)

lldb/source/Utility/ProcessInfo.cpp

348–351

Maybe define this as a SequenceTraits<ProcessInstanceInfoList>? I believe you could implement the required functions by simply forwarding them to SequenceTraits<std::vector<ProcessInstanceInfo>>::whatever

lldb/include/lldb/Utility/ArchSpec.h

 
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private-enumerations.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Support/YAMLTraits.h"
 #include <cstddef>
 #include <cstdint>
 #include <string>
 
 namespace lldb_private {
 
 /// \class ArchSpec ArchSpec.h "lldb/Utility/ArchSpec.h" An architecture
 /// specification class.

 /// \return true if \a lhs is less than \a rhs
 bool operator<(const ArchSpec &lhs, const ArchSpec &rhs);
 bool operator==(const ArchSpec &lhs, const ArchSpec &rhs);
 
 bool ParseMachCPUDashSubtypeTriple(llvm::StringRef triple_str, ArchSpec &arch);
 
 } // namespace lldb_private
 
+namespace llvm {
+namespace yaml {
+template <> struct ScalarTraits<lldb_private::ArchSpec> {
+  static void output(const lldb_private::ArchSpec &, void *, raw_ostream &);
+  static StringRef input(StringRef, void *, lldb_private::ArchSpec &);
+  static QuotingType mustQuote(StringRef S) { return QuotingType::Double; }
+};
+} // namespace yaml
+} // namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::ArchSpec)
+
 #endif // LLDB_UTILITY_ARCHSPEC_H

lldb/include/lldb/Utility/ProcessInfo.h

 //===-- ProcessInfo.h -------------------------------------------*- 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 LLDB_UTILITY_PROCESSINFO_H
 #define LLDB_UTILITY_PROCESSINFO_H
 
-// LLDB headers
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Environment.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/NameMatches.h"
-
+#include "llvm/Support/YAMLTraits.h"
 #include <vector>
 
 namespace lldb_private {
 
 class UserIDResolver;
 
 // ProcessInfo
 //
public:
   void SetArguments(const Args &args, bool first_arg_is_executable);
 
   void SetArguments(char const **argv, bool first_arg_is_executable);
 
   Environment &GetEnvironment() { return m_environment; }
   const Environment &GetEnvironment() const { return m_environment; }
 
 protected:
+  template <class T> friend struct llvm::yaml::MappingTraits;
   FileSpec m_executable;
   std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
   // Not all process plug-ins support specifying an argv[0] that differs from
   // the resolved platform executable (which is in m_executable)
   Args m_arguments; // All program arguments except argv[0]
   Environment m_environment;
   uint32_t m_uid;
   uint32_t m_gid;
public:
   void Dump(Stream &s, UserIDResolver &resolver) const;
 
   static void DumpTableHeader(Stream &s, bool show_args, bool verbose);
 
   void DumpAsTableRow(Stream &s, UserIDResolver &resolver, bool show_args,
                       bool verbose) const;
 
 protected:
+  friend struct llvm::yaml::MappingTraits<ProcessInstanceInfo>;
   uint32_t m_euid;
   uint32_t m_egid;
   lldb::pid_t m_parent_pid;
 };
 
 typedef std::vector<ProcessInstanceInfo> ProcessInstanceInfoList;
 
 // ProcessInstanceInfoMatch

 protected:
   ProcessInstanceInfo m_match_info;
   NameMatch m_name_match_type;
   bool m_match_all_users;
 };
 
 } // namespace lldb_private
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(lldb_private::ProcessInstanceInfo)
+
+namespace llvm {
+namespace yaml {
+template <> struct MappingTraits<lldb_private::ProcessInstanceInfo> {
+  static void mapping(IO &io, lldb_private::ProcessInstanceInfo &PII);
+};
+} // namespace yaml
+} // namespace llvm
+
 #endif // LLDB_UTILITY_PROCESSINFO_H

lldb/source/Utility/ArchSpec.cpp

void ArchSpec::DumpTriple(llvm::raw_ostream &s) const {
 
   s << llvm::formatv("{0}-{1}-{2}", arch_str.empty() ? "*" : arch_str,
                      vendor_str.empty() ? "*" : vendor_str,
                      os_str.empty() ? "*" : os_str);
 
   if (!environ_str.empty())
     s << "-" << environ_str;
 }
+
+void llvm::yaml::ScalarTraits<ArchSpec>::output(const ArchSpec &Val, void *,
+                                                raw_ostream &Out) {
+  Val.DumpTriple(Out);
+}
+
+llvm::StringRef
+llvm::yaml::ScalarTraits<ArchSpec>::input(llvm::StringRef Scalar, void *,
+                                          ArchSpec &Val) {
+  Val = ArchSpec(Scalar);
+  return {};
+}

lldb/source/Utility/ProcessInfo.cpp

bool ProcessInstanceInfoMatch::MatchAllProcesses() const {
   return true;
 }
 
 void ProcessInstanceInfoMatch::Clear() {
   m_match_info.Clear();
   m_name_match_type = NameMatch::Ignore;
   m_match_all_users = false;
 }
+
+void llvm::yaml::MappingTraits<ProcessInstanceInfo>::mapping(
+    IO &io, ProcessInstanceInfo &Info) {
+  io.mapRequired("executable", Info.m_executable);
+  io.mapRequired("arg0", Info.m_arg0);
+  io.mapRequired("arch", Info.m_arch);
+  io.mapRequired("uid", Info.m_uid);
+  io.mapRequired("gid", Info.m_gid);
+  io.mapRequired("pid", Info.m_pid);
+  io.mapRequired("effective-uid", Info.m_euid);
+  io.mapRequired("effective-gid", Info.m_egid);
+  io.mapRequired("parent-pid", Info.m_parent_pid);
+}

lldb/unittests/Utility/ArchSpecTest.cpp

 //===-- ArchSpecTest.cpp --------------------------------------------------===//
 //
 // 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 "gtest/gtest.h"
 
 #include "lldb/Utility/ArchSpec.h"
-#include "llvm/BinaryFormat/MachO.h"
 #include "llvm/BinaryFormat/ELF.h"
+#include "llvm/BinaryFormat/MachO.h"
+#include "llvm/Support/YAMLParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 TEST(ArchSpecTest, TestParseMachCPUDashSubtypeTripleSimple) {
 
   // Success conditions.  Valid cpu/subtype combinations using both - and .
   ArchSpec AS;
TEST(ArchSpecTest, MergeFrom) {
     ArchSpec A, B;
     A.SetArchitecture(eArchTypeELF, llvm::ELF::EM_ARM,
                       LLDB_INVALID_CPUTYPE, llvm::ELF::ELFOSABI_NONE);
     B.SetArchitecture(eArchTypeELF, llvm::ELF::EM_ARM,
                       LLDB_INVALID_CPUTYPE, llvm::ELF::ELFOSABI_LINUX);
 
     EXPECT_TRUE(A.IsValid());
     EXPECT_TRUE(B.IsValid());
-    
     EXPECT_EQ(llvm::Triple::ArchType::arm, B.GetTriple().getArch());
     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
               B.GetTriple().getVendor());
     EXPECT_EQ(llvm::Triple::OSType::Linux, B.GetTriple().getOS());
     EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
               B.GetTriple().getEnvironment());
-    
     A.MergeFrom(B);
     EXPECT_EQ(llvm::Triple::ArchType::arm, A.GetTriple().getArch());
     EXPECT_EQ(llvm::Triple::VendorType::UnknownVendor,
               A.GetTriple().getVendor());
     EXPECT_EQ(llvm::Triple::OSType::Linux, A.GetTriple().getOS());
     EXPECT_EQ(llvm::Triple::EnvironmentType::UnknownEnvironment,
               A.GetTriple().getEnvironment());
   }
TEST(ArchSpecTest, TripleComponentsWereSpecified) {
     ASSERT_TRUE(C.TripleOSWasSpecified());
     ASSERT_TRUE(C.TripleEnvironmentWasSpecified());
 
     ASSERT_TRUE(D.TripleVendorWasSpecified());
     ASSERT_TRUE(D.TripleOSWasSpecified());
     ASSERT_TRUE(D.TripleEnvironmentWasSpecified());
   }
 }
+
+TEST(ArchSpecTest, YAML) {
+  std::string buffer;
+  llvm::raw_string_ostream os(buffer);
+
+  // Serialize.
+  llvm::yaml::Output yout(os);
+  std::vector<ArchSpec> archs = {ArchSpec("x86_64-pc-linux"),
+                                 ArchSpec("x86_64-apple-macosx10.12"),
+                                 ArchSpec("i686-pc-windows")};
+  yout << archs;
+  os.flush();
+
+  // Deserialize.
+  std::vector<ArchSpec> deserialized;
+  llvm::yaml::Input yin(buffer);
+  yin >> deserialized;
+
+  EXPECT_EQ(archs, deserialized);
+}

lldb/unittests/Utility/ProcessInstanceInfoTest.cpp

TEST(ProcessInstanceInfoMatch, Name) {
 
   EXPECT_TRUE(match.Matches(info_bar));
   EXPECT_FALSE(match.Matches(info_empty));
 
   match.GetProcessInfo().GetExecutableFile() = FileSpec();
   EXPECT_TRUE(match.Matches(info_bar));
   EXPECT_TRUE(match.Matches(info_empty));
 }
+
+TEST(ProcessInstanceInfo, Yaml) {
+  std::string buffer;
+  llvm::raw_string_ostream os(buffer);
+
+  // Serialize.
+  ProcessInstanceInfo info("a.out", ArchSpec("x86_64-pc-linux"), 47);
+  info.SetUserID(1);
+  info.SetEffectiveUserID(2);
+  info.SetGroupID(3);
+  info.SetEffectiveGroupID(4);
+  llvm::yaml::Output yout(os);
+  yout << info;
+  os.flush();
+
+  // Deserialize.
+  ProcessInstanceInfo deserialized;
+  llvm::yaml::Input yin(buffer);
+  yin >> deserialized;
+
+  EXPECT_EQ(deserialized.GetNameAsStringRef(), info.GetNameAsStringRef());
+  EXPECT_EQ(deserialized.GetArchitecture(), info.GetArchitecture());
+  EXPECT_EQ(deserialized.GetUserID(), info.GetUserID());
+  EXPECT_EQ(deserialized.GetGroupID(), info.GetGroupID());
+  EXPECT_EQ(deserialized.GetEffectiveUserID(), info.GetEffectiveUserID());
+  EXPECT_EQ(deserialized.GetEffectiveGroupID(), info.GetEffectiveGroupID());
+}
+
+TEST(ProcessInstanceInfoList, Yaml) {
+  std::string buffer;
+  llvm::raw_string_ostream os(buffer);
+
+  // Serialize.
+  ProcessInstanceInfo info("a.out", ArchSpec("x86_64-pc-linux"), 47);
+  info.SetUserID(1);
+  info.SetEffectiveUserID(2);
+  info.SetGroupID(3);
+  info.SetEffectiveGroupID(4);
+  ProcessInstanceInfoList list;
+  list.push_back(info);
+  llvm::yaml::Output yout(os);
+  yout << list;
+  os.flush();
+
+  // Deserialize.
+  ProcessInstanceInfoList deserialized;
+  llvm::yaml::Input yin(buffer);
+  yin >> deserialized;
+
+  ASSERT_EQ(deserialized.size(), static_cast<size_t>(1));
+  EXPECT_EQ(deserialized[0].GetNameAsStringRef(), info.GetNameAsStringRef());
+  EXPECT_EQ(deserialized[0].GetArchitecture(), info.GetArchitecture());
+  EXPECT_EQ(deserialized[0].GetUserID(), info.GetUserID());
+  EXPECT_EQ(deserialized[0].GetGroupID(), info.GetGroupID());
+  EXPECT_EQ(deserialized[0].GetEffectiveUserID(), info.GetEffectiveUserID());
+  EXPECT_EQ(deserialized[0].GetEffectiveGroupID(), info.GetEffectiveGroupID());
+}