support for 'process launch -i' on remote targets

[vharron]

Summary

Installs stdin file onto remote target in working directory before
launch.

[vharron]

Thoughts?

[clayborg]

This is a hard one to do automatically. What if you have an input file already on the remote side you wanted to used without one being uploaded for you? If we do this by default we don't have the option of using one that is already on the remote host. I would prefer to not automate this and fix the test suite so it does this for us, but it doesn't happen automagically...

include/lldb/Target/FileAction.h

-//===-- ProcessLaunchInfo.h -------------------------------------*- C++ -*-===//
+//===-- FileAction.h --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

include/lldb/Target/ProcessLaunchInfo.h

public:
         }
 
         const FileAction *
         GetFileActionAtIndex (size_t idx) const;
 
         const FileAction *
         GetFileActionForFD (int fd) const;
 
+        FileAction *
+        GetFileActionForFD (int fd);
+
         Flags &
         GetFlags ()
         {
             return m_flags;
         }
 
         const Flags &
         GetFlags () const

source/Target/ProcessLaunchInfo.cpp

ProcessLaunchInfo::GetFileActionForFD(int fd) const
     for (size_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
     {
         if (m_file_actions[idx].GetFD () == fd)
             return &m_file_actions[idx];
     }
     return NULL;
 }
 
+FileAction *
+ProcessLaunchInfo::GetFileActionForFD(int fd)
+{
+    for (size_t idx=0, count=m_file_actions.size(); idx < count; ++idx)
+    {
+        if (m_file_actions[idx].GetFD () == fd)
+            return &m_file_actions[idx];
+    }
+    return nullptr;
+}
+
 const char *
 ProcessLaunchInfo::GetWorkingDirectory () const
 {
     if (m_working_dir.empty())
         return NULL;
     return m_working_dir.c_str();
 }
 

source/Target/Target.cpp

if (platform_sp)
                                     }
                                 }
                                 else
                                     break;
                             }
                         }
                     }
                 }
+
+                if (launch_info)
+                {
+                    // copy stdin redirect, if any
+                    FileAction* stdin_action = launch_info->GetFileActionForFD(STDIN_FILENO);
+                    if (stdin_action)
+                    {
+                        if (stdin_action->GetAction() == FileAction::eFileActionOpen)
+                        {
+                            // hopefully the stdin file and the executable don't have the same name!
+                            FileSpec local_file;
+                            local_file.SetFile(stdin_action->GetPath(), false);
+
+                            FileSpec remote_file;
+
+                            remote_file.GetDirectory() = platform_sp->GetWorkingDirectory();
+                            remote_file.GetFilename() = local_file.GetFilename();
+                            error = platform_sp->Install(local_file, remote_file);
+                            if (error.Success())
+                            {
+                                // update FileAction in place
+                                stdin_action->Open(STDIN_FILENO, remote_file.GetPath().c_str(), true, false);
+                            }
+                        }
+                        else
+                        {
+                            error.SetErrorStringWithFormat("stdin file action (%i) is unsupported for remote targets", stdin_action->GetAction());
+                        }
+                    }
+                }
             }
         }
     }
     return error;
 }
 
 bool
 Target::ResolveLoadAddress (addr_t load_addr, Address &so_addr, uint32_t stop_id)