[lldb][NFC] Remove dead Process::GetSTDERR implementation

[teemperor]

Summary

From what I can see this just reads from some internal storage that is never written to
(aside from AppendSTDERR which is never called anywhere).

[labath]

We currently redirect inferior stdout and stderr streams into a pty, so they come out mixed at the other end. If we wanted to separate them, we'd have to redirect one of them (stderr, I guess) somewhere else (a pipe maybe). That shouldn't be too hard, though it would mean that the application environment is different than it would be when normally running in a terminal, and so I'm not sure if it's really worth it.

In any case, it should be easy to resurrect this code if we decide to go in that direction.

lldb/include/lldb/Target/Process.h

lldb::UnixSignalsSP
       m_unix_signals_sp; /// This is the current signal set for this process.
   lldb::ABISP m_abi_sp;
   lldb::IOHandlerSP m_process_input_reader;
   Communication m_stdio_communication;
   std::recursive_mutex m_stdio_communication_mutex;
   bool m_stdin_forward; /// Remember if stdin must be forwarded to remote debug
                         /// server
   std::string m_stdout_data;
-  std::string m_stderr_data;
   std::recursive_mutex m_profile_data_comm_mutex;
   std::vector<std::string> m_profile_data;
   Predicate<uint32_t> m_iohandler_sync;
   MemoryCache m_memory_cache;
   AllocatedMemoryCache m_allocated_memory_cache;
   bool m_should_detach; /// Should we detach if the process object goes away
                         /// with an explicit call to Kill or Detach?
   LanguageRuntimeCollection m_language_runtimes;
protected:
   GetStateChangedEventsPrivate(lldb::EventSP &event_sp,
                                const Timeout<std::micro> &timeout);
 
   size_t WriteMemoryPrivate(lldb::addr_t addr, const void *buf, size_t size,
                             Status &error);
 
   void AppendSTDOUT(const char *s, size_t len);
 
-  void AppendSTDERR(const char *s, size_t len);
-
   void BroadcastAsyncProfileData(const std::string &one_profile_data);
 
   static void STDIOReadThreadBytesReceived(void *baton, const void *src,
                                            size_t src_len);
 
   bool PushProcessIOHandler();
 
   bool PopProcessIOHandler();

lldb/source/Target/Process.cpp

: ProcessProperties(this),
       m_thread_id_to_index_id_map(), m_exit_status(-1), m_exit_string(),
       m_exit_status_mutex(), m_thread_mutex(), m_thread_list_real(this),
       m_thread_list(this), m_thread_plans(*this), m_extended_thread_list(this),
       m_extended_thread_stop_id(0), m_queue_list(this), m_queue_list_stop_id(0),
       m_notifications(), m_image_tokens(), m_listener_sp(listener_sp),
       m_breakpoint_site_list(), m_dynamic_checkers_up(),
       m_unix_signals_sp(unix_signals_sp), m_abi_sp(), m_process_input_reader(),
       m_stdio_communication("process.stdio"), m_stdio_communication_mutex(),
-      m_stdin_forward(false), m_stdout_data(), m_stderr_data(),
+      m_stdin_forward(false), m_stdout_data(),
       m_profile_data_comm_mutex(), m_profile_data(), m_iohandler_sync(0),
       m_memory_cache(*this), m_allocated_memory_cache(*this),
       m_should_detach(false), m_next_event_action_up(), m_public_run_lock(),
       m_private_run_lock(), m_finalizing(false),
       m_clear_thread_plans_on_stop(false), m_force_next_event_delivery(false),
       m_last_broadcast_state(eStateInvalid), m_destroy_in_process(false),
       m_can_interpret_function_calls(false), m_warnings_issued(),
       m_run_thread_plan_lock(), m_can_jit(eCanJITDontKnow) {

 
 void Process::AppendSTDOUT(const char *s, size_t len) {
   std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
   m_stdout_data.append(s, len);
   BroadcastEventIfUnique(eBroadcastBitSTDOUT,
                          new ProcessEventData(shared_from_this(), GetState()));
 }
 
-void Process::AppendSTDERR(const char *s, size_t len) {
-  std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
-  m_stderr_data.append(s, len);
-  BroadcastEventIfUnique(eBroadcastBitSTDERR,
-                         new ProcessEventData(shared_from_this(), GetState()));
-}
-
 void Process::BroadcastAsyncProfileData(const std::string &one_profile_data) {
   std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
   m_profile_data.push_back(one_profile_data);
   BroadcastEventIfUnique(eBroadcastBitProfileData,
                          new ProcessEventData(shared_from_this(), GetState()));
 }
 
 void Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
if (bytes_available > buf_size) {
       memcpy(buf, m_stdout_data.c_str(), bytes_available);
       m_stdout_data.clear();
     }
   }
   return bytes_available;
 }
 
 size_t Process::GetSTDERR(char *buf, size_t buf_size, Status &error) {
-  std::lock_guard<std::recursive_mutex> gaurd(m_stdio_communication_mutex);
-  size_t bytes_available = m_stderr_data.size();
-  if (bytes_available > 0) {
-    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
-    LLDB_LOGF(log, "Process::GetSTDERR (buf = %p, size = %" PRIu64 ")",
-              static_cast<void *>(buf), static_cast<uint64_t>(buf_size));
-    if (bytes_available > buf_size) {
-      memcpy(buf, m_stderr_data.c_str(), buf_size);
-      m_stderr_data.erase(0, buf_size);
-      bytes_available = buf_size;
-    } else {
-      memcpy(buf, m_stderr_data.c_str(), bytes_available);
-      m_stderr_data.clear();
-    }
-  }
-  return bytes_available;
+  return 0; // not implemented.
 }
 
 void Process::STDIOReadThreadBytesReceived(void *baton, const void *src,
                                            size_t src_len) {
   Process *process = (Process *)baton;
   process->AppendSTDOUT(static_cast<const char *>(src), src_len);
 }