[lldb/Target] Add custom interpreter option to `platform shell`

[mib]

Summary

This patch adds the ability to use a custom interpreter with the
platform shell command. If the user set the -s|--shell option
with the path to a binary, lldb passes it down to the platform's
RunShellProcess method and set it as the shell to use in
`ProcessLaunchInfo to run commands.

Note that not all the Platforms support running shell commands with
custom interpreters (i.e. RemoteGDBServer is only expected to use the
default shell).

This patch also makes some refactoring and cleanups, like swapping
CString for StringRef when possible and updating SBPlatformShellCommand
with new methods and a new constructor.

rdar://67759256

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

lldb/source/API/SBPlatform.cpp

59

Given that this pattern repeats a few times in this struct, maybe a small static helper function would be nice:

static bool is_not_empty(cont char* c) { return c && c[0]; }

64

Shouldn't we just bail out if the command is null/empty? Now it will run shell -c, right?

71

m_command is a std::string, why call c_str()?

[kastiglione]

lldb/source/API/SBPlatform.cpp

59

Can these be StringRef, and then check with empty()?

lldb/source/Commands/CommandObjectPlatform.cpp

1627

Is it necessary to check readability? If not done here, at execution time would a non-readable interpreter lead to a useful error message?

If checking for readability is desirable here, is checking that it's executable also desirable?

lldb/test/API/commands/platform/basic/TestPlatformCommand.py

109

[labath]

I am wondering what should the platform classes which do not implement this feature do (although most of them could implemented I don't think you need to implement all of them -- PlatformGdbRemote in particular can be a bit tricky). It seems to me like it would be better for them to bail out if a non-standard shell is requested instead of silently executing a command the user did not intend.

lldb/include/lldb/Target/Platform.h

633

const on a value parameter is useless. Also, default arguments on virtual methods are somewhat shoot-footy: http://www.cplusplus.com/forum/general/69970/. The Non-virtual interface pattern would solve that, and maybe have some other benefits.

lldb/source/API/SBPlatform.cpp

59–68

Rather than duplicating this logic here (and getting it wrong for windows, for nested quotes, etc.) it would be better to just pass the custom shell to the RunShellCommand method. Then it use the existing quoting logic, and all that needs to change is that it now picks up the shell from the argument (if passed) instead of the baked-in default.

lldb/source/Commands/CommandObjectPlatform.cpp

1621–1633

This won't work for remote platforms. The checks should be at least done in the Platform class, but ideally I would really just leave it to the operating system to figure out if it can or cannot run a given command.

lldb/test/API/commands/platform/basic/TestPlatformCommand.py

96

You could build a small executable to serve as the "shell". Then, this test would work everywhere.

[jingham]

Do people really call command-line shells interpreters? I would have thought --shell would be a better name. lldb already has its own command interpreter which is orthogonal to the shells, so it seems confusing to use the same term for both.

[mib]

In D86667#2242566, @jingham wrote:

Do people really call command-line shells interpreters? I would have thought --shell would be a better name. lldb already has its own command interpreter which is orthogonal to the shells, so it seems confusing to use the same term for both.

I think platform shell --shell sounds/looks repetitive so I opted for -i|--interpreter instead, as in Command-line Interpreter.

lldb/source/API/SBPlatform.cpp

59

I think since this method will eventually interact with the Python API, they need to be C strings.

lldb/test/API/commands/platform/basic/TestPlatformCommand.py

109

Since it's a command output, it has a newline character at the end of it.

[mib]

Address most comments:

• Passed down the shell interpreter path down to Host::RunShellCommand to be "assembled" with the rest of the command.
• Wrote a custom test program to simplify testing on multiple platforms.
• Updated code by using llvm::StringRef instead of CString when possible.

[labath]

In D86667#2243781, @mib wrote:

In D86667#2242566, @jingham wrote:

Do people really call command-line shells interpreters? I would have thought --shell would be a better name. lldb already has its own command interpreter which is orthogonal to the shells, so it seems confusing to use the same term for both.

I think platform shell --shell sounds/looks repetitive so I opted for -i|--interpreter instead, as in Command-line Interpreter.

Yes, it is repetitive. OTOH:

• the unix commands that take a shell as an argument (e.g., su, sudo), do so via a --shell/-s argument
• we have a memory load --load command

Overall, I can understand where you're coming from, but I think I'd go with --shell nonetheless...

lldb/include/lldb/Target/Platform.h

643

The run_in_shell argument makes the inferface weird (why do I need to specify a shell, if I don't want to use it). And still suffers from the virtual default argument problem described above. Let's not propagate this Host weirdness into the platform class.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2820

These Shouldn't be NULL are out of place now, and probably not needed anymore.

2831

command.data() will do just fine

lldb/test/API/commands/platform/basic/TestPlatformPython.py

95 ↗

(On Diff #288531)

We normally set these things in the makefile. The environment tricks are reserved for cases where you need to do something funny (e.g. build multiple things from a single makefile, or similar...).

[jasonmolenda]

In D86667#2243878, @labath wrote:

In D86667#2243781, @mib wrote:

In D86667#2242566, @jingham wrote:

Do people really call command-line shells interpreters? I would have thought --shell would be a better name. lldb already has its own command interpreter which is orthogonal to the shells, so it seems confusing to use the same term for both.

I think platform shell --shell sounds/looks repetitive so I opted for -i|--interpreter instead, as in Command-line Interpreter.

Yes, it is repetitive. OTOH:

• the unix commands that take a shell as an argument (e.g., su, sudo), do so via a --shell/-s argument
• we have a memory load --load command

Overall, I can understand where you're coming from, but I think I'd go with --shell nonetheless...

I'd agree, process launch already takes a -c|--shell argument so it would be consistent to do that. (I assume -c was used because it's kind of like sh(1)'s -c option but not really. maybe more likely that -s was already used ;)

[mib]

lldb/include/lldb/Target/Platform.h

643

I started by removing this argument, then I noticed that some code calls Host::RunShellCommand with the run_in_shell argument set to false (i.e. PlatformDarwin::GetXcodeSelectPath). This means that Host::RunShellCommand will run the command without prepending the "sh -c" part.

That's why I kept it, and renamed it to run_in_shell instead of run_in_default_shell.

[mib]

• Changed CommandObject option from -i|--interpreter to -s|--shell.
• Updated test program build settings.

[labath]

lldb/include/lldb/Target/Platform.h

643

Right, but that code only calls the Host version. I'm only saying we should delete it (or, not add it, to be precise) to the Platform version. (I'd like to remove it from the Host version too, but that's a different story.)

[mib]

Removed bool run_in_shell argument from Platform classes.

[mib]

Replaced all the interpreter occurrences with shell in the code.

[labath]

Thanks, this looks good to me now.

lldb/test/API/commands/platform/basic/TestPlatformPython.py

16 ↗

(On Diff #288636)

If you add this, then there's no need for @no_debug_info_test on individual test methods.

[max-kudr]

Hi @mib, Windows buildbot is broken after this commit. Please fix or revert.

Failed Tests (2):

lldb-api :: commands/platform/basic/TestPlatformCommand.py
lldb-api :: commands/platform/basic/TestPlatformPython.py

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/18671/steps/test/logs/stdio

http://lab.llvm.org:8011/buildslaves/win-py3-buildbot

[mib]

@max-kudr Looking, thanks!

[mib]

lldb/test/API/commands/platform/basic/myshell.c

11 ↗

(On Diff #289444)

@max-kudr It seems I'm missing the leading _ (correct me if I'm wrong but IIUC the macro should be _WIN32), explaining the failure, I'll send a fix now.

[max-kudr]

lldb/test/API/commands/platform/basic/myshell.c

11 ↗

(On Diff #289444)

Yes, at least _WIN32 is used in clang. Thank you!

[mib]

Should be fixed with 0e86f390457a2b4dd1f2d1770db912963a36f240. @max-kudr I'll keep an eye on the Windows bot to make sure it worked :)

lldb/bindings/interface/SBPlatform.i

public:
 
     void
     SetLocalCacheDirectory(const char *path);
 };
 
 class SBPlatformShellCommand
 {
 public:
+    SBPlatformShellCommand (const char *shell_interpreter, const char *shell_command);
     SBPlatformShellCommand (const char *shell_command);
 
     SBPlatformShellCommand (const SBPlatformShellCommand &rhs);
 
     ~SBPlatformShellCommand();
 
     void
     Clear();

lldb/include/lldb/API/SBPlatform.h

 //===-- SBPlatform.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_API_SBPLATFORM_H
 #define LLDB_API_SBPLATFORM_H
 
 #include "lldb/API/SBDefines.h"
 
 #include <functional>
 
 struct PlatformConnectOptions;
 struct PlatformShellCommand;
 
 namespace lldb {
 
public:
   void SetLocalCacheDirectory(const char *path);
 
 protected:
   PlatformConnectOptions *m_opaque_ptr;
 };
 
 class LLDB_API SBPlatformShellCommand {
 public:
+  SBPlatformShellCommand(const char *shell_interpreter,
+                         const char *shell_command);
   SBPlatformShellCommand(const char *shell_command);
 
   SBPlatformShellCommand(const SBPlatformShellCommand &rhs);
 
   SBPlatformShellCommand &operator=(const SBPlatformShellCommand &rhs);
 
   ~SBPlatformShellCommand();
 

lldb/include/lldb/Target/Platform.h

 
 #include <functional>
 #include <map>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Host/File.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/Utility/Timeout.h"
virtual lldb_private::Status RunShellCommand(
       const char *command,         // Shouldn't be nullptr
       const FileSpec &working_dir, // Pass empty FileSpec to use the current
                                    // working directory
       int *status_ptr, // Pass nullptr if you don't want the process exit status
       int *signo_ptr,  // Pass nullptr if you don't want the signal that caused
                        // the process to exit
       std::string
           *command_output, // Pass nullptr if you don't want the command output
-      const Timeout<std::micro> &timeout);
+      const Timeout<std::micro> &timeout,
+      const bool run_in_default_shell = true);
 
   virtual void SetLocalCacheDirectory(const char *local);
 
   virtual const char *GetLocalCacheDirectory();
 
   virtual std::string GetPlatformSpecificConnectionInformation() { return ""; }
 
   virtual bool CalculateMD5(const FileSpec &file_spec, uint64_t &low,
                             uint64_t &high);
 
   virtual int32_t GetResumeCountForLaunchInfo(ProcessLaunchInfo &launch_info) {
     return 1;
   }
 
   virtual const lldb::UnixSignalsSP &GetRemoteUnixSignals();
 
   lldb::UnixSignalsSP GetUnixSignals();
 

lldb/include/lldb/Target/RemoteAwarePlatform.h

 //===-- RemoteAwarePlatform.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_TARGET_REMOTEAWAREPLATFORM_H
 #define LLDB_TARGET_REMOTEAWAREPLATFORM_H
 
 #include "lldb/Target/Platform.h"
 
 namespace lldb_private {
 
 /// A base class for platforms which automatically want to be able to forward
 /// operations to a remote platform instance (such as PlatformRemoteGDBServer).
 class RemoteAwarePlatform : public Platform {
 public:
   using Platform::Platform;
public:
   bool GetRemoteOSVersion() override;
   bool GetRemoteOSBuildString(std::string &s) override;
   bool GetRemoteOSKernelDescription(std::string &s) override;
   ArchSpec GetRemoteSystemArchitecture() override;
 
   Status RunShellCommand(const char *command, const FileSpec &working_dir,
                          int *status_ptr, int *signo_ptr,
                          std::string *command_output,
-                         const Timeout<std::micro> &timeout) override;
+                         const Timeout<std::micro> &timeout,
+                         const bool run_in_default_shell = true) override;
 
   const char *GetHostname() override;
   UserIDResolver &GetUserIDResolver() override;
   lldb_private::Environment GetEnvironment() override;
 
   bool IsConnected() const override;
 
   bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info) override;

lldb/source/API/SBPlatform.cpp

 //===-- SBPlatform.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 "lldb/API/SBPlatform.h"
 #include "SBReproducerPrivate.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"
 #include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBUnixSignals.h"
 #include "lldb/Host/File.h"
struct PlatformConnectOptions {
   std::string m_rsync_remote_path_prefix;
   bool m_rsync_enabled;
   bool m_rsync_omit_hostname_from_remote_path;
   ConstString m_local_cache_directory;
 };
 
 // PlatformShellCommand
 struct PlatformShellCommand {
+  PlatformShellCommand(const char *command_interpreter,
+                       const char *shell_command)
+      : m_command(), m_working_dir(), m_status(0), m_signo(0),
+        m_run_in_default_shell(false) {
+    std::string full_command;
+
+    if (command_interpreter && command_interpreter[0]) {
+      full_command += command_interpreter;
+      full_command += " -c ";
+    }
+
+    if (shell_command && shell_command[0]) {
+      full_command += " \"";
+      full_command += shell_command;
+      full_command += "\"";
+    }
+
+    if (!full_command.empty()) {
+      m_command = full_command.c_str();
+    }
+  }
+
   PlatformShellCommand(const char *shell_command = nullptr)
-      : m_command(), m_working_dir(), m_status(0), m_signo(0) {
+      : m_command(), m_working_dir(), m_status(0), m_signo(0),
+        m_run_in_default_shell(true) {
     if (shell_command && shell_command[0])
       m_command = shell_command;
   }
 
   ~PlatformShellCommand() = default;
 
   std::string m_command;
   std::string m_working_dir;
   std::string m_output;
   int m_status;
   int m_signo;
   Timeout<std::ratio<1>> m_timeout = llvm::None;
+  bool m_run_in_default_shell;
 };
 // SBPlatformConnectOptions
 SBPlatformConnectOptions::SBPlatformConnectOptions(const char *url)
     : m_opaque_ptr(new PlatformConnectOptions(url)) {
   LLDB_RECORD_CONSTRUCTOR(SBPlatformConnectOptions, (const char *), url);
 }
 
 SBPlatformConnectOptions::SBPlatformConnectOptions(
void SBPlatformConnectOptions::SetLocalCacheDirectory(const char *path) {
 
   if (path && path[0])
     m_opaque_ptr->m_local_cache_directory.SetCString(path);
   else
     m_opaque_ptr->m_local_cache_directory = ConstString();
 }
 
 // SBPlatformShellCommand
+SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_interpreter,
+                                               const char *shell_command)
+    : m_opaque_ptr(new PlatformShellCommand(shell_interpreter, shell_command)) {
+  LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *, const char *),
+                          shell_interpreter, shell_command);
+}
+
 SBPlatformShellCommand::SBPlatformShellCommand(const char *shell_command)
     : m_opaque_ptr(new PlatformShellCommand(shell_command)) {
   LLDB_RECORD_CONSTRUCTOR(SBPlatformShellCommand, (const char *),
                           shell_command);
 }
 
 SBPlatformShellCommand::SBPlatformShellCommand(
     const SBPlatformShellCommand &rhs)
if (!command)
       return Status("invalid shell command (empty)");
 
     const char *working_dir = shell_command.GetWorkingDirectory();
     if (working_dir == nullptr) {
       working_dir = platform_sp->GetWorkingDirectory().GetCString();
       if (working_dir)
         shell_command.SetWorkingDirectory(working_dir);
     }
-    return platform_sp->RunShellCommand(command, FileSpec(working_dir),
-                                        &shell_command.m_opaque_ptr->m_status,
-                                        &shell_command.m_opaque_ptr->m_signo,
-                                        &shell_command.m_opaque_ptr->m_output,
-                                        shell_command.m_opaque_ptr->m_timeout);
+    return platform_sp->RunShellCommand(
+        command, FileSpec(working_dir), &shell_command.m_opaque_ptr->m_status,
+        shell_command.m_opaque_ptr->m_timeout,
+        shell_command.m_opaque_ptr->m_run_in_default_shell);
   }));
 }
 
 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Launch, (lldb::SBLaunchInfo &),
                      launch_info);
   return LLDB_RECORD_RESULT(
       ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {

lldb/source/Commands/CommandObjectPlatform.cpp

Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
         uint32_t timeout_sec;
         if (option_arg.getAsInteger(10, timeout_sec))
           error.SetErrorStringWithFormat(
               "could not convert \"%s\" to a numeric value.",
               option_arg.str().c_str());
         else
           m_timeout = std::chrono::seconds(timeout_sec);
         break;
+      case 'i': {
+        if (option_arg.empty()) {
+          error.SetErrorStringWithFormat(
+              "missing shell interpreter path for option -i|--interpreter.");
+          return error;
+        }
+
+        if (!FileSystem::Instance().Exists(option_arg)) {
+          error.SetErrorStringWithFormat("File \"%s\" doesn't exist.",
+                                         option_arg.str().c_str());
+          return error;
+        }
+
+        if (!FileSystem::Instance().Readable(option_arg)) {
+          error.SetErrorStringWithFormat("File \"%s\" is not readable.",
+                                         option_arg.str().c_str());
+          return error;
+        }
+
+        m_shell_interpreter.SetFile(option_arg, FileSpec::Style::native);
+
+        break;
+      }
       default:
         llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_timeout.reset();
       m_use_host_platform = false;
+      m_shell_interpreter.Clear();
     }
 
     Timeout<std::micro> m_timeout = std::chrono::seconds(10);
     bool m_use_host_platform;
+    FileSpec m_shell_interpreter;
   };
 
   CommandObjectPlatformShell(CommandInterpreter &interpreter)
       : CommandObjectRaw(interpreter, "platform shell",
                          "Run a shell command on the current platform.",
                          "platform shell <shell-command>", 0),
         m_options() {}
 
bool DoExecute(llvm::StringRef raw_command_line,
     // Print out an usage syntax on an empty command line.
     if (raw_command_line.empty()) {
       result.GetOutputStream().Printf("%s\n", this->GetSyntax().str().c_str());
       return true;
     }
 
     const bool is_alias = !raw_command_line.contains("platform");
     OptionsWithRaw args(raw_command_line);
-    const char *expr = args.GetRawPart().c_str();
 
     if (args.HasArgs())
       if (!ParseOptions(args.GetArgs(), result))
         return false;
 
     if (args.GetRawPart().empty()) {
       result.GetOutputStream().Printf("%s <shell-command>\n",
                                       is_alias ? "shell" : "platform shell");
       return false;
     }
 
+    std::string expr;
+    bool use_default_shell = true;
+    if (m_options.m_shell_interpreter) {
+      expr += m_options.m_shell_interpreter.GetPath() + " -c ";
+      use_default_shell = false;
+    }
+    expr += args.GetRawPart();
+
     PlatformSP platform_sp(
         m_options.m_use_host_platform
             ? Platform::GetHostPlatform()
             : GetDebugger().GetPlatformList().GetSelectedPlatform());
     Status error;
     if (platform_sp) {
       FileSpec working_dir{};
       std::string output;
       int status = -1;
       int signo = -1;
-      error = (platform_sp->RunShellCommand(expr, working_dir, &status, &signo,
-                                            &output, m_options.m_timeout));
+      error = (platform_sp->RunShellCommand(
+          expr.c_str(), working_dir, &status, &signo, &output,
+          m_options.m_timeout, use_default_shell));
       if (!output.empty())
         result.GetOutputStream().PutCString(output);
       if (status > 0) {
         if (signo > 0) {
           const char *signo_cstr = Host::GetSignalAsCString(signo);
           if (signo_cstr)
             result.GetOutputStream().Printf(
                 "error: command returned with status %i and signal %s\n",

lldb/source/Commands/Options.td

def platform_process_attach_waitfor : Option<"waitfor", "w">, Group<2>,
     Desc<"Wait for the process with <process-name> to launch.">;
 }
 
 let Command = "platform shell" in {
   def platform_shell_host : Option<"host", "h">,
     Desc<"Run the commands on the host shell when enabled.">;
   def platform_shell_timeout : Option<"timeout", "t">, Arg<"Value">,
     Desc<"Seconds to wait for the remote host to finish running the command.">;
+  def platform_shell_interpreter : Option<"interpreter", "i">, Arg<"Path">,
+    Desc<"Shell interpreter path. This is the binary used to run the command.">;
 }
 
 let Command = "process attach" in {
   def process_attach_continue : Option<"continue", "c">,
     Desc<"Immediately continue the process once attached.">;
   def process_attach_plugin : Option<"plugin", "P">, Arg<"Plugin">,
     Desc<"Name of the process plugin you want to use.">;
   def process_attach_pid : Option<"pid", "p">, Group<1>, Arg<"Pid">,

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h

 //===-- PlatformRemoteGDBServer.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_SOURCE_PLUGINS_PLATFORM_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_GDB_SERVER_PLATFORMREMOTEGDBSERVER_H
 
 #include <string>
 
 #include "Plugins/Process/Utility/GDBRemoteSignals.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationReplayServer.h"
 #include "lldb/Target/Platform.h"
 
 namespace lldb_private {
 namespace platform_gdb_server {
 
 class PlatformRemoteGDBServer : public Platform, private UserIDResolver {
Status RunShellCommand(
       const char *command,         // Shouldn't be NULL
       const FileSpec &working_dir, // Pass empty FileSpec to use the current
                                    // working directory
       int *status_ptr, // Pass NULL if you don't want the process exit status
       int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                        // process to exit
       std::string
           *command_output, // Pass NULL if you don't want the command output
-      const lldb_private::Timeout<std::micro> &timeout) override;
+      const lldb_private::Timeout<std::micro> &timeout,
+      const bool run_in_default_shell = true) override;
 
   void CalculateTrapHandlerSymbolNames() override;
 
   const lldb::UnixSignalsSP &GetRemoteUnixSignals() override;
 
   lldb::ProcessSP ConnectProcess(llvm::StringRef connect_url,
                                  llvm::StringRef plugin_name,
                                  lldb_private::Debugger &debugger,

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Status PlatformRemoteGDBServer::RunShellCommand(
     const char *command, // Shouldn't be NULL
     const FileSpec &
         working_dir, // Pass empty FileSpec to use the current working directory
     int *status_ptr, // Pass NULL if you don't want the process exit status
     int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                      // process to exit
     std::string
         *command_output, // Pass NULL if you don't want the command output
-    const Timeout<std::micro> &timeout) {
+    const Timeout<std::micro> &timeout, const bool run_in_default_shell) {
   return m_gdb_client.RunShellCommand(command, working_dir, status_ptr,
-                                      signo_ptr, command_output, timeout);
+                                      signo_ptr, command_output, timeout,
+                                      run_in_default_shell);
 }
 
 void PlatformRemoteGDBServer::CalculateTrapHandlerSymbolNames() {
   m_trap_handlers.push_back(ConstString("_sigtramp"));
 }
 
 const UnixSignalsSP &PlatformRemoteGDBServer::GetRemoteUnixSignals() {
   if (!IsConnected())

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

Status RunShellCommand(
       const char *command,         // Shouldn't be nullptr
       const FileSpec &working_dir, // Pass empty FileSpec to use the current
                                    // working directory
       int *status_ptr, // Pass nullptr if you don't want the process exit status
       int *signo_ptr,  // Pass nullptr if you don't want the signal that caused
                        // the process to exit
       std::string
           *command_output, // Pass nullptr if you don't want the command output
-      const Timeout<std::micro> &timeout);
+      const Timeout<std::micro> &timeout,
+      const bool run_in_default_shell = true);
 
   bool CalculateMD5(const FileSpec &file_spec, uint64_t &high, uint64_t &low);
 
   lldb::DataBufferSP ReadRegister(
       lldb::tid_t tid,
       uint32_t
           reg_num); // Must be the eRegisterKindProcessPlugin register number
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

lldb::addr_t GDBRemoteCommunicationClient::GetShlibInfoAddr() {
   if (SendPacketAndWaitForResponse("qShlibInfoAddr", response, false) !=
           PacketResult::Success ||
       !response.IsNormalResponse())
     return LLDB_INVALID_ADDRESS;
   return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
 }
 
 lldb_private::Status GDBRemoteCommunicationClient::RunShellCommand(
     const char *command, // Shouldn't be NULL
     const FileSpec &
         working_dir, // Pass empty FileSpec to use the current working directory
     int *status_ptr, // Pass NULL if you don't want the process exit status
     int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
                      // process to exit
     std::string
         *command_output, // Pass NULL if you don't want the command output
-    const Timeout<std::micro> &timeout) {
+    const Timeout<std::micro> &timeout, const bool run_in_default_shell) {
   lldb_private::StreamString stream;
   stream.PutCString("qPlatform_shell:");
   stream.PutBytesAsRawHex8(command, strlen(command));
   stream.PutChar(',');
   uint32_t timeout_sec = UINT32_MAX;
   if (timeout) {
     // TODO: Use chrono version of std::ceil once c++17 is available.
     timeout_sec = std::ceil(std::chrono::duration<double>(*timeout).count());
   }
   stream.PutHex32(timeout_sec);
   if (working_dir) {

lldb/source/Target/Platform.cpp

 //===-- Platform.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 <algorithm>
 #include <csignal>
 #include <fstream>
 #include <memory>
 #include <vector>
 
 #include "lldb/Breakpoint/BreakpointIDList.h"
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
lldb_private::Status Platform::RunShellCommand(
     const char *command, // Shouldn't be nullptr
     const FileSpec &
         working_dir, // Pass empty FileSpec to use the current working directory
     int *status_ptr, // Pass nullptr if you don't want the process exit status
     int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
                     // process to exit
     std::string
         *command_output, // Pass nullptr if you don't want the command output
-    const Timeout<std::micro> &timeout) {
+    const Timeout<std::micro> &timeout, const bool run_in_default_shell) {
   if (IsHost())
     return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
-                                 command_output, timeout);
+                                 command_output, timeout, run_in_default_shell);
   else
     return Status("unimplemented");
 }
 
 bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
                             uint64_t &high) {
   if (!IsHost())
     return false;

lldb/source/Target/RemoteAwarePlatform.cpp

 //===-- RemoteAwarePlatform.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 "lldb/Target/RemoteAwarePlatform.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileCache.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Utility/StreamString.h"
// it another try.
         }
       }
     }
   }
 
   return error;
 }
 
-Status RemoteAwarePlatform::RunShellCommand(
-    const char *command, const FileSpec &working_dir, int *status_ptr,
-    int *signo_ptr, std::string *command_output,
-    const Timeout<std::micro> &timeout) {
+Status RemoteAwarePlatform::RunShellCommand(const char *command,
+                                            const FileSpec &working_dir,
+                                            int *status_ptr, int *signo_ptr,
+                                            std::string *command_output,
+                                            const Timeout<std::micro> &timeout,
+                                            const bool run_in_default_shell) {
   if (IsHost())
     return Host::RunShellCommand(command, working_dir, status_ptr, signo_ptr,
-                                 command_output, timeout);
+                                 command_output, timeout, run_in_default_shell);
   if (m_remote_platform_sp)
     return m_remote_platform_sp->RunShellCommand(
-        command, working_dir, status_ptr, signo_ptr, command_output, timeout);
+        command, working_dir, status_ptr, signo_ptr, command_output, timeout,
+        run_in_default_shell);
   return Status("unable to run a remote command without a platform");
 }
 
 Status RemoteAwarePlatform::MakeDirectory(const FileSpec &file_spec,
                                           uint32_t file_permissions) {
   if (m_remote_platform_sp)
     return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
   return Platform::MakeDirectory(file_spec, file_permissions);

lldb/test/API/commands/platform/basic/TestPlatformCommand.py

class PlatformCommandTestCase(TestBase):
     @no_debug_info_test
     def test_shell_timeout(self):
         """ Test a shell built-in command (sleep) that times out """
         self.skipTest("Alias with option not supported by the command interpreter.")
         self.expect("platform shell -t 1 -- sleep 15", error=True, substrs=[
                     "error: timed out waiting for shell command to complete"])
         self.expect("shell -t 1 --  sleep 3", error=True, substrs=[
                     "error: timed out waiting for shell command to complete"])
+
+    @expectedFailureAll(oslist=["windows"])
+    @no_debug_info_test
+    def test_shell_interpreter(self):
+        """ Test a shell with a different interpreter """
+        platform = self.dbg.GetSelectedPlatform()
+        self.assertTrue(platform.IsValid())
+
+        sh_cmd = lldb.SBPlatformShellCommand('/bin/sh', 'echo $0')
+        self.assertIn('/bin/sh', sh_cmd.GetCommand())
+        self.assertIn('echo $0', sh_cmd.GetCommand())
+
+        err = platform.Run(sh_cmd)
+        self.assertTrue(err.Success())
+        self.assertIn("/bin/sh", sh_cmd.GetOutput())
+
+    @expectedFailureAll(oslist=["windows"])
+    @no_debug_info_test
+    def test_host_shell_interpreter(self):
+        """ Test the host platform shell with a different interpreter """
+        self.expect("platform shell -h -i /bin/sh -- 'echo $0'", substrs=['/bin/sh'])