Add new API to SBTarget class

[apolyakov]

Summary

The new API appends an image search path to the
target's path mapping list.

[clayborg]

include/lldb/API/SBTarget.h

275–276

Remove this first one? Other functions were first created and gave no error feedback and then another version was added that had an error. We should start with one that has an error and not ever add this version.

include/lldb/Target/Target.h

1003–1005 ↗

(On Diff #157053)

Remove and just use "PathMappingList &Target::GetImageSearchPathList();"

lit/tools/lldb-mi/target/inputs/target-select-so-path.sh

3–11 ↗

(On Diff #157053)

This seems like it could be racy and cause problems on buildbots.

source/API/SBTarget.cpp

1460–1464

Remove this version that takes no error

source/Target/Target.cpp

2055–2059 ↗

(On Diff #157053)

You don't need this, just call "target. GetImageSearchPathList().Append(...)

[labath]

I am sure that particular test is worth trying to implement in lit. That script of yours is full of operating system specifics, and it's going to be super flaky.

I'd suggest keeping this as a python test, as there you can abstract the platform specifics much easier, and we also have a lot of code we can (re)use to setup socket connections safely. (e.g. lldb-server has a mode where *it* selects a port to listen on (race-free), and then you can just fetch that port and connect to it.)

Doing that from a shell script is going to be painful.

I suppose if you really want to make this a lit test, you should at least ditch the bash script and replace that bit with python.

[apolyakov]

What do you think about running tests with a hardcoded port number(as it's done in a web-services). Doing this, we get rid of additional scripts and os-specific things. AFAIK, debugserver even has its own default port.

P.S. As I saw in the lldb-mi python tests, port number is just a random value in a specific range, so, in general, it's the same as a hardcoded number.

[labath]

In D49739#1174744, @apolyakov wrote:

What do you think about running tests with a hardcoded port number(as it's done in a web-services). Doing this, we get rid of additional scripts and os-specific things. AFAIK, debugserver even has its own default port.

Even if you somehow managed (which I doubt) to find a port that has a reasonable chance of being free on most machines, then you'd still run into issues, because two of such tests could not run in parallel. Or you'd have to choose a different hard-coded port for each test, which again lowers your chance of not conflicting with anything.

Generally, I think ports are too scarce of a resource these days for anyone to be able to simply squat them and expect things will work. On unix you could do this with domain sockets, as you can put almost anything in their "address" (build folder, test name, timestamp, ...). However, that won't work on windows (though I believe it may be possible to get named pipes to do this for you there).

P.S. As I saw in the lldb-mi python tests, port number is just a random value in a specific range, so, in general, it's the same as a hardcoded number.

Can you point me to the code that does this? If the tests are just choosing a random port and hoping it will be free, then I'm not surprised they are flaky.

[apolyakov]

packages/Python/lldbsuite/test/tools/lldb-mi/signal/TestMiSignal.py test contains port = 12000 + random.randint(0, 3999).

[labath]

In D49739#1174769, @apolyakov wrote:

packages/Python/lldbsuite/test/tools/lldb-mi/signal/TestMiSignal.py test contains port = 12000 + random.randint(0, 3999).

Ok, that's bad. I don't know why the other lldb-mi tests are flaky, but these ones are definitely flaky because of that. Let's not emulate that.

The best way to get a port is to have lldb-server/debugserver choose it for you. You can do this by passing "0" as the command line port, and using the --pipe argument to have the stub write out the actual port number it has chosen back to you. That way, you're guaranteed to get a free port without any races.

[apolyakov]

Thanks, I used this lldb-server gdbserver --pipe 0 localhost:0 and got a port chosen by debugserver. But to let lldb-mi know about this port we need an additional script, is python a good choice for that?

[labath]

In D49739#1174810, @apolyakov wrote:

Thanks, I used this lldb-server gdbserver --pipe 0 localhost:0 and got a port chosen by debugserver. But to let lldb-mi know about this port we need an additional script, is python a good choice for that?

It's definitely better than bash. :)

[apolyakov]

Moved test from bash to python, removed unnecessary Target::AppendImageSearchPath.

[apolyakov]

lit/lit.cfg

59

Do we have debugserver only on macOS? On other OS it's called lldb-server?

source/API/SBTarget.cpp

1468

I didn't find nullptr check in other API functions, is it OK or it's better to add it?

[labath]

lit/lit.cfg

59

That is correct (well.. some platforms like FreeBSD and Windows have neither).

lit/tools/lldb-mi/target/inputs/target-select-so-path.py

8–11

This is still racy, because the port can be snatched from under you between the time you get the free port and the time when lldb-server binds to it. If this was the only test doing it then it might be fine, but since this is going to be running concurrently with other tests, all of which are fetching free ports, the chances of that happening add up.

(Also, binding to the wildcard address will trigger a firewall popup on some machines.)

25–26

Another race here: lldb-mi can attempt to connect before lldb-server has had a chance to start listening. (That's another reason to implement the port handshake, as it will serve as an synchronization point -- you get the port number only after lldb-server has successfully started and set up it's socket).

[apolyakov]

lit/tools/lldb-mi/target/inputs/target-select-so-path.py

8–11

There is a problem with getting port from lldb-server. If we run lldb-server gdbserver --pipe 0 ocalhost:0, it'll print port number to its stdout, but we can't get it using pipes since to do this we need to wait until lldb-server finishes that isn't what we want.

[labath]

lit/tools/lldb-mi/target/inputs/target-select-so-path.py

8–11

Aha, I see. lldb-server does not really expect you to pass std file descriptor as the --pipe argument. Normally you would create a separate fd and pass that instead. Doing that from python is a bit icky, but doable:

(r, w) = os.pipe()
kwargs = {}
if sys.version_info >= (3,0):
  kwargs["pass_fds"] = [w]
llgs = subprocess.Popen(["lldb-server", "gdbserver", "--pipe", str(w), ...], **kwargs)
port_bytes = os.read(r, 10)
port = int(port_bytes.decode("utf-8").strip('\x00'))

Alternatively, we could modify lldb-server to print the port number to stdout in addition to any --pipe arguments (sounds like a good addition anyway, as it enables easy free port selection for a shell user), and then you can sniff that text from here.

[apolyakov]

lit/tools/lldb-mi/target/inputs/target-select-so-path.py

8–11

--pipe 0 prints port number exactly to stdout, so there will not be a difference for us. It's not so simple to get port from lldb-server's stdout in python, so I don't think it will save us.

[labath]

lit/tools/lldb-mi/target/inputs/target-select-so-path.py

8–11

I think you're looking for this:

foo = subprocess.Popen(...)
print "The first line of output is: " + foo.stdout.readline()

Btw, using --pipe 0 works only by accident (0 is the stdin descriptor), and probably only in a terminal. Once popen() starts redirecting things, 0 will probably not refer to the thing that stdout will read from. --pipe 1 would fix that, but then we have the issue that lldb-server will close the --pipe descriptor once it's finished writing the port. That can have surprising effects as subsequent attempts to write to stdout will fail. (That's why I suggested a different implementation. Among other things, outputting something like "lldb-server listening on 127.0.0.1:4747" will make it easier to separate out the port from other things that lldb-server happens to write to stdout.)

[apolyakov]

lit/tools/lldb-mi/target/inputs/target-select-so-path.py

8–11

I think you're looking for this:

foo = subprocess.Popen(...)
print "The first line of output is: " + foo.stdout.readline()

I tried this, it hangs for me.

[apolyakov]

Now tcp port is choosing by debugserver.

[apolyakov]

So, do you have any thoughts about this approach letting the debugserver choose a tcp port and patch overall?

[labath]

Sorry for not responding, I've been a bit busy these days. I've wanted to make a proof-of-concept to show you that reading the port number from stdout is possible, but I haven't gotten around to it yet.

However, I am happy with the current mechanism of choosing the port too (thank you). This should make the test much more stable.

I don't have an opinion on the rest of the patch.

[apolyakov]

OK, thank you for respond. Then, I think, we should wait for review from @clayborg or @aprantl, and if they accept the patch I'll divide it into two parts: SB API part and target-select one.

[aprantl]

Seems good otherwise.

source/API/SBTarget.cpp

1468

I would convert it to a ConstString up front and then check whether the ConstString is empty. This way you don't have to worry about nullptr vs empty string.

[apolyakov]

source/API/SBTarget.cpp

1468

Maybe then change method's signature from const char * to ConstString? I haven't done this since in other methods strings are represented as pointers to char, is it some rule for SB API or not?

[aprantl]

source/API/SBTarget.cpp

1468

In order to map this to Python properly I think we need to keep the signature using const char*.

[apolyakov]

Added converting from const char * to ConstString, documented new API.

[clayborg]

source/API/SBTarget.cpp

1476–1477

check if csFrom or csTo is empty and give an error message that states which one is invalid?

[apolyakov]

Made error handling more meaningful: added different error messages for cases - empty <from> path and empty <to> path.

[aprantl]

source/API/SBTarget.cpp

1467

personally I would write this as:

if (!csFrom)
  return error.SetErrorString("<from> path is empty");
if (!csTo)
  return error.SetErrorString("<to> path is empty");
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
if (log)
  log->Printf("SBTarget(%p)::%s: '%s' -> '%s'",
              static_cast<void *>(target_sp.get()),  __FUNCTION__,
              from, to);
target_sp->GetImageSearchPathList().Append(csFrom, csTo, true);

[apolyakov]

source/API/SBTarget.cpp

1467

in my opinion, the branch if (csFrom && csTo) will be executed in most cases, so it is reasonable to make it executed first, as this will benefit the branch prediction of the processor. Is this a worthwhile argument?

[aprantl]

source/API/SBTarget.cpp

1467

Not really. First, you don't actually control the order in which the code is emitted by the compiler by rearranging the source code. Second, it doesn't make sense to think about branch prediction outside of a tight loop as the effect would not even be measurable. We should optimize for readability and compact code here.

[apolyakov]

source/API/SBTarget.cpp

1467

Yes, I should agree that thinking about branch prediction isn't so effective in our case. But the readability of our approaches is almost equal. At the same time, taking into consideration that in most cases we will have not empty string arguments, your approach will check 2 conditions and mine approach will check 1 condition.

[aprantl]

source/API/SBTarget.cpp

1467

It's the LLVM style to prefer early exits:

http://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code

[apolyakov]

Changed the order of if statements to follow llvm coding standards.

[aprantl]

sgtm.

[apolyakov]

Splitted the patch into two parts: this part with the new API and another one with re-implementing of target-select command.
The second part will be committed separately.

[jingham]

Could you add a short doc to this API - it's particularly useful to do this to the .i version. I know there are lots of API's that don't have docs, but that is not a happy situation. I'd like it if we all at least didn't make the problem worse by documenting all the new API's we add.

[apolyakov]

Sure, will do it.

[jingham]

Thanks! No need for review...

[apolyakov]

It seems that target-select-so-path.test hangs on macOS. Thanks to @t.p.northover for noting this.

The debugserver doesn't have --pipe option, so on macOS it fails to start and the test hangs waiting for output from debugserver. Is there any alternative for --pipe option to let the debugserver choose a tcp port itself? I took a quick look at debugserver's sources and didn't find it.

[jingham]

It looks like lots of options to debugserver were added without also adding them to the --help output. Probably because there are so few clients they already know the options (the same person added & used them...) But if you look at the actual options in debugserver.cpp, you will see:

{"unix-socket", required_argument, NULL,
 'u'}, // If we need to handshake with our parent process, an option will be
       // passed down that specifies a unix socket name to use
{"fd", required_argument, NULL,
 '2'}, // A file descriptor was passed to this process when spawned that
       // is already open and ready for communication
{"named-pipe", required_argument, NULL, 'P'},
{"reverse-connect", no_argument, NULL, 'R'},

Will one of those serve your purpose?

Jim

[apolyakov]

I think those options don't fit. I'm looking for behavior like this:

~/workspace/gsoc/build/bin/lldb-server gdbserver --pipe 1 localhost:0
36251

Here lldb-server prints out the port number it is listening on and continues running.

If debugserver can choose a tcp port in case of passed hostname:0 then probably all we need to do is to add analogue of --pipe option.

[labath]

In D49739#1194037, @apolyakov wrote:

I think those options don't fit. I'm looking for behavior like this:

~/workspace/gsoc/build/bin/lldb-server gdbserver --pipe 1 localhost:0
36251

Here lldb-server prints out the port number it is listening on and continues running.

If debugserver can choose a tcp port in case of passed hostname:0 then probably all we need to do is to add analogue of --pipe option.

That's what --unix-socket and --named-pipe do, except that they write to the port number, well.. to a unix socket or a named pipe. You should be able to use that the same way as the --pipe argument, just the setup will be slightly different. However, adding support for the --pipe option should not be a problem either, given that all the pieces are already in place.

[teemperor]

This test is timing out for me on Arch Linux. Any idea why?

bash -x ./tools/lldb/lit/tools/lldb-mi/target/Output/target-select-so-path.test.script
+ set -o pipefail
+ set -x
+ : 'RUN: at line 3'
+ /data/llvm/dbg-build/./bin/clang -o /data/llvm/dbg-build/tools/lldb/lit/tools/lldb-mi/target/Output/target-select-so-path.test.tmp /home/me/llvm/llvm/tools/lldb/lit/tools/lldb-mi/target/inputs/main.c -g
+ : 'RUN: at line 4'
+ python /home/me/llvm/llvm/tools/lldb/lit/tools/lldb-mi/target/inputs/target-select-so-path.py '/data/llvm/dbg-build/bin/lldb-server gdbserver' '/data/llvm/dbg-build/bin/lldb-mi --synchronous /data/llvm/dbg-build/tools/lldb/lit/tools/lldb-mi/target/Output/target-select-so-path.test.tmp' /home/me/llvm/llvm/tools/lldb/lit/tools/lldb-mi/target/target-select-so-path.test
failed to write to the unnamed pipe: timed out

[tatyana-krasnukha]

On CentOS this test hangs forever. If I manually kill lldb-mi and lldb-server subprocesses, the output is

--
Exit Code: 1

Command Output (stderr):
--
/lldb/lit/tools/lldb-mi/target/target-select-so-path.test:16:10: error: CHECK: expected string not found in input
# CHECK: ^done
         ^
<stdin>:4:1: note: scanning from here
(gdb)
^
<stdin>:5:37: note: possible intended match here
=library-loaded,id="/lldb/lit/tools/lldb-mi/target/Output/target-select-so-path.test.tmp",target-name="/lldb/lit/tools/lldb-mi/target/Output/target-select-so-path.test.tmp",host-name="/lldb/lit/tools/lldb-mi/target/Output/target-select-so-path.test.tmp",symbols-loaded="0",loaded_addr="-",size="0"

[tatyana-krasnukha]

lit/tools/lldb-mi/target/target-select-so-path.test

5

Could you run the same python that is used for all python tests? (%python)

[apolyakov]

lit/tools/lldb-mi/target/target-select-so-path.test

5

Done in https://reviews.llvm.org/D52498

include/lldb/API/SBTarget.h

public:
   /// @return
   ///      A process object for the connected process.
   //------------------------------------------------------------------
   lldb::SBProcess ConnectRemote(SBListener &listener, const char *url,
                                 const char *plugin_name, SBError &error);
 
   lldb::SBFileSpec GetExecutable();
 
+  void AppendImageSearchPath(const char *from, const char *to,
+                             lldb::SBError &error);
+
   bool AddModule(lldb::SBModule &module);
 
   lldb::SBModule AddModule(const char *path, const char *triple,
                            const char *uuid);
 
   lldb::SBModule AddModule(const char *path, const char *triple,
                            const char *uuid_cstr, const char *symfile);
 

lit/lit.cfg

 config.environment['LLVM_SRC_ROOT'] = getattr(config, 'llvm_src_root', '')
 
 # Propagate PYTHON_EXECUTABLE into the environment
 config.environment['PYTHON_EXECUTABLE'] = getattr(config, 'python_executable', '')
 
 # Register substitutions
 config.substitutions.append(('%python', config.python_executable))
 
+if platform.system() in ['Darwin']:
     debugserver = lit.util.which('debugserver', lldb_tools_dir)
+else:
+    debugserver = lit.util.which('lldb-server', lldb_tools_dir)
 lldb = "%s -S %s/lit-lldb-init" % (lit.util.which('lldb', lldb_tools_dir),
                                config.test_source_root)
 
 lldbmi = lit.util.which('lldb-mi', lldb_tools_dir)
 
 if not os.path.exists(config.cc):
     config.cc = lit.util.which(config.cc, config.environment['PATH'])
 

 
 config.substitutions.append(('%cc', config.cc))
 config.substitutions.append(('%cxx', config.cxx))
 
 config.substitutions.append(('%lldbmi', lldbmi + " --synchronous"))
 config.substitutions.append(('%lldb', lldb))
 
 if debugserver is not None:
+    if platform.system() in ['Darwin']:
         config.substitutions.append(('%debugserver', debugserver))
+    else:
+        config.substitutions.append(('%debugserver', debugserver + ' gdbserver'))
 
 for pattern in [r"\bFileCheck\b",
                 r"\blldb-test\b",
                 r"\byaml2obj\b",
                 r"\| \bnot\b"]:
     tool_match = re.match(r"^(\\)?((\| )?)\W+b([0-9A-Za-z-_]+)\\b\W*$",
                           pattern)
     tool_pipe = tool_match.group(2)

lit/tools/lldb-mi/target/inputs/main.c

+int main(void) {
+  int x = 0;
+  return x;
+}

lit/tools/lldb-mi/target/inputs/target-select-so-path.py

+#!/usr/bin/env python2
+
+import sys
+import socket
+import subprocess
+
+
+def get_free_port():
+    s = socket.socket()
+    s.bind(('', 0))
+    return s.getsockname()[1]
+
+
+port = str(get_free_port())
+hostname = 'localhost'
+
+args = sys.argv
+# Get debugserver, lldb-mi and FileCheck executables' paths with arguments.
+debugserver = ' '.join([args[1], hostname + ':' + port])
+lldbmi = args[2]
+test_file = args[3]
+filecheck = 'FileCheck ' + test_file
+
+# Run debugserver, lldb-mi and FileCheck.
+debugserver_proc = subprocess.Popen(debugserver, shell=True)
+lldbmi_proc = subprocess.Popen(lldbmi, stdin=subprocess.PIPE,
+                               stdout=subprocess.PIPE, shell=True)
+filecheck_proc = subprocess.Popen(filecheck, stdin=lldbmi_proc.stdout,
+                                  shell=True)
+
+with open(test_file, 'r') as f:
+    # Replace '$PORT' with a free port number and pass
+    # test's content to lldb-mi.
+    lldbmi_proc.stdin.write(f.read().replace('$PORT', port))
+    lldbmi_proc.wait()
+    filecheck_proc.wait()
+
+debugserver_proc.kill()
+exit(filecheck_proc.returncode)

lit/tools/lldb-mi/target/lit.local.cfg

+config.suffixes = ['.test']

lit/tools/lldb-mi/target/target-select-so-path.test

+# UNSUPPORTED: windows
+#
+# RUN: %cc -o %t %p/inputs/main.c -g
+# RUN: python %p/inputs/target-select-so-path.py "%debugserver" "%lldbmi %t" %s
+
+# Test that -target-select command can hook up a path
+# added by gdb-set solib-search-path.
+
+# Check that we have a valid target created via file-exec-and-symbols.
+# CHECK: ^done
+
+-interpreter-exec console "target modules search-paths list"
+# CHECK ^done
+
+-gdb-set solib-search-path /example/dir
+# CHECK: ^done
+
+-target-select remote localhost:$PORT
+# CHECK: ^connected
+
+-interpreter-exec console "target modules search-paths list"
+# CHECK: ~"[0] \".\" -> \"/example/dir\"\n"
+# CHECK-NEXT: ^done
+
+-gdb-exit

source/API/SBTarget.cpp

if (target_sp) {
     std::unique_lock<std::recursive_mutex> lock;
     target_sp->GetWatchpointList().GetListMutex(lock);
     target_sp->RemoveAllWatchpoints();
     return true;
   }
   return false;
 }
 
+void SBTarget::AppendImageSearchPath(const char *from, const char *to,
+                                     lldb::SBError &error) {
+  TargetSP target_sp(GetSP());
+  if (!target_sp) {
+    error.SetErrorStringWithFormat("invalid target "
+                                   "(SBTarget::%s) failed", __FUNCTION__);
+    return;
+  }
+  if (from[0] && to[0]) {
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+    if (log)
+      log->Printf("SBTarget::%s: '%s' -> '%s'",
+                  __FUNCTION__, from, to);
+    target_sp->GetImageSearchPathList().Append(
+        ConstString(from), ConstString(to), true);
+  } else
+    error.SetErrorStringWithFormat("<path-prefix> can't be empty "
+                                   "(SBTarget::%s) failed", __FUNCTION__);
+}
+
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr) {
   return AddModule(path, triple, uuid_cstr, NULL);
 }
 
 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
                                    const char *uuid_cstr, const char *symfile) {
   lldb::SBModule sb_module;

tools/lldb-mi/MICmdCmdTarget.cpp

 //===-- MICmdCmdTarget.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Overview:    CMICmdCmdTargetSelect           implementation.
 
 // Third Party Headers:
-#include "lldb/API/SBCommandInterpreter.h"
-#include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBStream.h"
+#include "lldb/API/SBError.h"
 
 // In-house headers:
 #include "MICmdArgValNumber.h"
 #include "MICmdArgValOptionLong.h"
 #include "MICmdArgValOptionShort.h"
 #include "MICmdArgValString.h"
 #include "MICmdCmdTarget.h"
 #include "MICmnLLDBDebugSessionInfo.h"

 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmdCmdTargetSelect destructor.
 // Type:    Overrideable.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
-CMICmdCmdTargetSelect::~CMICmdCmdTargetSelect() {}
+CMICmdCmdTargetSelect::~CMICmdCmdTargetSelect() = default;
 
 //++
 //------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The parses the command line
 // options
 //          arguments to extract values for each of those arguments.
 // Type:    Overridden.
 // Args:    None.

 // Throws:  None.
 //--
 bool CMICmdCmdTargetSelect::Execute() {
   CMICMDBASE_GETOPTION(pArgType, String, m_constStrArgNamedType);
   CMICMDBASE_GETOPTION(pArgParameters, String, m_constStrArgNamedParameters);
 
   CMICmnLLDBDebugSessionInfo &rSessionInfo(
       CMICmnLLDBDebugSessionInfo::Instance());
+  lldb::SBTarget target = rSessionInfo.GetTarget();
 
-  // Check we have a valid target
-  // Note: target created via 'file-exec-and-symbols' command
-  if (!rSessionInfo.GetTarget().IsValid()) {
+  // Check we have a valid target.
+  // Note: target created via 'file-exec-and-symbols' command.
+  if (!target.IsValid()) {
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_TARGET_CURRENT),
                                    m_cmdData.strMiCmd.c_str()));
     return MIstatus::failure;
   }
 
-  // Verify that we are executing remotely
+  // Verify that we are executing remotely.
   const CMIUtilString &rRemoteType(pArgType->GetValue());
   if (rRemoteType != "remote") {
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_TARGET_TYPE),
                                    m_cmdData.strMiCmd.c_str(),
                                    rRemoteType.c_str()));
     return MIstatus::failure;
   }
 
-  // Create a URL pointing to the remote gdb stub
+  // Create a URL pointing to the remote gdb stub.
   const CMIUtilString strUrl =
       CMIUtilString::Format("connect://%s", pArgParameters->GetValue().c_str());
 
-  // Ask LLDB to connect to the target port
-  const char *pPlugin("gdb-remote");
   lldb::SBError error;
-  lldb::SBProcess process = rSessionInfo.GetTarget().ConnectRemote(
+  // Ask LLDB to connect to the target port.
+  const char *pPlugin("gdb-remote");
+  lldb::SBProcess process = target.ConnectRemote(
       rSessionInfo.GetListener(), strUrl.c_str(), pPlugin, error);
 
-  // Verify that we have managed to connect successfully
-  lldb::SBStream errMsg;
-  error.GetDescription(errMsg);
+  // Verify that we have managed to connect successfully.
   if (!process.IsValid()) {
     SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_TARGET_PLUGIN),
                                    m_cmdData.strMiCmd.c_str(),
-                                   errMsg.GetData()));
-    return MIstatus::failure;
-  }
-  if (error.Fail()) {
-    SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_CONNECT_TO_TARGET),
-                                   m_cmdData.strMiCmd.c_str(),
-                                   errMsg.GetData()));
+                                   error.GetCString()));
     return MIstatus::failure;
   }
 
-  // Set the environment path if we were given one
+  // Set the environment path if we were given one.
   CMIUtilString strWkDir;
   if (rSessionInfo.SharedDataRetrieve<CMIUtilString>(
           rSessionInfo.m_constStrSharedDataKeyWkDir, strWkDir)) {
     lldb::SBDebugger &rDbgr = rSessionInfo.GetDebugger();
     if (!rDbgr.SetCurrentPlatformSDKRoot(strWkDir.c_str())) {
       SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_FNFAILED),
                                      m_cmdData.strMiCmd.c_str(),
                                      "target-select"));
       return MIstatus::failure;
     }
   }
 
-  // Set the shared object path if we were given one
+  // Set the shared object path if we were given one.
   CMIUtilString strSolibPath;
   if (rSessionInfo.SharedDataRetrieve<CMIUtilString>(
-          rSessionInfo.m_constStrSharedDataSolibPath, strSolibPath)) {
-    lldb::SBDebugger &rDbgr = rSessionInfo.GetDebugger();
-    lldb::SBCommandInterpreter cmdIterpreter = rDbgr.GetCommandInterpreter();
-
-    CMIUtilString strCmdString = CMIUtilString::Format(
-        "target modules search-paths add . %s", strSolibPath.c_str());
-
-    lldb::SBCommandReturnObject retObj;
-    cmdIterpreter.HandleCommand(strCmdString.c_str(), retObj, false);
+          rSessionInfo.m_constStrSharedDataSolibPath, strSolibPath))
+    target.AppendImageSearchPath(".", strSolibPath.c_str(), error);
 
-    if (!retObj.Succeeded()) {
-      SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_FNFAILED),
-                                     m_cmdData.strMiCmd.c_str(),
-                                     "target-select"));
-      return MIstatus::failure;
-    }
-  }
-
-  return MIstatus::success;
+  return HandleSBError(error);
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record
 // Result
 //          for the work carried out in the Execute().
 // Type:    Overridden.