Remove debug std::cout code. Run git-clang-format

Author: Jlalond

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

@@ -408,7 +408,7 @@ std::vector<const minidump::Module *> MinidumpParser::GetFilteredModuleList() {
         continue;
       }
       // This module has been seen. Modules are sometimes mentioned multiple
-      // times when they are mapped discontiguously, so find the module with 
+      // times when they are mapped discontiguously, so find the module with
       // the lowest "base_of_image" and use that as the filtered module.
       if (module.BaseOfImage < dup_module->BaseOfImage)
         filtered_modules[iter->second] = &module;
@@ -417,7 +417,8 @@ std::vector<const minidump::Module *> MinidumpParser::GetFilteredModuleList() {
   return filtered_modules;
 }
 
-const std::vector<minidump::ExceptionStream> MinidumpParser::GetExceptionStreams() {
+const std::vector<minidump::ExceptionStream>
+MinidumpParser::GetExceptionStreams() {
   auto ExpectedStream = GetMinidumpFile().getExceptionStreams();
   if (ExpectedStream)
     return ExpectedStream.get();

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

@@ -39,7 +39,6 @@
 
 #include <memory>
 #include <optional>
-#include <iostream>
 
 using namespace lldb;
 using namespace lldb_private;
@@ -158,8 +157,7 @@ ProcessMinidump::ProcessMinidump(lldb::TargetSP target_sp,
                                  const FileSpec &core_file,
                                  DataBufferSP core_data)
     : PostMortemProcess(target_sp, listener_sp, core_file),
-      m_core_data(std::move(core_data)),
-      m_is_wow64(false) {}
+      m_core_data(std::move(core_data)), m_is_wow64(false) {}
 
 ProcessMinidump::~ProcessMinidump() {
   Clear();
@@ -210,18 +208,19 @@ Status ProcessMinidump::DoLoadCore() {
   GetTarget().SetArchitecture(arch, true /*set_platform*/);
 
   m_thread_list = m_minidump_parser->GetThreads();
-  std::vector<minidump::ExceptionStream> exception_streams = m_minidump_parser->GetExceptionStreams();
+  std::vector<minidump::ExceptionStream> exception_streams =
+      m_minidump_parser->GetExceptionStreams();
   for (const auto &exception_stream : exception_streams) {
-    if (m_exceptions_by_tid.count(exception_stream.ThreadId) > 0) {
-      // We only cast to avoid the warning around converting little endian in printf.
-      error.SetErrorStringWithFormat("duplicate exception stream for tid %" PRIu32, (uint32_t)exception_stream.ThreadId);
+    if (!m_exceptions_by_tid
+             .try_emplace(exception_stream.ThreadId, exception_stream)
+             .second) {
+      // We only cast to avoid the warning around converting little endian in
+      // printf.
+      error.SetErrorStringWithFormat(
+          "duplicate exception stream for tid %" PRIu32,
+          (uint32_t)exception_stream.ThreadId);
       return error;
-    } else 
-      m_exceptions_by_tid[exception_stream.ThreadId] = exception_stream;
-
-
-    std::cout << "Adding Exception Stream # " << (uint32_t)exception_stream.ThreadId << std::endl;
-    std::cout << "Added index " << (uint32_t)m_exceptions_by_tid[exception_stream.ThreadId].ExceptionRecord.ExceptionCode << std::endl;
+    }
   }
 
   SetUnixSignals(UnixSignals::Create(GetArchitecture()));
@@ -270,14 +269,12 @@ void ProcessMinidump::RefreshStateAfterStop() {
 
     if (arch.GetTriple().getOS() == llvm::Triple::Linux) {
       uint32_t signo = exception_stream.ExceptionRecord.ExceptionCode;
-      std::cout << "Thread Id : " << exception_stream.ThreadId << " has signal " << signo << std::endl;
       if (signo == 0) {
         // No stop.
         return;
       }
 
-      stop_info = StopInfo::CreateStopReasonWithSignal(
-          *stop_thread, signo);
+      stop_info = StopInfo::CreateStopReasonWithSignal(*stop_thread, signo);
     } else if (arch.GetTriple().getVendor() == llvm::Triple::Apple) {
       stop_info = StopInfoMachException::CreateStopReasonWithMachException(
           *stop_thread, exception_stream.ExceptionRecord.ExceptionCode, 2,
@@ -288,10 +285,10 @@ void ProcessMinidump::RefreshStateAfterStop() {
       llvm::raw_string_ostream desc_stream(desc);
       desc_stream << "Exception "
                   << llvm::format_hex(
-                        exception_stream.ExceptionRecord.ExceptionCode, 8)
+                         exception_stream.ExceptionRecord.ExceptionCode, 8)
                   << " encountered at address "
                   << llvm::format_hex(
-                        exception_stream.ExceptionRecord.ExceptionAddress, 8);
+                         exception_stream.ExceptionRecord.ExceptionAddress, 8);
       stop_info = StopInfo::CreateStopReasonWithException(
           *stop_thread, desc_stream.str().c_str());
     }
@@ -405,14 +402,14 @@ bool ProcessMinidump::DoUpdateThreadList(ThreadList &old_thread_list,
       exception = m_exceptions_by_tid[thread.ThreadId].ExceptionRecord;
     }
 
-
     llvm::ArrayRef<uint8_t> context;
     if (!m_is_wow64)
       context = m_minidump_parser->GetThreadContext(context_location);
     else
       context = m_minidump_parser->GetThreadContextWow64(thread);
 
-    lldb::ThreadSP thread_sp(new ThreadMinidump(*this, thread, context, exception));
+    lldb::ThreadSP thread_sp(
+        new ThreadMinidump(*this, thread, context, exception));
     new_thread_list.AddThread(thread_sp);
   }
   return new_thread_list.GetSize(false) > 0;

lldb/source/Plugins/Process/minidump/ThreadMinidump.cpp

@@ -34,7 +34,8 @@ using namespace lldb_private;
 using namespace minidump;
 
 ThreadMinidump::ThreadMinidump(Process &process, const minidump::Thread &td,
-                               llvm::ArrayRef<uint8_t> gpregset_data, std::optional<minidump::Exception> exception)
+                               llvm::ArrayRef<uint8_t> gpregset_data,
+                               std::optional<minidump::Exception> exception)
     : Thread(process, td.ThreadId), m_thread_reg_ctx_sp(),
       m_gpregset_data(gpregset_data), m_exception(exception) {}
 
@@ -115,12 +116,15 @@ ThreadMinidump::CreateRegisterContextForFrame(StackFrame *frame) {
   return reg_ctx_sp;
 }
 
+// This method doesn't end up getting called for minidump
+// because the stopinfo is set in `ProcessMinidump::RefreshStateAfterStop`
 bool ThreadMinidump::CalculateStopInfo() {
   if (!m_exception)
     return false;
 
   minidump::Exception thread_exception = m_exception.value();
   SetStopInfo(StopInfo::CreateStopReasonWithSignal(
-      *this, thread_exception.ExceptionCode, /*description=*/nullptr, thread_exception.ExceptionCode));
+      *this, thread_exception.ExceptionCode, /*description=*/nullptr,
+      thread_exception.ExceptionCode));
   return true;
 }

lldb/source/Plugins/Process/minidump/ThreadMinidump.h

@@ -21,7 +21,8 @@ namespace minidump {
 class ThreadMinidump : public Thread {
 public:
   ThreadMinidump(Process &process, const minidump::Thread &td,
-                 llvm::ArrayRef<uint8_t> gpregset_data, std::optional<minidump::Exception> exception);
+                 llvm::ArrayRef<uint8_t> gpregset_data,
+                 std::optional<minidump::Exception> exception);
 
   ~ThreadMinidump() override;
 

lldb/unittests/Process/minidump/MinidumpParserTest.cpp

@@ -253,7 +253,7 @@ TEST_F(MinidumpParserTest, GetExceptionStream) {
   SetUpData("linux-x86_64.dmp");
   llvm::Expected<std::vector<ExceptionStream>> exception_stream =
       parser->GetExceptionStreams();
-  // LLVM::Expected has an explicit bool operator that determines if 
+  // LLVM::Expected has an explicit bool operator that determines if
   // the expected value is an error or not.
   ASSERT_TRUE((bool)exception_stream);
   ASSERT_EQ(1UL, exception_stream->size());

llvm/include/llvm/Object/Minidump.h

@@ -82,10 +82,11 @@ class MinidumpFile : public Binary {
     return getListStream<minidump::Thread>(minidump::StreamType::ThreadList);
   }
 
-  /// Returns the contents of the Exception stream. An error is returned if the 
-  /// associated stream is smaller than the size of the ExceptionStream structure.  
-  /// Or the directory supplied is not of kind exception stream.
-  Expected<minidump::ExceptionStream> getExceptionStream(minidump::Directory Directory) const {
+  /// Returns the contents of the Exception stream. An error is returned if the
+  /// associated stream is smaller than the size of the ExceptionStream
+  /// structure. Or the directory supplied is not of kind exception stream.
+  Expected<minidump::ExceptionStream>
+  getExceptionStream(minidump::Directory Directory) const {
     if (Directory.Type != minidump::StreamType::Exception) {
       return createError("Not an exception stream");
     }
@@ -94,8 +95,9 @@ class MinidumpFile : public Binary {
   }
 
   /// 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.
+  /// 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<minidump::ExceptionStream>> getExceptionStreams() const;
 
   /// Returns the list of descriptors embedded in the MemoryList stream. The
@@ -182,7 +184,8 @@ class MinidumpFile : public Binary {
   /// Return the stream of the given type, cast to the appropriate type. Checks
   /// that the stream is large enough to hold an object of this type.
   template <typename T>
-  Expected<const T &> getStreamFromDirectory(minidump::Directory Directory) const;
+  Expected<const T &>
+  getStreamFromDirectory(minidump::Directory Directory) const;
 
   /// Return the stream of the given type, cast to the appropriate type. Checks
   /// that the stream is large enough to hold an object of this type.
@@ -200,7 +203,8 @@ class MinidumpFile : public Binary {
 };
 
 template <typename T>
-Expected<const T &> MinidumpFile::getStreamFromDirectory(minidump::Directory Directory) const {
+Expected<const T &>
+MinidumpFile::getStreamFromDirectory(minidump::Directory Directory) const {
   ArrayRef<uint8_t> Stream = getRawStream(Directory);
   if (Stream.size() >= sizeof(T))
     return *reinterpret_cast<const T *>(Stream.data());

llvm/lib/Object/Minidump.cpp

@@ -54,7 +54,8 @@ Expected<std::string> MinidumpFile::getString(size_t Offset) const {
   return Result;
 }
 
-Expected<std::vector<minidump::ExceptionStream>> MinidumpFile::getExceptionStreams() const {
+Expected<std::vector<minidump::ExceptionStream>>
+MinidumpFile::getExceptionStreams() const {
   // Scan the directories for exceptions first
   std::vector<Directory> exceptionStreams;
   for (const auto &directory : Streams) {
@@ -67,15 +68,12 @@ Expected<std::vector<minidump::ExceptionStream>> MinidumpFile::getExceptionStrea
 
   std::vector<minidump::ExceptionStream> exceptionStreamList;
   for (const auto &exceptionStream : exceptionStreams) {
-    llvm::Expected<minidump::ExceptionStream> ExpectedStream = getStreamFromDirectory<minidump::ExceptionStream>(exceptionStream);
+    llvm::Expected<minidump::ExceptionStream> ExpectedStream =
+        getStreamFromDirectory<minidump::ExceptionStream>(exceptionStream);
     if (!ExpectedStream)
       return ExpectedStream.takeError();
 
-    std::cout << "Adding Exception Stream # " << exceptionStreamList.size() << std::endl;
-    std::cout << "Thread Id : " << ExpectedStream->ThreadId << std::endl;
-    std::cout << "Exception Code : " << ExpectedStream.get().ExceptionRecord.ExceptionCode << std::endl;
     exceptionStreamList.push_back(ExpectedStream.get());
-    assert(exceptionStreamList.back().ThreadId == ExpectedStream->ThreadId);
   }
 
   return exceptionStreamList;
@@ -172,9 +170,10 @@ MinidumpFile::create(MemoryBufferRef Source) {
     }
 
     // We treat exceptions differently here because the LLDB minidump
-    // makes some assumptions about uniqueness, all the streams other than exceptions
-    // are lists. But exceptions are not a list, they are single streams that point back to their thread
-    // So we will omit them here, and will find them when needed in the MinidumpFile.
+    // makes some assumptions about uniqueness, all the streams other than
+    // exceptions are lists. But exceptions are not a list, they are single
+    // 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;
     }