[lldb/API] Make Launch(Simple) use args and env from target properties

[friss]

Summary

When no arguments or environment is provided to SBTarget::LaunchSimple,
make it use the values surrently set in the target properties. You can
get the current behavior back by passing an empty array instead.

It seems like using the target defaults is a much more intuitive
behavior for those APIs. It's unllikely that anyone passed NULL/None to
this API after having set properties in order to explicitely ignore them.

One direct application of this change is within the testsuite. We have
plenty of tests calling LaunchSimple and passing None as environment.
If you passed --inferior-env to dotest.py to, for example, set
(DY)LD_LIBRARY_PATH, it wouldn't be taken into account.

[friss]

Remove unrelated change commited by accident

[labath]

sounds reasonable.

lldb/include/lldb/API/SBTarget.h

130–133

Make it explicit that "isn't provided" means nullptr. And maybe mention that one can get an empty environment by passing an empty array. And do the same for the argv array. :)

[friss]

This is somewhat useless without D76009 because the default LaunchInfo doesn't get populated with the environment without it. I'll wait for a resolution there before landing this.

lldb/include/lldb/API/SBTarget.h

public:
   ///     If \a listener is valid then \a listener will listen to all
   ///     process events. If not valid, then this target's debugger
   ///     (SBTarget::GetDebugger()) will listen to all process events.
   ///
   /// \param[in] argv
   ///     The argument array.
   ///
   /// \param[in] envp
-  ///     The environment array.
+  ///     The environment array. If this is null, the default
+  ///     environment values (provided through `settings set
+  ///     target.env-vars`) will be used.
   ///
   /// \param[in] stdin_path
   ///     The path to use when re-directing the STDIN of the new
   ///     process. If all stdXX_path arguments are nullptr, a pseudo
   ///     terminal will be used.
   ///
   /// \param[in] stdout_path
   ///     The path to use when re-directing the STDOUT of the new
   ///     process. If all stdXX_path arguments are nullptr, a pseudo
public:
   SBProcess LoadCore(const char *core_file, lldb::SBError &error);
 
   /// Launch a new process with sensible defaults.
   ///
   /// \param[in] argv
   ///     The argument array.
   ///
   /// \param[in] envp
-  ///     The environment array.
+  ///     The environment array. If this isn't provided, the default
+  ///     environment values (provided through `settings set
+  ///     target.env-vars`) will be used.
   ///
   /// \param[in] working_directory
   ///     The working directory to have the child process run in
   ///
   /// Default: listener
   ///     Set to the target's debugger (SBTarget::GetDebugger())
   ///
   /// Default: launch_flags

lldb/source/API/SBTarget.cpp

if (target_sp) {
 
     ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path),
                                   FileSpec(stderr_path),
                                   FileSpec(working_directory), launch_flags);
 
     Module *exe_module = target_sp->GetExecutableModulePointer();
     if (exe_module)
       launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
-    if (argv)
+    if (argv) {
       launch_info.GetArguments().AppendArguments(argv);
-    if (envp)
+    } else {
+      auto default_launch_info = target_sp->GetProcessLaunchInfo();
+      launch_info.GetArguments().AppendArguments(
+          default_launch_info.GetArguments());
+    }
+    if (envp) {
       launch_info.GetEnvironment() = Environment(envp);
+    } else {
+      auto default_launch_info = target_sp->GetProcessLaunchInfo();
+      launch_info.GetEnvironment() = default_launch_info.GetEnvironment();
+    }
 
     if (listener.IsValid())
       launch_info.SetListener(listener.GetSP());
 
     error.SetError(target_sp->Launch(launch_info, nullptr));
 
     sb_process.SetSP(target_sp->GetProcessSP());
   } else {

lldb/test/API/commands/settings/TestSettings.py

def test_disassembler_settings(self):
         self.expect("disassemble -n numberfn",
                     substrs=["0x5a"])
         self.runCmd("settings set target.hex-immediate-style asm")
         self.expect("disassemble -n numberfn",
                     substrs=["5ah"])
 
     @skipIfDarwinEmbedded   # <rdar://problem/34446098> debugserver on ios etc can't write files
     def test_run_args_and_env_vars(self):
+        self.do_test_run_args_and_env_vars(use_launchsimple=False)
+
+    @skipIfDarwinEmbedded   # <rdar://problem/34446098> debugserver on ios etc can't write files
+    def test_launchsimple_args_and_env_vars(self):
+        self.do_test_run_args_and_env_vars(use_launchsimple=True)
+
+    def do_test_run_args_and_env_vars(self, use_launchsimple):
         """Test that run-args and env-vars are passed to the launched process."""
         self.build()
-        exe = self.getBuildArtifact("a.out")
-        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Set the run-args and the env-vars.
         # And add hooks to restore the settings during tearDown().
         self.runCmd('settings set target.run-args A B C')
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.run-args"))
         self.runCmd('settings set target.env-vars ["MY_ENV_VAR"]=YES')
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.env-vars"))
 
-        launch_info = self.dbg.GetTargetAtIndex(0).GetLaunchInfo()
+        exe = self.getBuildArtifact("a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        target = self.dbg.GetTargetAtIndex(0)
+        launch_info = target.GetLaunchInfo()
         found_env_var = False
         for i in range(0, launch_info.GetNumEnvironmentEntries()):
             if launch_info.GetEnvironmentEntryAtIndex(i) == "MY_ENV_VAR=YES":
                 found_env_var = True
                 break
         self.assertTrue(found_env_var,
                         "MY_ENV_VAR was not set in LunchInfo object")
 
-        self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()),
+        wd = self.get_process_working_directory()
+        if use_launchsimple:
+            process = target.LaunchSimple(None, None, wd)
+            self.assertTrue(process)
+        else:
+            self.runCmd("process launch --working-dir '{0}'".format(wd),
                 RUN_SUCCEEDED)
 
         # Read the output file produced by running the program.
         output = lldbutil.read_file_from_process_wd(self, "output2.txt")
 
         self.expect(
             output,
             exe=False,