[LLDB][Android] Add platform options

[splhack]

Summary

This is an alternative approach to 'Fix Android serial number handling' https://reviews.llvm.org/D138164 .

As I pointed out in https://reviews.llvm.org/D138164, the platform connect URL does not work to specify TCP/IP-connected Android device.

This diff allows users to use platform connect options in order to specify Android device serial, ADB server port, platform local TCP port, and/or GDB local TCP port.

This is the example to use a TCP/IP-connected Android device with serial [::1]:5556.

(lldb) platform select remote-android
(lldb) platform connect --android-serial [::1]:5556 unix-abstract-connect:///data/local/tmp/debug.sock

help

(lldb) platform select remote-android
  Platform: remote-android
 Connected: no
(lldb) help platform connect
Select the current platform by providing a connection URL.

Syntax: platform connect <connect-url>

Command Options Usage:
  platform connect [-s <cmd-name>] [-p <cmd-name>] [-l <cmd-name>] [-g <cmd-name>] <process-connect-url>

       -g <cmd-name> ( --gdb-local-port <cmd-name> )
            Local TCP port for GDB port forwarding (overrides $ANDROID_PLATFORM_LOCAL_GDB_PORT.)

       -l <cmd-name> ( --platform-local-port <cmd-name> )
            Local TCP port for the platform port forwarding (overrides
            $ANDROID_PLATFORM_LOCAL_PORT.)

       -p <cmd-name> ( --adb-server-port <cmd-name> )
            Local server port to connect ADB (overrides $ANDROID_ADB_SERVER_PORT.)

       -s <cmd-name> ( --android-serial <cmd-name> )
            Android device serial for ADB to use (overrides $ANDROID_SERIAL.)

     This command takes options and free-form arguments.  If your arguments resemble option
     specifiers (i.e., they start with a - or --), you must use ' -- ' between the end of the
     command options and the beginning of the arguments.

[splhack]

.

lldb/include/lldb/Target/Platform.h

 //===-- Platform.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
 //
 //===----------------------------------------------------------------------===//
 
public:
   std::string m_ssh_opts;
 
 private:
   OptionGroupPlatformSSH(const OptionGroupPlatformSSH &) = delete;
   const OptionGroupPlatformSSH &
   operator=(const OptionGroupPlatformSSH &) = delete;
 };
 
+class OptionGroupPlatformAndroid : public lldb_private::OptionGroup {
+public:
+  OptionGroupPlatformAndroid() = default;
+
+  ~OptionGroupPlatformAndroid() override = default;
+
+  lldb_private::Status
+  SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
+                 ExecutionContext *execution_context) override;
+
+  void OptionParsingStarting(ExecutionContext *execution_context) override;
+
+  llvm::ArrayRef<OptionDefinition> GetDefinitions() override;
+
+  // Instance variables to hold the values for command options.
+
+  std::string m_android_serial;
+  std::string m_adb_server_port;
+  std::string m_platform_local_port;
+  std::string m_gdb_local_port;
+
+private:
+  OptionGroupPlatformAndroid(const OptionGroupPlatformAndroid &) = delete;
+  const OptionGroupPlatformAndroid &
+  operator=(const OptionGroupPlatformAndroid &) = delete;
+};
+
 class OptionGroupPlatformCaching : public lldb_private::OptionGroup {
 public:
   OptionGroupPlatformCaching() = default;
 
   ~OptionGroupPlatformCaching() override = default;
 
   lldb_private::Status
   SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,

lldb/source/Plugins/Platform/Android/AdbClient.h

 //===-- AdbClient.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
 //
 //===----------------------------------------------------------------------===//
 
private:
     Status internalStat(const FileSpec &remote_file, uint32_t &mode,
                         uint32_t &size, uint32_t &mtime);
 
     Status executeCommand(const std::function<Status()> &cmd);
 
     std::unique_ptr<Connection> m_conn;
   };
 
-  static Status CreateByDeviceID(const std::string &device_id, AdbClient &adb);
+  static Status CreateByDeviceID(const std::string &device_id,
+                                 const std::string &server_port,
+                                 AdbClient &adb);
 
   AdbClient();
-  explicit AdbClient(const std::string &device_id);
+  explicit AdbClient(const std::string &device_id,
+                     const std::string &server_port);
 
   ~AdbClient();
 
   const std::string &GetDeviceID() const;
 
+  const std::string &GetServerPort() const;
+
   Status GetDevices(DeviceIDList &device_list);
 
+  Status GetSerialNo(std::string *output);
+
   Status SetPortForwarding(const uint16_t local_port,
                            const uint16_t remote_port);
 
   Status SetPortForwarding(const uint16_t local_port,
                            llvm::StringRef remote_socket_name,
                            const UnixSocketNamespace socket_namespace);
 
   Status DeletePortForwarding(const uint16_t local_port);
 
   Status Shell(const char *command, std::chrono::milliseconds timeout,
                std::string *output);
 
   Status ShellToFile(const char *command, std::chrono::milliseconds timeout,
                      const FileSpec &output_file_spec);
 
   std::unique_ptr<SyncService> GetSyncService(Status &error);
 
   Status SwitchDeviceTransport();
 
 private:
   Status Connect();
 
   void SetDeviceID(const std::string &device_id);
 
+  void SetServerPort(const std::string &server_port);
+
   Status SendMessage(const std::string &packet, const bool reconnect = true);
 
   Status SendDeviceMessage(const std::string &packet);
 
   Status ReadMessage(std::vector<char> &message);
 
   Status ReadMessageStream(std::vector<char> &message,
                            std::chrono::milliseconds timeout);
 
   Status GetResponseError(const char *response_id);
 
   Status ReadResponseStatus();
 
   Status Sync();
 
   Status StartSync();
 
   Status internalShell(const char *command, std::chrono::milliseconds timeout,
                        std::vector<char> &output_buf);
 
   Status ReadAllBytes(void *buffer, size_t size);
 
   std::string m_device_id;
+  std::string m_server_port;
   std::unique_ptr<Connection> m_conn;
 };
 
 } // namespace platform_android
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_ANDROID_ADBCLIENT_H

lldb/source/Plugins/Platform/Android/AdbClient.cpp

 //===-- AdbClient.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
 //
 //===----------------------------------------------------------------------===//
 
static Status ReadAllBytes(Connection &conn, void *buffer, size_t size) {
   if (total_read_bytes < size)
     error = Status(
         "Unable to read requested number of bytes. Connection status: %d.",
         status);
   return error;
 }
 
 Status AdbClient::CreateByDeviceID(const std::string &device_id,
+                                   const std::string &server_port,
                                    AdbClient &adb) {
   Status error;
+  std::string port = "5037";
+  if (!server_port.empty())
+    port = server_port;
+  else if (const char *env_port = std::getenv("ANDROID_ADB_SERVER_PORT"))
+    port = env_port;
+  adb.SetServerPort(port);
+
   std::string android_serial;
   if (!device_id.empty())
     android_serial = device_id;
   else if (const char *env_serial = std::getenv("ANDROID_SERIAL"))
     android_serial = env_serial;
 
   if (android_serial.empty()) {
     DeviceIDList connected_devices;
     error = adb.GetDevices(connected_devices);
     if (error.Fail())
       return error;
 
     if (connected_devices.size() != 1)
       return Status("Expected a single connected device, got instead %zu - try "
-                    "setting 'ANDROID_SERIAL'",
+                    "using --android-serial or setting 'ANDROID_SERIAL'",
                     connected_devices.size());
     adb.SetDeviceID(connected_devices.front());
   } else {
     adb.SetDeviceID(android_serial);
   }
   return error;
 }
 
 AdbClient::AdbClient() = default;
 
-AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {}
+AdbClient::AdbClient(const std::string &device_id,
+                     const std::string &server_port)
+    : m_device_id(device_id), m_server_port(server_port) {}
 
 AdbClient::~AdbClient() = default;
 
 void AdbClient::SetDeviceID(const std::string &device_id) {
   m_device_id = device_id;
 }
 
+void AdbClient::SetServerPort(const std::string &server_port) {
+  m_server_port = server_port;
+}
+
 const std::string &AdbClient::GetDeviceID() const { return m_device_id; }
 
+const std::string &AdbClient::GetServerPort() const { return m_server_port; }
+
 Status AdbClient::Connect() {
   Status error;
   m_conn = std::make_unique<ConnectionFileDescriptor>();
-  std::string port = "5037";
-  if (const char *env_port = std::getenv("ANDROID_ADB_SERVER_PORT")) {
-    port = env_port;
-  }
-  std::string uri = "connect://127.0.0.1:" + port;
+  std::string uri = "connect://127.0.0.1:" + m_server_port;
   m_conn->Connect(uri.c_str(), &error);
 
   return error;
 }
 
 Status AdbClient::GetDevices(DeviceIDList &device_list) {
   device_list.clear();
 
for (const auto &device : devices)
     device_list.push_back(std::string(device.split('\t').first));
 
   // Force disconnect since ADB closes connection after host:devices response
   // is sent.
   m_conn.reset();
   return error;
 }
 
+Status AdbClient::GetSerialNo(std::string *output) {
+  const char *message = "get-serialno";
+  auto error = SendDeviceMessage(message);
+  if (error.Fail())
+    return error;
+
+  error = ReadResponseStatus();
+  if (error.Fail())
+    return error;
+
+  std::vector<char> output_buffer;
+  error = ReadMessage(output_buffer);
+  if (error.Success() && output)
+    output->assign(output_buffer.begin(), output_buffer.end());
+
+  return error;
+}
+
 Status AdbClient::SetPortForwarding(const uint16_t local_port,
                                     const uint16_t remote_port) {
   char message[48];
   snprintf(message, sizeof(message), "forward:tcp:%d;tcp:%d", local_port,
            remote_port);
 
   const auto error = SendDeviceMessage(message);
   if (error.Fail())

lldb/source/Plugins/Platform/Android/PlatformAndroid.h

 //===-- PlatformAndroid.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_ANDROID_PLATFORMANDROID_H
 #define LLDB_SOURCE_PLUGINS_PLATFORM_ANDROID_PLATFORMANDROID_H
 
 #include <memory>
 #include <string>
 
 #include "Plugins/Platform/Linux/PlatformLinux.h"
+#include "lldb/Interpreter/Options.h"
 
 #include "AdbClient.h"
 
 namespace lldb_private {
 namespace platform_android {
 
 class PlatformAndroid : public platform_linux::PlatformLinux {
 public:
public:
   static llvm::StringRef GetPluginDescriptionStatic(bool is_host);
 
   llvm::StringRef GetPluginName() override {
     return GetPluginNameStatic(IsHost());
   }
 
   // lldb_private::Platform functions
 
+  lldb_private::OptionGroupOptions *
+  GetConnectionOptions(lldb_private::CommandInterpreter &interpreter) override;
+
   Status ConnectRemote(Args &args) override;
 
   Status GetFile(const FileSpec &source, const FileSpec &destination) override;
 
   Status PutFile(const FileSpec &source, const FileSpec &destination,
                  uint32_t uid = UINT32_MAX, uint32_t gid = UINT32_MAX) override;
 
   uint32_t GetSdkVersion();
protected:
 
   Status DownloadSymbolFile(const lldb::ModuleSP &module_sp,
                             const FileSpec &dst_file_spec) override;
 
   llvm::StringRef
   GetLibdlFunctionDeclarations(lldb_private::Process *process) override;
 
 private:
+  std::unique_ptr<lldb_private::OptionGroupPlatformAndroid>
+      m_option_group_platform_android;
+
   AdbClient::SyncService *GetSyncService(Status &error);
 
   std::unique_ptr<AdbClient::SyncService> m_adb_sync_svc;
   std::string m_device_id;
+  std::string m_adb_server_port;
   uint32_t m_sdk_version;
 };
 
-} // namespace platofor_android
+} // namespace platform_android
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PLATFORM_ANDROID_PLATFORMANDROID_H

lldb/source/Plugins/Platform/Android/PlatformAndroid.cpp

 //===-- PlatformAndroid.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
 //
 //===----------------------------------------------------------------------===//
 
#endif
   LLDB_LOGF(
       log, "PlatformAndroid::%s() aborting creation of remote-android platform",
       __FUNCTION__);
 
   return PlatformSP();
 }
 
 PlatformAndroid::PlatformAndroid(bool is_host)
-    : PlatformLinux(is_host), m_sdk_version(0) {}
+    : PlatformLinux(is_host),
+      m_option_group_platform_android(new OptionGroupPlatformAndroid()),
+      m_sdk_version(0) {}
+
+lldb_private::OptionGroupOptions *PlatformAndroid::GetConnectionOptions(
+    lldb_private::CommandInterpreter &interpreter) {
+  auto iter = m_options.find(&interpreter), end = m_options.end();
+  if (iter == end) {
+    std::unique_ptr<lldb_private::OptionGroupOptions> options(
+        new OptionGroupOptions());
+    options->Append(m_option_group_platform_android.get());
+    m_options[&interpreter] = std::move(options);
+  }
+
+  return m_options.at(&interpreter).get();
+}
 
 llvm::StringRef PlatformAndroid::GetPluginDescriptionStatic(bool is_host) {
   if (is_host)
     return "Local Android user platform plug-in.";
   return "Remote Android user platform plug-in.";
 }
 
 Status PlatformAndroid::ConnectRemote(Args &args) {
   m_device_id.clear();
+  m_adb_server_port.clear();
 
   if (IsHost())
     return Status("can't connect to the host platform, always connected");
 
-  if (!m_remote_platform_sp)
-    m_remote_platform_sp = PlatformSP(new PlatformAndroidRemoteGDBServer());
-
   const char *url = args.GetArgumentAtIndex(0);
   if (!url)
     return Status("URL is null.");
   llvm::Optional<URI> parsed_url = URI::Parse(url);
   if (!parsed_url)
     return Status("Invalid URL: %s", url);
   if (parsed_url->hostname != "localhost")
     m_device_id = parsed_url->hostname.str();
 
-  auto error = PlatformLinux::ConnectRemote(args);
-  if (error.Success()) {
-    AdbClient adb;
-    error = AdbClient::CreateByDeviceID(m_device_id, adb);
-    if (error.Fail())
-      return error;
+  std::string platform_local_port;
+  std::string gdb_local_port;
+  const auto &option = m_option_group_platform_android.get();
+  if (option) {
+    if (!option->m_android_serial.empty())
+      m_device_id = option->m_android_serial;
+    if (!option->m_adb_server_port.empty())
+      m_adb_server_port = option->m_adb_server_port;
+    if (!option->m_platform_local_port.empty())
+      platform_local_port = option->m_platform_local_port;
+    if (!option->m_gdb_local_port.empty())
+      gdb_local_port = option->m_gdb_local_port;
+  }
+
+  auto error = AdbClient::CreateByDeviceID(m_device_id, m_adb_server_port, adb);
 
-    m_device_id = adb.GetDeviceID();
-  }
+  std::string serial;
+  error = adb.GetSerialNo(&serial);
+  if (error.Fail())
     return error;
+
+  Log *log = GetLog(LLDBLog::Platform);
+  LLDB_LOGF(log, "PlatformAndroid::%s() connected to '%s'", __FUNCTION__,
+            serial.c_str());
+
+  m_device_id = adb.GetDeviceID();
+  m_adb_server_port = adb.GetServerPort();
+
+  if (!m_remote_platform_sp)
+    m_remote_platform_sp = PlatformSP(new PlatformAndroidRemoteGDBServer(
+        m_device_id, m_adb_server_port, platform_local_port, gdb_local_port));
+
+  return PlatformLinux::ConnectRemote(args);
 }
 
 Status PlatformAndroid::GetFile(const FileSpec &source,
                                 const FileSpec &destination) {
   if (IsHost() || !m_remote_platform_sp)
     return PlatformLinux::GetFile(source, destination);
 
   FileSpec source_spec(source.GetPath(false), FileSpec::Style::posix);
Status PlatformAndroid::GetFile(const FileSpec &source,
   LLDB_LOGF(log, "Got mode == 0 on '%s': try to get file via 'shell cat'",
             source_file.c_str());
 
   if (strchr(source_file.c_str(), '\'') != nullptr)
     return Status("Doesn't support single-quotes in filenames");
 
   // mode == 0 can signify that adbd cannot access the file due security
   // constraints - try "cat ..." as a fallback.
-  AdbClient adb(m_device_id);
+  AdbClient adb(m_device_id, m_adb_server_port);
 
   char cmd[PATH_MAX];
   snprintf(cmd, sizeof(cmd), "cat '%s'", source_file.c_str());
 
   return adb.ShellToFile(cmd, minutes(1), destination);
 }
 
 Status PlatformAndroid::PutFile(const FileSpec &source,

 uint32_t PlatformAndroid::GetSdkVersion() {
   if (!IsConnected())
     return 0;
 
   if (m_sdk_version != 0)
     return m_sdk_version;
 
   std::string version_string;
-  AdbClient adb(m_device_id);
+  AdbClient adb(m_device_id, m_adb_server_port);
   Status error =
       adb.Shell("getprop ro.build.version.sdk", seconds(5), &version_string);
   version_string = llvm::StringRef(version_string).trim().str();
 
   if (error.Fail() || version_string.empty()) {
     Log *log = GetLog(LLDBLog::Platform);
     LLDB_LOGF(log, "Get SDK version failed. (error: %s, output: %s)",
               error.AsCString(), version_string.c_str());
Status PlatformAndroid::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
   if (GetSdkVersion() < 23)
     return Status("Symbol file generation only supported on SDK 23+");
 
   // If we already have symtab then we don't have to try and generate one
   if (module_sp->GetSectionList()->FindSectionByName(ConstString(".symtab")) !=
       nullptr)
     return Status("Symtab already available in the module");
 
-  AdbClient adb(m_device_id);
+  AdbClient adb(m_device_id, m_adb_server_port);
   std::string tmpdir;
   Status error = adb.Shell("mktemp --directory --tmpdir /data/local/tmp",
                            seconds(5), &tmpdir);
   if (error.Fail() || tmpdir.empty())
     return Status("Failed to generate temporary directory on the device (%s)",
                   error.AsCString());
   tmpdir = llvm::StringRef(tmpdir).trim().str();
 
PlatformAndroid::GetLibdlFunctionDeclarations(lldb_private::Process *process) {
 
   return PlatformPOSIX::GetLibdlFunctionDeclarations(process);
 }
 
 AdbClient::SyncService *PlatformAndroid::GetSyncService(Status &error) {
   if (m_adb_sync_svc && m_adb_sync_svc->IsConnected())
     return m_adb_sync_svc.get();
 
-  AdbClient adb(m_device_id);
+  AdbClient adb(m_device_id, m_adb_server_port);
   m_adb_sync_svc = adb.GetSyncService(error);
   return (error.Success()) ? m_adb_sync_svc.get() : nullptr;
 }

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h

 //===-- PlatformAndroidRemoteGDBServer.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
 //
 //===----------------------------------------------------------------------===//
 

 #include "AdbClient.h"
 
 namespace lldb_private {
 namespace platform_android {
 
 class PlatformAndroidRemoteGDBServer
     : public platform_gdb_server::PlatformRemoteGDBServer {
 public:
-  PlatformAndroidRemoteGDBServer() = default;
+  PlatformAndroidRemoteGDBServer() = delete;
+  explicit PlatformAndroidRemoteGDBServer(const std::string &device_id,
+                                          const std::string &adb_server_port,
+                                          const std::string &platform_local_port,
+                                          const std::string &gdb_local_port);
 
   ~PlatformAndroidRemoteGDBServer() override;
 
   Status ConnectRemote(Args &args) override;
 
   Status DisconnectRemote() override;
 
   lldb::ProcessSP ConnectProcess(llvm::StringRef connect_url,
                                  llvm::StringRef plugin_name,
                                  lldb_private::Debugger &debugger,
                                  lldb_private::Target *target,
                                  lldb_private::Status &error) override;
 
 protected:
   std::string m_device_id;
+  std::string m_adb_server_port;
+  std::string m_platform_local_port;
+  std::string m_gdb_local_port;
   std::map<lldb::pid_t, uint16_t> m_port_forwards;
   llvm::Optional<AdbClient::UnixSocketNamespace> m_socket_namespace;
 
   bool LaunchGDBServer(lldb::pid_t &pid, std::string &connect_url) override;
 
+  uint16_t GetPlatformLocalPort();
+
+  uint16_t GetGDBLocalPort();
+
   bool KillSpawnedProcess(lldb::pid_t pid) override;
 
   void DeleteForwardPort(lldb::pid_t pid);
 
   Status MakeConnectURL(const lldb::pid_t pid, const uint16_t local_port,
                         const uint16_t remote_port,
                         llvm::StringRef remote_socket_name,
                         std::string &connect_url);

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

 //===-- PlatformAndroidRemoteGDBServer.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
 //
 //===----------------------------------------------------------------------===//
 

 
 static const lldb::pid_t g_remote_platform_pid =
     0; // Alias for the process id of lldb-platform
 
 static Status ForwardPortWithAdb(
     const uint16_t local_port, const uint16_t remote_port,
     llvm::StringRef remote_socket_name,
     const llvm::Optional<AdbClient::UnixSocketNamespace> &socket_namespace,
-    std::string &device_id) {
+    const std::string &device_id, const std::string &adb_server_port) {
   Log *log = GetLog(LLDBLog::Platform);
 
-  AdbClient adb;
-  auto error = AdbClient::CreateByDeviceID(device_id, adb);
-  if (error.Fail())
-    return error;
-
-  device_id = adb.GetDeviceID();
+  AdbClient adb(device_id, adb_server_port);
   LLDB_LOGF(log, "Connected to Android device \"%s\"", device_id.c_str());
 
   if (remote_port != 0) {
     LLDB_LOGF(log, "Forwarding remote TCP port %d to local TCP port %d",
               remote_port, local_port);
     return adb.SetPortForwarding(local_port, remote_port);
   }
 
   LLDB_LOGF(log, "Forwarding remote socket \"%s\" to local TCP port %d",
             remote_socket_name.str().c_str(), local_port);
 
   if (!socket_namespace)
     return Status("Invalid socket namespace");
 
   return adb.SetPortForwarding(local_port, remote_socket_name,
                                *socket_namespace);
 }
 
 static Status DeleteForwardPortWithAdb(uint16_t local_port,
-                                       const std::string &device_id) {
-  AdbClient adb(device_id);
+                                       const std::string &device_id,
+                                       const std::string &adb_server_port) {
+  AdbClient adb(device_id, adb_server_port);
   return adb.DeletePortForwarding(local_port);
 }
 
 static Status FindUnusedPort(uint16_t &port) {
   Status error;
   std::unique_ptr<TCPSocket> tcp_socket(new TCPSocket(true, false));
   if (error.Fail())
     return error;
 
   error = tcp_socket->Listen("127.0.0.1:0", 1);
   if (error.Success())
     port = tcp_socket->GetLocalPortNumber();
 
   return error;
 }
 
+PlatformAndroidRemoteGDBServer::PlatformAndroidRemoteGDBServer(
+    const std::string &device_id, const std::string &adb_server_port,
+    const std::string &platform_local_port, const std::string &gdb_local_port)
+    : m_device_id(device_id), m_adb_server_port(adb_server_port),
+      m_platform_local_port(platform_local_port),
+      m_gdb_local_port(gdb_local_port) {}
+
 PlatformAndroidRemoteGDBServer::~PlatformAndroidRemoteGDBServer() {
   for (const auto &it : m_port_forwards)
-    DeleteForwardPortWithAdb(it.second, m_device_id);
+    DeleteForwardPortWithAdb(it.second, m_device_id, m_adb_server_port);
 }
 
 bool PlatformAndroidRemoteGDBServer::LaunchGDBServer(lldb::pid_t &pid,
                                                      std::string &connect_url) {
   assert(IsConnected());
   uint16_t remote_port = 0;
   std::string socket_name;
   if (!m_gdb_client_up->LaunchGDBServer("127.0.0.1", pid, remote_port,
                                         socket_name))
     return false;
 
   Log *log = GetLog(LLDBLog::Platform);
 
-  uint16_t local_port = 0;
-  const char *gdbstub_port = std::getenv("ANDROID_PLATFORM_LOCAL_GDB_PORT");
-  if (gdbstub_port)
-    local_port = std::stoi(gdbstub_port);
+  uint16_t local_port = GetGDBLocalPort();
 
   auto error = MakeConnectURL(pid, local_port, remote_port, socket_name.c_str(),
                               connect_url);
   if (error.Success() && log)
     LLDB_LOGF(log, "gdbserver connect URL: %s", connect_url.c_str());
 
   return error.Success();
 }
 
+uint16_t PlatformAndroidRemoteGDBServer::GetGDBLocalPort() {
+  if (!m_gdb_local_port.empty()) {
+    return std::stoi(m_gdb_local_port);
+  } else {
+    const char *gdbstub_port = std::getenv("ANDROID_PLATFORM_LOCAL_GDB_PORT");
+    if (gdbstub_port)
+      return std::stoi(gdbstub_port);
+  }
+  return 0;
+}
+
 bool PlatformAndroidRemoteGDBServer::KillSpawnedProcess(lldb::pid_t pid) {
   assert(IsConnected());
   DeleteForwardPort(pid);
   return m_gdb_client_up->KillSpawnedProcess(pid);
 }
 
 Status PlatformAndroidRemoteGDBServer::ConnectRemote(Args &args) {
-  m_device_id.clear();
-
   if (args.GetArgumentCount() != 1)
     return Status(
         "\"platform connect\" takes a single argument: <connect-url>");
 
   const char *url = args.GetArgumentAtIndex(0);
   if (!url)
     return Status("URL is null.");
   llvm::Optional<URI> parsed_url = URI::Parse(url);
   if (!parsed_url)
     return Status("Invalid URL: %s", url);
-  if (parsed_url->hostname != "localhost")
+  if (!parsed_url->hostname.empty() && parsed_url->hostname != "localhost")
     m_device_id = parsed_url->hostname.str();
 
   m_socket_namespace.reset();
   if (parsed_url->scheme == "unix-connect")
     m_socket_namespace = AdbClient::UnixSocketNamespaceFileSystem;
   else if (parsed_url->scheme == "unix-abstract-connect")
     m_socket_namespace = AdbClient::UnixSocketNamespaceAbstract;
 
-  uint16_t local_port = 0;
-  const char *platform_local_port = std::getenv("ANDROID_PLATFORM_LOCAL_PORT");
-  if (platform_local_port)
-    local_port = std::stoi(platform_local_port);
+  uint16_t local_port = GetPlatformLocalPort();
 
   std::string connect_url;
   auto error = MakeConnectURL(g_remote_platform_pid, local_port,
                               parsed_url->port.value_or(0), parsed_url->path,
                               connect_url);
 
   if (error.Fail())
     return error;
 
   args.ReplaceArgumentAtIndex(0, connect_url);
 
   Log *log = GetLog(LLDBLog::Platform);
   LLDB_LOGF(log, "Rewritten platform connect URL: %s", connect_url.c_str());
 
   error = PlatformRemoteGDBServer::ConnectRemote(args);
   if (error.Fail())
     DeleteForwardPort(g_remote_platform_pid);
 
   return error;
 }
 
+uint16_t PlatformAndroidRemoteGDBServer::GetPlatformLocalPort() {
+  if (!m_platform_local_port.empty()) {
+    return std::stoi(m_platform_local_port);
+  } else {
+    const char *platform_local_port =
+        std::getenv("ANDROID_PLATFORM_LOCAL_PORT");
+    if (platform_local_port)
+      return std::stoi(platform_local_port);
+  }
+  return 0;
+}
+
 Status PlatformAndroidRemoteGDBServer::DisconnectRemote() {
   DeleteForwardPort(g_remote_platform_pid);
   return PlatformRemoteGDBServer::DisconnectRemote();
 }
 
 void PlatformAndroidRemoteGDBServer::DeleteForwardPort(lldb::pid_t pid) {
   Log *log = GetLog(LLDBLog::Platform);
 
   auto it = m_port_forwards.find(pid);
   if (it == m_port_forwards.end())
     return;
 
   const auto port = it->second;
-  const auto error = DeleteForwardPortWithAdb(port, m_device_id);
+  const auto error =
+      DeleteForwardPortWithAdb(port, m_device_id, m_adb_server_port);
   if (error.Fail()) {
     LLDB_LOGF(log,
               "Failed to delete port forwarding (pid=%" PRIu64
               ", port=%d, device=%s): %s",
               pid, port, m_device_id.c_str(), error.AsCString());
   }
   m_port_forwards.erase(it);
 }
 
 Status PlatformAndroidRemoteGDBServer::MakeConnectURL(
     const lldb::pid_t pid, const uint16_t local_port,
     const uint16_t remote_port, llvm::StringRef remote_socket_name,
     std::string &connect_url) {
   static const int kAttempsNum = 5;
 
   Status error;
 
   auto forward = [&](const uint16_t local, const uint16_t remote) {
-    error = ForwardPortWithAdb(local, remote, remote_socket_name,
-                               m_socket_namespace, m_device_id);
+    error =
+        ForwardPortWithAdb(local, remote, remote_socket_name,
+                           m_socket_namespace, m_device_id, m_adb_server_port);
     if (error.Success()) {
       m_port_forwards[pid] = local;
       std::ostringstream url_str;
       url_str << "connect://127.0.0.1:" << local;
       connect_url = url_str.str();
     }
     return error;
   };

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
 //
 //===----------------------------------------------------------------------===//
 

 static constexpr OptionDefinition g_ssh_option_table[] = {
     {LLDB_OPT_SET_ALL, false, "ssh", 's', OptionParser::eNoArgument, nullptr,
      {}, 0, eArgTypeNone, "Enable SSH."},
     {LLDB_OPT_SET_ALL, false, "ssh-opts", 'S', OptionParser::eRequiredArgument,
      nullptr, {}, 0, eArgTypeCommandName,
      "Platform-specific options required for SSH to work."},
 };
 
+static constexpr OptionDefinition g_android_option_table[] = {
+    {LLDB_OPT_SET_ALL, false, "android-serial", 's',
+     OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
+     "Android device serial for ADB to use (overrides $ANDROID_SERIAL.)"},
+    {LLDB_OPT_SET_ALL, false, "adb-server-port", 'p',
+     OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
+     "Local server port to connect ADB (overrides $ANDROID_ADB_SERVER_PORT.)"},
+    {LLDB_OPT_SET_ALL, false, "platform-local-port", 'l',
+     OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
+     "Local TCP port for the platform port forwarding "
+     "(overrides $ANDROID_PLATFORM_LOCAL_PORT.)"},
+    {LLDB_OPT_SET_ALL, false, "gdb-local-port", 'g',
+     OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
+     "Local TCP port for GDB port forwarding "
+     "(overrides $ANDROID_PLATFORM_LOCAL_GDB_PORT.)"},
+};
+
 static constexpr OptionDefinition g_caching_option_table[] = {
     {LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c',
      OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePath,
      "Path in which to store local copies of files."},
 };
 
 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
   return llvm::makeArrayRef(g_rsync_option_table);
OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;
   }
 
   return error;
 }
 
+llvm::ArrayRef<OptionDefinition> OptionGroupPlatformAndroid::GetDefinitions() {
+  return llvm::makeArrayRef(g_android_option_table);
+}
+
+void OptionGroupPlatformAndroid::OptionParsingStarting(
+    ExecutionContext *execution_context) {
+  m_android_serial.clear();
+  m_adb_server_port.clear();
+  m_gdb_local_port.clear();
+  m_platform_local_port.clear();
+}
+
+lldb_private::Status
+OptionGroupPlatformAndroid::SetOptionValue(uint32_t option_idx,
+                                           llvm::StringRef option_arg,
+                                           ExecutionContext *execution_context) {
+  Status error;
+  char short_option = (char)GetDefinitions()[option_idx].short_option;
+  switch (short_option) {
+  case 's':
+    m_android_serial.assign(std::string(option_arg));
+    break;
+
+  case 'p':
+    m_adb_server_port.assign(std::string(option_arg));
+    break;
+
+  case 'l':
+    m_platform_local_port.assign(std::string(option_arg));
+    break;
+
+  case 'g':
+    m_gdb_local_port.assign(std::string(option_arg));
+    break;
+
+  default:
+    error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
+    break;
+  }
+
+  return error;
+}
+
 llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
   return llvm::makeArrayRef(g_caching_option_table);
 }
 
 void OptionGroupPlatformCaching::OptionParsingStarting(
     ExecutionContext *execution_context) {
   m_cache_dir.clear();
 }

lldb/unittests/Platform/Android/AdbClientTest.cpp

 //===-- AdbClientTest.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
 //
 //===----------------------------------------------------------------------===//
 

 using namespace lldb;
 using namespace lldb_private;
 
 namespace lldb_private {
 namespace platform_android {
 
 class AdbClientTest : public ::testing::Test {
 public:
-  void SetUp() override { set_env("ANDROID_SERIAL", ""); }
+  void SetUp() override {
+    set_env("ANDROID_SERIAL", "");
+    set_env("ANDROID_ADB_SERVER_PORT", "");
+  }
 
-  void TearDown() override { set_env("ANDROID_SERIAL", ""); }
+  void TearDown() override {
+    set_env("ANDROID_SERIAL", "");
+    set_env("ANDROID_ADB_SERVER_PORT", "");
+  }
 };
 
 TEST(AdbClientTest, CreateByDeviceId) {
   AdbClient adb;
-  Status error = AdbClient::CreateByDeviceID("device1", adb);
+  Status error = AdbClient::CreateByDeviceID("device1", "", adb);
   EXPECT_TRUE(error.Success());
   EXPECT_EQ("device1", adb.GetDeviceID());
+  EXPECT_EQ("5037", adb.GetServerPort());
 }
 
 TEST(AdbClientTest, CreateByDeviceId_ByEnvVar) {
   set_env("ANDROID_SERIAL", "device2");
 
   AdbClient adb;
-  Status error = AdbClient::CreateByDeviceID("", adb);
+  Status error = AdbClient::CreateByDeviceID("", "", adb);
   EXPECT_TRUE(error.Success());
   EXPECT_EQ("device2", adb.GetDeviceID());
+  EXPECT_EQ("5037", adb.GetServerPort());
+}
+
+TEST(AdbClientTest, CreateByDeviceId_WithServerPort) {
+  AdbClient adb;
+  Status error = AdbClient::CreateByDeviceID("device1", "5038", adb);
+  EXPECT_TRUE(error.Success());
+  EXPECT_EQ("device1", adb.GetDeviceID());
+  EXPECT_EQ("5038", adb.GetServerPort());
+}
+
+TEST(AdbClientTest, CreateByDeviceId_WithServerPortEnvVar) {
+  set_env("ANDROID_ADB_SERVER_PORT", "5039");
+
+  AdbClient adb;
+  Status error = AdbClient::CreateByDeviceID("device1", "", adb);
+  EXPECT_TRUE(error.Success());
+  EXPECT_EQ("device1", adb.GetDeviceID());
+  EXPECT_EQ("5039", adb.GetServerPort());
 }
 
 } // end namespace platform_android
 } // end namespace lldb_private

lldb/unittests/Platform/Android/CMakeLists.txt

 include_directories(${LLDB_SOURCE_DIR}/source/Plugins/Platform/Android)
 
-add_lldb_unittest(AdbClientTests
+add_lldb_unittest(PlatformAndroidTests
   AdbClientTest.cpp
+  PlatformAndroidRemoteGDBServerTest.cpp
 
   LINK_LIBS
     lldbPluginPlatformAndroid
   )

lldb/unittests/Platform/Android/PlatformAndroidRemoteGDBServerTest.cpp

+//===-- PlatformAndroidRemoteGDBServerTest.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 "Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h"
+#include "gtest/gtest.h"
+#include <cstdlib>
+
+static void set_env(const char *var, const char *value) {
+#ifdef _WIN32
+  _putenv_s(var, value);
+#else
+  setenv(var, value, true);
+#endif
+}
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace lldb_private {
+namespace platform_android {
+
+class PlatformAndroidRemoteGDBServerForTest
+    : public PlatformAndroidRemoteGDBServer {
+public:
+  PlatformAndroidRemoteGDBServerForTest() = delete;
+  explicit PlatformAndroidRemoteGDBServerForTest(
+      const std::string &device_id, const std::string &adb_server_port,
+      const std::string &platform_local_port, const std::string &gdb_local_port)
+      : PlatformAndroidRemoteGDBServer(device_id, adb_server_port,
+                                       platform_local_port, gdb_local_port) {}
+
+  void CheckPorts(uint16_t platform_local_port, uint16_t gdb_local_port) {
+    ASSERT_EQ(platform_local_port, GetPlatformLocalPort());
+    ASSERT_EQ(gdb_local_port, GetGDBLocalPort());
+  }
+};
+
+class PlatformAndroidRemoteGDBServerTest : public ::testing::Test {
+public:
+  void SetUp() override {
+    set_env("ANDROID_PLATFORM_LOCAL_PORT", "");
+    set_env("ANDROID_PLATFORM_LOCAL_GDB_PORT", "");
+  }
+
+  void TearDown() override {
+    set_env("ANDROID_PLATFORM_LOCAL_PORT", "");
+    set_env("ANDROID_PLATFORM_LOCAL_GDB_PORT", "");
+  }
+};
+
+TEST(PlatformAndroidRemoteGDBServerTest, GetPlatformLocalPort) {
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "", "");
+  p.CheckPorts(0u, 0u);
+}
+
+TEST(PlatformAndroidRemoteGDBServerTest, GetPlatformLocalPort_WithEnv) {
+  set_env("ANDROID_PLATFORM_LOCAL_PORT", "12346");
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "", "");
+  p.CheckPorts(12346u, 0u);
+}
+
+TEST(PlatformAndroidRemoteGDBServerTest, GetPlatformLocalPort_WithOption) {
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "12345", "");
+  p.CheckPorts(12345u, 0u);
+}
+
+TEST(PlatformAndroidRemoteGDBServerTest,
+     GetPlatformLocalPort_WithEnvAndOption) {
+  set_env("ANDROID_PLATFORM_LOCAL_PORT", "12346");
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "12345", "");
+  p.CheckPorts(12345u, 0u);
+}
+
+TEST(PlatformAndroidRemoteGDBServerTest, GetGDBLocalPort) {
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "", "");
+  p.CheckPorts(0u, 0u);
+}
+
+TEST(PlatformAndroidRemoteGDBServerTest, GetGDBLocalPort_WithEnv) {
+  set_env("ANDROID_PLATFORM_LOCAL_GDB_PORT", "12346");
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "", "");
+  p.CheckPorts(0u, 12346u);
+}
+
+TEST(PlatformAndroidRemoteGDBServerTest, GetGDBLocalPort_WithOption) {
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "", "12345");
+  p.CheckPorts(0u, 12345u);
+}
+
+TEST(PlatformAndroidRemoteGDBServerTest, GetGDBLocalPort_WithEnvAndOption) {
+  set_env("ANDROID_PLATFORM_LOCAL_GDB_PORT", "12346");
+  PlatformAndroidRemoteGDBServerForTest p("device1", "5037", "", "12345");
+  p.CheckPorts(0u, 12345u);
+}
+
+} // end namespace platform_android
+} // end namespace lldb_private