[lldb] Introduce SBPlatform::SetSDKRoot

[labath]

Summary

It complements the existing SBDebugger::SetCurrentPlatformSDKRoot and
allows one to set the sysroot of a platform without making it current.

[JDevlieghere]

LGTM

lldb/bindings/interface/SBPlatform.i

public:
     GetOSMajorVersion ();
 
     uint32_t
     GetOSMinorVersion ();
 
     uint32_t
     GetOSUpdateVersion ();
 
+    void
+    SetSDKRoot(const char *sysroot);
+
     lldb::SBError
     Get (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);
 
     lldb::SBError
     Put (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);
 
     lldb::SBError
     Install (lldb::SBFileSpec &src, lldb::SBFileSpec &dst);

lldb/include/lldb/API/SBPlatform.h

public:
   const char *GetOSDescription();
 
   uint32_t GetOSMajorVersion();
 
   uint32_t GetOSMinorVersion();
 
   uint32_t GetOSUpdateVersion();
 
+  void SetSDKRoot(const char *sysroot);
+
   SBError Put(SBFileSpec &src, SBFileSpec &dst);
 
   SBError Get(SBFileSpec &src, SBFileSpec &dst);
 
   SBError Install(SBFileSpec &src, SBFileSpec &dst);
 
   SBError Run(SBPlatformShellCommand &shell_command);
 

lldb/source/API/SBDebugger.cpp

SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
   }
   return sb_error;
 }
 
 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
   LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
                      (const char *), sysroot);
 
-  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-  if (m_opaque_sp) {
-    PlatformSP platform_sp(
-        m_opaque_sp->GetPlatformList().GetSelectedPlatform());
-
-    if (platform_sp) {
-      if (log && sysroot)
-        LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")",
-                  sysroot);
-      platform_sp->SetSDKRootDirectory(ConstString(sysroot));
-      return true;
-    }
-  }
+  if (SBPlatform platform = GetSelectedPlatform()) {
+    platform.SetSDKRoot(sysroot);
   return false;
 }
 
 bool SBDebugger::GetCloseInputOnEOF() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
 
   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
 }

lldb/source/API/SBPlatform.cpp

uint32_t SBPlatform::GetOSUpdateVersion() {
   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBPlatform, GetOSUpdateVersion);
 
   llvm::VersionTuple version;
   if (PlatformSP platform_sp = GetSP())
     version = platform_sp->GetOSVersion();
   return version.getSubminor().getValueOr(UINT32_MAX);
 }
 
+void SBPlatform::SetSDKRoot(const char *sysroot) {
+  LLDB_RECORD_METHOD(void, SBPlatform, SetSDKRoot, (const char *), sysroot);
+  if (PlatformSP platform_sp = GetSP())
+    platform_sp->SetSDKRootDirectory(ConstString(sysroot));
+}
+
 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
   LLDB_RECORD_METHOD(lldb::SBError, SBPlatform, Get,
                      (lldb::SBFileSpec &, lldb::SBFileSpec &), src, dst);
 
   SBError sb_error;
   PlatformSP platform_sp(GetSP());
   if (platform_sp) {
     sb_error.ref() = platform_sp->GetFile(src.ref(), dst.ref());

lldb/source/Target/Platform.cpp

if (IsHost()) {
     strm.Printf("  Hostname: %s\n", GetHostname());
   } else {
     const bool is_connected = IsConnected();
     if (is_connected)
       strm.Printf("  Hostname: %s\n", GetHostname());
     strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
   }
 
+  if (GetSDKRootDirectory()) {
+    strm.Format("   Sysroot: {0}\n", GetSDKRootDirectory());
+  }
   if (GetWorkingDirectory()) {
     strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
   }
   if (!IsConnected())
     return;
 
   std::string specific_info(GetPlatformSpecificConnectionInformation());
 

lldb/test/API/python_api/sbplatform/TestSBPlatform.py

def test_run(self):
 
         os.environ["MY_TEST_ENV_VAR"]="SBPlatformAPICase.test_run"
         def cleanup():
             del os.environ["MY_TEST_ENV_VAR"]
         self.addTearDownHook(cleanup)
         cmd = lldb.SBPlatformShellCommand(self.getBuildArtifact("a.out"))
         self.assertTrue(plat.Run(cmd).Success())
         self.assertIn("MY_TEST_ENV_VAR=SBPlatformAPICase.test_run", cmd.GetOutput())
+
+    def test_SetSDKRoot(self):
+        plat = lldb.SBPlatform("remote-linux") # arbitrary choice
+        self.assertTrue(plat)
+        plat.SetSDKRoot(self.getBuildDir())
+        self.dbg.SetCurrentPlatform("remote-linux")
+        self.expect("platform status",
+                substrs=["Sysroot:", self.getBuildDir()])