Add -exec-arguments command

[ki.stfu]

Summary

This patch adds -exec-arguments command for lldb-mi. -exec-arguments command allows to specify arguments for executable file in MI mode. Also it contains tests for that command.

Btw, new added files was formatted by clang-format.

[abidh]

Looks ok to me. 2 comments though.

1. Why are changes in SBTarget when you are not using them.
2. I think the test cases for arguments are currently skipped (@unittest2.skip("requires 'quotes' and 'CLI support' patches")). Currently, we can test for argc. So I think at least that portion should be enabled as that gives us some coverage. I will have to see why argv is not being evaluated.

If nobody else comments then I can commit this patch in a day or 2 with modification suggested above.

[jingham]

So the way you set arguments when you launch a process through the SB API's (besides some old unstructured API's that we'll eventually deprecate) is through the SBLaunchInfo. You're adding another way to get and set the arguments that's independent of that.

I'd rather we didn't create another way to specify launch arguments. You can already do that by creating an SBLaunchInfo with the appropriate args set, and use that for the launch.

The SBTarget already provides a way to get the arguments (SBTarget::GetNumArguments/GetArgumentAtIndex.) If you need to provide a way to get the current or previous launch arguments then we should add an API to copy out the SBLaunchInfo that was used for the launch. That's not currently kept around so you may have to reconstruct it from bits sitting in the target, but that way we keep one structured way to get at all the launch parameters...

[ki.stfu]

In D6965#110399, @abidh wrote:

1. Why are changes in SBTarget when you are not using them.

Oops. It's the old version. I'll update patch right now.

2. I think the test cases for arguments are currently skipped (@unittest2.skip("requires 'quotes' and 'CLI support' patches")). Currently, we can test for argc. So I think at least that portion should be enabled as that gives us some coverage. I will have to see why argv is not being evaluated.

Ok. I think that I can fix this test using -interpreter-exec command.

[ki.stfu]

Update patch:

• Fix test_lldbmi_setargs test and enable it.
• Set arguments directly to target (don't save it in SessionInfo)

[ki.stfu]

In D6965#110558, @jingham wrote:

So the way you set arguments when you launch a process through the SB API's (besides some old unstructured API's that we'll eventually deprecate) is through the SBLaunchInfo. You're adding another way to get and set the arguments that's independent of that.

I'd rather we didn't create another way to specify launch arguments. You can already do that by creating an SBLaunchInfo with the appropriate args set, and use that for the launch.

The SBTarget already provides a way to get the arguments (SBTarget::GetNumArguments/GetArgumentAtIndex.) If you need to provide a way to get the current or previous launch arguments then we should add an API to copy out the SBLaunchInfo that was used for the launch. That's not currently kept around so you may have to reconstruct it from bits sitting in the target, but that way we keep one structured way to get at all the launch parameters...

Yes, I had seen these functions but I was working on CLI support in MI mode. My goal was to fix the following cases:
First:

-file-exec-and-symbols ~/p/hello
-exec-arguments foo bar
-interpreter-exec command "r"

Second:

-file-exec-and-symbols ~/p/hello
-interpreter-exec command "settings set target.run-args foo bar"
-exec-run

Your way didn't work because when we specify arguments via "settings set target.run-args" they are stored as Debugger's property. Initially I had tried to set and get argument directly but it was awful because SBDebugger::GetInternalVariableValue returns arguments in dumped format, like:

[0]: "--arg1"
[1]: "2nd arg"
[2]: "third_arg"
[4]: "fourth=\"4th arg\""

Therefore I decided to extend public API.

[jingham]

If we want to have a way to directly set the arguments in a Target, I would prefer to have the SBTarget vend the SBLaunchInfo that it will use when it launches (if you don't give it another SBLaunchInfo) and then set the arguments there.

Right now it is pretty incoherent, you can set arguments in the run-args, you can set them directly when you call launch, you can set them in a SBLaunchInfo which you pass to the target, and now you can set then by passing in an SBArgs. That's too many ways to do the same thing.

Of the ones that it would be good to reuse, I think the SBLaunchInfo is the best structured, and encapsulates all the various options. So we should expose that rather than make another entity.

[ki.stfu]

In D6965#110597, @jingham wrote:

If we want to have a way to directly set the arguments in a Target, I would prefer to have the SBTarget vend the SBLaunchInfo that it will use when it launches (if you don't give it another SBLaunchInfo) and then set the arguments there.

The "process launch" command uses lldb_private (i.e. not public lldb API) and it creates LaunchInfo every time it is executed. I can't affect to that LaunchInfo instance using the public API.

Right now it is pretty incoherent, you can set arguments in the run-args, you can set them directly when you call launch, you can set them in a SBLaunchInfo which you pass to the target, and now you can set then by passing in an SBArgs. That's too many ways to do the same thing.

Maybe it's so but I don't want to create one more way of setting arguments in lldb_private::Target class. I just have made a wrapper for the existing method.

[jingham]

My suggestion was to have the SBTarget vend the SBLaunchInfo it WOULD use if you were to call launch without providing an SBLaunchInfo of your own. Unfortunately, the underlying target doesn't actually use a ProcessLaunch info to store these settings, it stores the individual bits. That's purely historical: the ProcessLaunchInfo was a later invention, and was layered onto of the existing code without re-working it. We should probably change that at some point.

So if you want extra credit it would be great to re-plumb this stuff. But I can understand if that's way more than you thought you were biting off for this task. I'm still unhappy about adding yet another way to set run arguments, and once it's in the SB API's we're stuck with it for a while.

But given that it's our fault we are in this situation, it doesn't seem fair to push this too hard.

Jim

[clayborg]

I would vote for a different approach altogether which would be a cleaner all around implementation:

Have the lldb-mi have a variable whose type is: lldb::SBLaunchInfo.

lldb::SBLaunchInfo m_launch_info;

And somehow you make a function that all command can access this launch info with like:

lldb::SBLaunchInfo &GetGlobalLaunchInfo();

This probably should be an instance variable that is part of the global MI interpreter.

Any calls to things like:

-file-exec-and-symbols ~/p/hello

Would do:

bool add_as_first_arg = true;
GetGlobalLaunchInfo().SetExecutableFile(lldb::SBFileSpec("~/p/hello"), add_as_first_arg);

Then:

-exec-arguments foo bar

would do:

const bool append_args = true;
GetGlobalLaunchInfo().SetArguments(argv, append_args);

And then:

-interpreter-exec command "r"

would do:

lldb::SBProcess process = target.Launch (GetGlobalLaunchInfo(), error);

This give you the most flexibility to set/change stuff before you launch, and setting up SBLaunchInfo is the current best practices way to launch a process.

[ki.stfu]

In D6965#111915, @clayborg wrote:

This probably should be an instance variable that is part of the global MI interpreter.

And then:

-interpreter-exec command "r"

would do:

lldb::SBProcess process = target.Launch (GetGlobalLaunchInfo(), error);

This give you the most flexibility to set/change stuff before you launch, and setting up SBLaunchInfo is the current best practices way to launch a process.

The "r" command is the CLI command which is located in source/Commands/CommandObjectProcess.cpp file. The MI module executes it using SBInterpreter::HandleCommand function and it seems like a user has typed the "r" command in the shell. I think that it's inadmissible to reference to MI module's variable in LLDB's commands because MI it's not a part of LLDB kernel. It just a extra module and LLDB shouldn't depend on it.

[ki.stfu]

Are there any other opinions?

[clayborg]

I stand by my recommendation. There are many commands that build up what is effectively a SBLaunchInfo and eventually a command that makes the program run. It is quite sad to see things like '-interpreter-exec command "r"' in a MI command log. Do you really expect all implementations of MI to implement GDB commands? Is a packet that says "-exe-launch"? The only thing that should be exposing command line execution is when the user types something. And the command interpreter could then be anything and GDB commands would not be expected to work.

Greg

[ki.stfu]

In D6965#115926, @clayborg wrote:

I stand by my recommendation.

But your recommendation can't be applied in this case (perhaps I explained it poorly).
The "r" command creates LaunchInfo every time it's executed. If you look at CommandObjectProcessLaunch you will see that LaunchInfo (which is passed into Target::Launch) is a class member. And this way is used in many commands. I can't create global LaunchInfo which will be used by these commands and MI. I think it would be strange to use one global variable in CLI commands and MI module because at the moment CommandObjectProcess.cpp looks like separate module which implements and registers commands inside itself and it doesn't provide any external symbols (only 1 class CommandObjectMultiwordProcess). I can't use your recommendation here.

There are many commands that build up what is effectively a SBLaunchInfo and eventually a command that makes the program run.

I agree that LaunchInfo is much better than many-many arguments of Launch method or than a lot of setters/getters for properties. But current implementation of process commands doesn't allow me to use single LaunchInfo for them and MI. I don't create an additional method for setting of arguments. I just have made a wrapper for the existing method.

It is quite sad to see things like '-interpreter-exec command "r"' in a MI command log. Do you really expect all implementations of MI to implement GDB commands? Is a packet that says "-exe-launch"? The only thing that should be exposing command line execution is when the user types something. And the command interpreter could then be anything and GDB commands would not be expected to work.

huh. Perhaps you didn't face with that but it's impossible to specify an architecture (what can be done by using "target create") or select a remote platform and connect to it (using platform commands) or launch a program and stop at entry (process launch -s) or load a python scripts (using script commands) or ... and so on.
It's a known problem and GDB/MI allows to use CLI and MI commands simultaneously. Also smart guys invented -interpreter-exec command (see what this command is doing here if it's not clear) and now we don't need to introduce a new syntax or commands, we can use CLI commands instead.

Therefore I think '-interpreter-exec command "r"' is an important case which should work too, also as the case when arguments are set up by "settings set target.run-args" after that -exec-run is called.

[ki.stfu]

FYI: I looked how run-args are specified for Target class. At the moment it can be done by using "settings set target.run-args" command which sets Debugger's "target.run-args" property. But actually this property is mapped to Target's ePropertyRunArgs property which can be read by Target::GetRunArguments and modified by Target::SetRunArguments. You can see in Target.cpp that Target::Launch gets these arguments by using Target::GetRunArguments.

My implementation of "-exec-arguments" uses Target::SetRunArguments (which is wrapped in SBTarget::SetRunArguments) and as I said above it's the same thing. Thus the my implementation works the same way as "settings set target.run-args" and if you don't like it, then this architecture can be rewritten, but it's outside the scope of this CL.

[clayborg]

The fix I requested should be easy to implement as noted above in the code comments.

Step 1:
1 - Add a "SBLaunchInfo m_lldbLaunchInfo" as a member variable in the CMICmnLLDBDebugSessionInfo class next to the "SBTarget m_lldbTarget" member variable
2 - Add a SBAttachInfo for attaching as well if needed
3 - Make code changes I specify above
4 - Hook up more calls to modify data in the SBLaunchInfo and SBAttachInfo
5 - Remove SBArgs.h and SBArgs.cpp

This will provide the cleanest implementation and allow of the most flexibility in setting the environment variables (just modify SBLaunchInfo), working directory (modify SBLaunchInfo), etc, then when you launch you get to just use the launch info you have built up.

tools/lldb-mi/MICmdCmdExec.cpp

95–99 ↗

(On Diff #18397)

If we store a SBLaunchInfo in CMICmnLLDBDebugSessionInfo then this becomes:

lldb::SBProcess process = rSessionInfo.m_lldbTarget.Launch(rSessionInfo.m_lldbLaunchInfo, error);

And the SBLaunchInfo doesn't require the lldb::LaunchFlags::eLaunchFlagDebug as that is implied by the launch itself. You can set it in the m_lldbLaunchInfo if you want when you construct it inside CMICmnLLDBDebugSessionInfo.

1076–1110 ↗

(On Diff #18397)

If we store a SBLaunchInfo in CMICmnLLDBDebugSessionInfo we can turn this function into:

bool
CMICmdCmdExecArguments::Execute(void)
{
    CMICMDBASE_GETOPTION(pArgArguments, ListOfN, m_constStrArgArguments);

    CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
    const char *argv[2] = { nullptr, nullptr };
    const bool append = true;
    CMIUtilString strArg;
    size_t nArgIndex = 0;
    while (pArgArguments->GetExpectedOption<CMICmdArgValString, CMIUtilString>(strArg, nArgIndex))
    {
        argv[0] = strArg.c_str();
        rSessionInfo.m_lldbLaunchInfo.SetArguments (argv, append);
        ++nArgIndex;
    }

    return MIstatus::success;
}

[clayborg]

I forgot one step:

You will need to do a:

m_lldbLaunchInfo.SetListener(rSessionInfo.m_rLlldbListener);

before you call

lldb::SBProcess process  = m_lldbTarget.Launch(m_launch, error);

[ki.stfu]

In D6965#116930, @clayborg wrote:

The fix I requested should be easy to implement as noted above in the code comments.

This will provide the cleanest implementation and allow of the most flexibility in setting the environment variables (just modify SBLaunchInfo), working directory (modify SBLaunchInfo), etc, then when you launch you get to just use the launch info you have built up.

Greg, we are talking about different things. Your patch looks good but it wouldn't work on test case which I described earlier:

In D6965#110595, @ki.stfu wrote:

In D6965#110558, @jingham wrote:

So the way you set arguments when you launch a process through the SB API's (besides some old unstructured API's that we'll eventually deprecate) is through the SBLaunchInfo. You're adding another way to get and set the arguments that's independent of that.

I'd rather we didn't create another way to specify launch arguments. You can already do that by creating an SBLaunchInfo with the appropriate args set, and use that for the launch.

The SBTarget already provides a way to get the arguments (SBTarget::GetNumArguments/GetArgumentAtIndex.) If you need to provide a way to get the current or previous launch arguments then we should add an API to copy out the SBLaunchInfo that was used for the launch. That's not currently kept around so you may have to reconstruct it from bits sitting in the target, but that way we keep one structured way to get at all the launch parameters...

Yes, I had seen these functions but I was working on CLI support in MI mode. My goal was to fix the following cases:
First:

-file-exec-and-symbols ~/p/hello
-exec-arguments foo bar
-interpreter-exec command "r"

Second:

-file-exec-and-symbols ~/p/hello
-interpreter-exec command "settings set target.run-args foo bar"
-exec-run

Your way didn't work because when we specify arguments via "settings set target.run-args" they are stored as Debugger's property. Initially I had tried to set and get argument directly but it was awful because SBDebugger::GetInternalVariableValue returns arguments in dumped format, like:

[0]: "--arg1"
[1]: "2nd arg"
[2]: "third_arg"
[4]: "fourth=\"4th arg\""

Therefore I decided to extend public API.

[ki.stfu]

Greg,

I know that it takes a long your time but we didn't decide what need to do with this patch. If you tell me that "process launch" shouldn't work as I have described above then I can remove SBTarget::SetRunArguments, but I think it should.

Sorry that I didn't provide complete information in the description at once.

[clayborg]

So remove everything I listed and add m_lldbLaunchOptions to your CMICmnLLDBDebugSessionInfo object and populate it with all of the -exec calls, then use it to launch

include/lldb/API/SBArgs.h

1–83 ↗

(On Diff #18397)

Remove this.

include/lldb/API/SBDefines.h

32 ↗

(On Diff #18397)

Remove this.

include/lldb/API/SBTarget.h

1050–1056 ↗

(On Diff #18397)

Remove this.

source/API/CMakeLists.txt

8 ↗

(On Diff #18397)

Remove this.

source/API/SBArgs.cpp

1–153 ↗

(On Diff #18397)

Remove this.

source/API/SBTarget.cpp

16 ↗

(On Diff #18397)

Remove this.

2933–2958 ↗

(On Diff #18397)

Remove this.

[ki.stfu]

Update patch after r227958; Enable new tests

[ki.stfu]

Enable the related tests in MiExecTestCase

[ki.stfu]

Update patch according to clayborg's remarks

[ki.stfu]

In D6965#118501, @clayborg wrote:

So remove everything I listed and add m_lldbLaunchOptions to your CMICmnLLDBDebugSessionInfo object and populate it with all of the -exec calls, then use it to launch

I have updated the patch according to your remarks. Hope it looks good for you.

But I have a problem: In Diff 4 all tests pass, but now the MiInterpreterExecTestCase.test_lldbmi_settings_set_target_run_args test fails. What we should do with it?

FYI: I was trying to explain this problem in my comments above.

[clayborg]

Very nice.

[ki.stfu]

@clayborg, but what about the broken test?

In D6965#121079, @ki.stfu wrote:

But I have a problem: In Diff 4 all tests pass, but now the MiInterpreterExecTestCase.test_lldbmi_settings_set_target_run_args test fails. What we should do with it?

[ki.stfu]

@clayborg, I meant that I can't make the attached test pass with your solution.

[clayborg]

When you launch the SBTarget run args will be set for you from your SBLaunchInfo, so we don't really need to test that the setting gets set explicitly as "settings set target.run-args" is. What were you trying to test with this test? You should be able to get/set the run args in the SBLaunchInfo now before you run. Is this what you should be testing now?

[ki.stfu]

In D6965#121436, @clayborg wrote:

What were you trying to test with this test?

This test checks that we can specify arguments using CLI "settings set target.run-args" command in lldb-mi.

You should be able to get/set the run args in the SBLaunchInfo now before you run. Is this what you should be testing now?

No. I can't get arguments which were set by "settings set target.run-args" command because lldb API doesn't provide this ability.

[clayborg]

You could verify that you can set the args with "settings set" and then run with your empty SBLaunchInfo and verify that you got the right args?

[clayborg]

It would be nice to have lldb_private::Target have its own ProcessLaunchInfo as a member variable and change all storage of settings (target.run-args, target.arg0 etc) and have the settings just modify the lldb_private::Target's version of this. Then we can add functions to SBTarget:

// Get a _copy_ of the target's launch info
SBLaunchInfo
SBTarget::GetLaunchInfo();

// Set the target's launch info
void
SBTarget::GetLaunchInfo(SBLaunchInfo &launch_info);

// Launch using the target's current launch info
SBProcess
Launch (SBError& error);

This would be fine to add. Then you can make your test work again.

[ki.stfu]

In D6965#121474, @clayborg wrote:

You could verify that you can set the args with "settings set" and then run with your empty SBLaunchInfo and verify that you got the right args?

It doesn't work (test MiInterpreterExecTestCase.test_lldbmi_settings_set_target_run_args by yourself).

When I set arguments using "settings set" it were stored as the Debugger's property. And when I call Target::Launch with empty ProcessLaunchInfo, these arguments are ignored.

[ki.stfu]

In D6965#121476, @clayborg wrote:

It would be nice to have lldb_private::Target have its own ProcessLaunchInfo as a member variable and change all storage of settings (target.run-args, target.arg0 etc) and have the settings just modify the lldb_private::Target's version of this.

I'll try do it but how I can synchronize Target::m_GlobalLaunchInfo and Debugger's property (which can be set by "settings set" command)? I can't update m_GlobalLaunchInfo every time when "settings set target.run-args" is executed. Therefore will be 2 different places where these arguments are stored.

As I said, currently "settings set" stores all values as debugger's properties. And I don't want to do the following:

if (property == "target.run-args") {
    Target::GetGlobalLaunchInfo().SetRunArguments(value);
}
else {
    Debugger.SetProperty(...);
}

[ki.stfu]

Add launch_info to TargetProperties

List of changes:

• Fix OptionValueArray::SetValueFromCString that notified before the value was changed
• Add SBLaunchInfo::ref() const
• Add SBTarget::{GetLaunchInfo,SetLaunchInfo}
• Add m_launch_info to TargetProperty + add getter and setter. It has RunArgumentsValueChangedCallback callback which called when run-args value was updated.
• Fix "process launch" command

All tests passed on OS X.

[ki.stfu]

@clayborg,

Take a look again please.

[clayborg]

If we are adding a ProcessLaunchInfo to the TargetProperties everything needs to be kept up to date:

{ "arg0"                               , OptionValue::eTypeString    , false, 0                         , NULL, NULL, "The first argument passed to the program in the argument array which can be different from the executable itself." },
{ "run-args"                           , OptionValue::eTypeArgs      , false, 0                         , NULL, NULL, "A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0." },
{ "env-vars"                           , OptionValue::eTypeDictionary, false, OptionValue::eTypeString  , NULL, NULL, "A list of all the environment variables to be passed to the executable's environment, and their values." },
{ "inherit-env"                        , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "Inherit the environment from the process that is running LLDB." },
{ "input-path"                         , OptionValue::eTypeFileSpec  , false, 0                         , NULL, NULL, "The file/path to be used by the executable program for reading its standard input." },
{ "output-path"                        , OptionValue::eTypeFileSpec  , false, 0                         , NULL, NULL, "The file/path to be used by the executable program for writing its standard output." },
{ "error-path"                         , OptionValue::eTypeFileSpec  , false, 0                         , NULL, NULL, "The file/path to be used by the executable program for writing its standard error." },
{ "detach-on-error"                    , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "debugserver will detach (rather than killing) a process if it loses connection with lldb." },
{ "disable-aslr"                       , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "Disable Address Space Layout Randomization (ASLR)" },
{ "disable-stdio"                      , OptionValue::eTypeBoolean   , false, false                     , NULL, NULL, "Disable stdin/stdout for process (e.g. for a GUI application)" },

You will need to install callback functions for each of these and keep your built in ProcessLaunchInfo up to date.

include/lldb/Target/Target.h

200–201 ↗

(On Diff #19847)

We might want to make this return a "ProcessLaunchInfo &" so it isn't copied when using it internally.

source/API/SBTarget.cpp

2574 ↗

(On Diff #19847)

You must check that m_opaque_sp is valid and also make a copy of it before you use it in case another thread calls SBThread::Clear():

TargetSP target_sp(GetSP());
if (target_sp)
{
    ProcessLaunchInfo launch_info = m_opaque_sp->GetProcessLaunchInfo();
    lldb::SBLaunchInfo sb_launch_info(NULL);
    sb_launch_info.ref() = launch_info;
    return sb_launch_info;   
}
return lldb::SBLaunchInfo();

2584 ↗

(On Diff #19847)

Replace with:

TargetSP target_sp(GetSP());
if (target_sp)
{
    m_opaque_sp->SetProcessLaunchInfo(sb_launch_info.ref());
}

You might also want to change this to return a bool in case m_opaque_sp is invalid, you can return false.

[ki.stfu]

source/API/SBTarget.cpp

2574 ↗

(On Diff #19847)

oops..

[ki.stfu]

Added update other properties in m_launch_info

• Add TargetProperties::SetEnvironmentFromArgs
• Add callback for other options

Note, that "inherit-env" doesn't exist in ProcessLaunchInfo. I skipped it.

[ki.stfu]

@clayborg,

Take a look again please.

[clayborg]

Looks great.

[ki.stfu]

source/Target/Target.cpp

3061–3069 ↗

(On Diff #19851)

I can't set more than 1 callback.

[clayborg]

You will need to get the object for each item individual and set the callback on each OptionValue separately. Right now only only the item OptionValue itself will call the callback it won't pass it up to the parent and call the parent's callback. You can change this to happen if you want. then you just need to install one callback and use the "OptionValue *option_value" second param and look at its name using:

ConstString option_name = option_value->GetName();

Then you will need to find out which option it maps to and then set the right value.

[clayborg]

Inlined comments

include/lldb/Target/Target.h

213–222 ↗

(On Diff #19851)

Either get each option value and set the callback on each indivdual one, or make just one callback and in that callback extract the name from the "OptionValue *" using OptionValue::GetName() and then decoding which value it comes from.

source/Target/Target.cpp

3061–3069 ↗

(On Diff #19851)

Either get each option value and set the callback on each indivdual one, or make just one callback and in that callback extract the name from the "OptionValue *" using OptionValue::GetName() and then decoding which value it comes from.

[ki.stfu]

Fix callback; Add test that checks "settings set" before "target create"; Fix "process launch -s"; Fix OptionValueArray::DeepCopy

[ki.stfu]

@clayborg, Take a look again please.

All tests passed.
BTW, I have disabled initialization of environment variables. See line #3064.

source/Target/Target.cpp

3064 ↗

(On Diff #19863)

here

[ki.stfu]

As for me it looks bulky and Diff 4 looked better.

[clayborg]

Looks good.

lldb/trunk/include/lldb/API/SBLaunchInfo.h

 
 protected:
     friend class SBPlatform;
     friend class SBTarget;
 
     lldb_private::ProcessLaunchInfo &
     ref ();
 
+    const lldb_private::ProcessLaunchInfo &
+    ref () const;
+
     ProcessLaunchInfoSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif  // LLDB_SBLaunchInfo_h_

lldb/trunk/include/lldb/API/SBTarget.h

#endif
     bool
     GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
 
     lldb::SBValue
     EvaluateExpression (const char *expr, const SBExpressionOptions &options);
 
     lldb::addr_t
     GetStackRedZoneSize();
-    
+    lldb::SBLaunchInfo
+    GetLaunchInfo () const;
+
+    void
+    SetLaunchInfo (const lldb::SBLaunchInfo &launch_info);
+    
 protected:
     friend class SBAddress;
     friend class SBBlock;
     friend class SBDebugger;
     friend class SBExecutionContext;
     friend class SBFunction;
     friend class SBInstruction;
     friend class SBModule;

lldb/trunk/include/lldb/Target/Target.h

 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
 #include "lldb/Interpreter/OptionValueEnumeration.h"
 #include "lldb/Interpreter/OptionValueFileSpec.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/PathMappingList.h"
+#include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/SectionLoadHistory.h"
 
 namespace lldb_private {
 
 extern OptionEnumValueElement g_dynamic_value_types[];
 
 typedef enum InlineStrategy
 {
//    SetDisassemblyFlavor(const char *flavor);
     bool
     GetRunArguments (Args &args) const;
     
     void
     SetRunArguments (const Args &args);
     
     size_t
     GetEnvironmentAsArgs (Args &env) const;
-    
+    void
+    SetEnvironmentFromArgs (const Args &env);
+
     bool
     GetSkipPrologue() const;
     
     PathMappingList &
     GetSourcePathMap () const;
     
     FileSpecList &
     GetExecutableSearchPaths ();
//    SetDisassemblyFlavor(const char *flavor);
     void
     SetUserSpecifiedTrapHandlerNames (const Args &args);
     
     bool
     GetDisplayRuntimeSupportValues () const;
     
     void
     SetDisplayRuntimeSupportValues (bool b);
+
+    const ProcessLaunchInfo &
+    GetProcessLaunchInfo() const;
+
+    void
+    SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info);
+
+private:
+    //------------------------------------------------------------------
+    // Callbacks for m_launch_info.
+    //------------------------------------------------------------------
+    static void Arg0ValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void RunArgsValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void InheritEnvValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void InputPathValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void DisableASLRValueChangedCallback(void *target_property_ptr, OptionValue *);
+    static void DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *);
+
+private:
+    //------------------------------------------------------------------
+    // Member variables.
+    //------------------------------------------------------------------
+    ProcessLaunchInfo m_launch_info;
 };
 
 typedef std::shared_ptr<TargetProperties> TargetPropertiesSP;
 
 class EvaluateExpressionOptions
 {
 public:
     static const uint32_t default_timeout = 500000;

lldb/trunk/source/API/SBLaunchInfo.cpp

 }
 
 lldb_private::ProcessLaunchInfo &
 SBLaunchInfo::ref ()
 {
     return *m_opaque_sp;
 }
 
+const lldb_private::ProcessLaunchInfo &
+SBLaunchInfo::ref () const
+{
+    return *m_opaque_sp;
+}
+
 lldb::pid_t
 SBLaunchInfo::GetProcessID()
 {
     return m_opaque_sp->GetProcessID();
 }
 
 uint32_t
 SBLaunchInfo::GetUserID()

lldb/trunk/source/API/SBTarget.cpp

if (target_sp)
             abi_sp = process_sp->GetABI();
         else
             abi_sp = ABI::FindPlugin(target_sp->GetArchitecture());
         if (abi_sp)
             return abi_sp->GetRedZoneSize();
     }
     return 0;
 }
+
+lldb::SBLaunchInfo
+SBTarget::GetLaunchInfo () const
+{
+    lldb::SBLaunchInfo launch_info(NULL);
+    TargetSP target_sp(GetSP());
+    if (target_sp)
+        launch_info.ref() = m_opaque_sp->GetProcessLaunchInfo();
+    return launch_info;
+}
+
+void
+SBTarget::SetLaunchInfo (const lldb::SBLaunchInfo &launch_info)
+{
+    TargetSP target_sp(GetSP());
+    if (target_sp)
+        m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
+}

lldb/trunk/source/Commands/CommandObjectProcess.cpp

DoExecute (Args& launch_args, CommandReturnObject &result)
         }
         else
         {
             m_options.launch_info.SetExecutableFile(exe_module_sp->GetPlatformFileSpec(), true);
         }
 
         if (launch_args.GetArgumentCount() == 0)
         {
-            Args target_setting_args;
-            if (target->GetRunArguments(target_setting_args))
-                m_options.launch_info.GetArguments().AppendArguments (target_setting_args);
+            m_options.launch_info.GetArguments() = target->GetProcessLaunchInfo().GetArguments();
         }
         else
         {
             m_options.launch_info.GetArguments().AppendArguments (launch_args);
             // Save the arguments for subsequent runs in the current target.
             target->SetRunArguments (launch_args);
         }
 

lldb/trunk/source/Interpreter/OptionValueArray.cpp

if (dump_mask & eDumpOptionValue)
         strm.IndentLess();
     }
 }
 
 Error
 OptionValueArray::SetValueFromCString (const char *value, VarSetOperationType op)
 {
     Args args(value);
+    Error error = SetArgs (args, op);
+    if (error.Success())
         NotifyValueChanged();
-    return SetArgs (args, op);
+    return error;
 }
 
 
 lldb::OptionValueSP
 OptionValueArray::GetSubValue (const ExecutionContext *exe_ctx,
                                const char *name,
                                bool will_modify,
                                Error &error) const
OptionValueArray::SetArgs (const Args &args, VarSetOperationType op)
     return error;
 }
 
 lldb::OptionValueSP
 OptionValueArray::DeepCopy () const
 {
     OptionValueArray *copied_array = new OptionValueArray (m_type_mask, m_raw_value_dump);
     lldb::OptionValueSP copied_value_sp(copied_array);
+    *static_cast<OptionValue *>(copied_array) = *this;
+    copied_array->m_callback = m_callback;
     const uint32_t size = m_values.size();
     for (uint32_t i = 0; i<size; ++i)
     {
         copied_array->AppendValue (m_values[i]->DeepCopy());
     }
     return copied_value_sp;
 }
 
 
 

lldb/trunk/source/Target/Target.cpp

protected:
     Target *m_target;
     mutable bool m_got_host_env;
 };
 
 //----------------------------------------------------------------------
 // TargetProperties
 //----------------------------------------------------------------------
 TargetProperties::TargetProperties (Target *target) :
-    Properties ()
+    Properties (),
+    m_launch_info ()
 {
     if (target)
     {
         m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties()));
+
+        // Set callbacks to update launch_info whenever "settins set" updated any of these properties
+        m_collection_sp->SetValueChangedCallback(ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyInputPath, TargetProperties::InputPathValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, TargetProperties::DetachOnErrorValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback, this);
+        m_collection_sp->SetValueChangedCallback(ePropertyDisableSTDIO, TargetProperties::DisableSTDIOValueChangedCallback, this);
+    
+        // Update m_launch_info once it was created
+        Arg0ValueChangedCallback(this, NULL);
+        RunArgsValueChangedCallback(this, NULL);
+        //EnvVarsValueChangedCallback(this, NULL); // FIXME: cause segfault in Target::GetPlatform()
+        InputPathValueChangedCallback(this, NULL);
+        OutputPathValueChangedCallback(this, NULL);
+        ErrorPathValueChangedCallback(this, NULL);
+        DetachOnErrorValueChangedCallback(this, NULL);
+        DisableASLRValueChangedCallback(this, NULL);
+        DisableSTDIOValueChangedCallback(this, NULL);
     }
     else
     {
         m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target")));
         m_collection_sp->Initialize(g_properties);
         m_collection_sp->AppendProperty(ConstString("process"),
                                         ConstString("Settings specify to processes."),
                                         true,
                                         Process::GetGlobalProperties()->GetValueProperties());
     }
+
 }
 
 TargetProperties::~TargetProperties ()
 {
 }
 ArchSpec
 TargetProperties::GetDefaultArchitecture () const
 {

 
 size_t
 TargetProperties::GetEnvironmentAsArgs (Args &env) const
 {
     const uint32_t idx = ePropertyEnvVars;
     return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, env);
 }
 
+void
+TargetProperties::SetEnvironmentFromArgs (const Args &env)
+{
+    const uint32_t idx = ePropertyEnvVars;
+    m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, env);
+}
+
 bool
 TargetProperties::GetSkipPrologue() const
 {
     const uint32_t idx = ePropertySkipPrologue;
     return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
 }
 
 PathMappingList &

 
 void
 TargetProperties::SetDisplayRuntimeSupportValues (bool b)
 {
     const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
     m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
 }
 
+const ProcessLaunchInfo &
+TargetProperties::GetProcessLaunchInfo () const
+{
+    return m_launch_info;
+}
+
+void
+TargetProperties::SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info)
+{
+    m_launch_info = launch_info;
+    SetArg0(launch_info.GetArg0());
+    SetRunArguments(launch_info.GetArguments());
+    SetEnvironmentFromArgs(launch_info.GetEnvironmentEntries());
+    const FileAction *input_file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
+    if (input_file_action)
+    {
+        const char *input_path = input_file_action->GetPath();
+        if (input_path)
+            SetStandardInputPath(input_path);
+    }
+    const FileAction *output_file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
+    if (output_file_action)
+    {
+        const char *output_path = output_file_action->GetPath();
+        if (output_path)
+            SetStandardOutputPath(output_path);
+    }
+    const FileAction *error_file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
+    if (error_file_action)
+    {
+        const char *error_path = error_file_action->GetPath();
+        if (error_path)
+            SetStandardErrorPath(error_path);
+    }
+    SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError));
+    SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR));
+    SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO));
+}
+
+void
+TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    this_->m_launch_info.SetArg0(this_->GetArg0());
+}
+
+void
+TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    Args args;
+    if (this_->GetRunArguments(args))
+        this_->m_launch_info.GetArguments() = args;
+}
+
+void
+TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    Args args;
+    if (this_->GetEnvironmentAsArgs(args))
+        this_->m_launch_info.GetEnvironmentEntries() = args;
+}
+
+void
+TargetProperties::InputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath().GetPath().c_str(), true, false);
+}
+
+void
+TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath().GetPath().c_str(), false, true);
+}
+
+void
+TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath().GetPath().c_str(), false, true);
+}
+
+void
+TargetProperties::DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    if (this_->GetDetachOnError())
+        this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError);
+    else
+        this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError);
+}
+
+void
+TargetProperties::DisableASLRValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    if (this_->GetDisableASLR())
+        this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR);
+    else
+        this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR);
+}
+
+void
+TargetProperties::DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *)
+{
+    TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
+    if (this_->GetDisableSTDIO())
+        this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO);
+    else
+        this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO);
+}
+
 //----------------------------------------------------------------------
 // Target::TargetEventData
 //----------------------------------------------------------------------
 const ConstString &
 Target::TargetEventData::GetFlavorString ()
 {
     static ConstString g_flavor ("Target::TargetEventData");
     return g_flavor;

lldb/trunk/test/tools/lldb-mi/TestMiExec.py

def test_lldbmi_exec_abort(self):
 
         # Test that program may be aborted again
         self.runCmd("-exec-abort")
         self.expect("\^done")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("reviews.llvm.org/D6965: requires this patch")
     def test_lldbmi_exec_arguments_set(self):
         """Test that 'lldb-mi --interpreter' can pass args using -exec-arguments."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
def test_lldbmi_exec_arguments_set(self):
         self.expect("\^done,value=\"5\"")
         #self.runCmd("-data-evaluate-expression argv[1]")
         #self.expect("\^done,value=\"--arg1\"")
         self.runCmd("-interpreter-exec command \"print argv[1]\"")
         self.expect("\"--arg1\"")
         #self.runCmd("-data-evaluate-expression argv[2]")
         #self.expect("\^done,value=\"2nd arg\"")
         self.runCmd("-interpreter-exec command \"print argv[2]\"")
-        self.expect("\"2nd arg\"")
+        #FIXME: lldb-mi doesn't handle inner quotes
+        self.expect("\"\\\\\\\"2nd arg\\\\\\\"\"") #FIXME: self.expect("\"2nd arg\"")
         #self.runCmd("-data-evaluate-expression argv[3]")
         #self.expect("\^done,value=\"third_arg\"")
         self.runCmd("-interpreter-exec command \"print argv[3]\"")
         self.expect("\"third_arg\"")
         #self.runCmd("-data-evaluate-expression argv[4]")
         #self.expect("\^done,value=\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
         self.runCmd("-interpreter-exec command \"print argv[4]\"")
         self.expect("\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("reviews.llvm.org/D6965: requires this patch")
     def test_lldbmi_exec_arguments_reset(self):
         """Test that 'lldb-mi --interpreter' can reset previously set args using -exec-arguments."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
def test_lldbmi_exec_step_instruction(self):
 
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-step-instruction --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("reviews.llvm.org/D6965: requires this patch")
     def test_lldbmi_exec_finish(self):
         """Test that 'lldb-mi --interpreter' works for -exec-finish."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")

lldb/trunk/test/tools/lldb-mi/TestMiInterpreterExec.py

def test_lldbmi_breakpoint_set(self):
 
         # Test that breakpoint was set properly
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("reviews.llvm.org/D6965: requires this patch")
-    def test_lldbmi_settings_set_target_run_args(self):
-        """Test that 'lldb-mi --interpreter' can set target arguments by 'setting set target.run-args' command."""
+    def test_lldbmi_settings_set_target_run_args_before(self):
+        """Test that 'lldb-mi --interpreter' can set target arguments by 'setting set target.run-args' command before than target was created."""
+
+        self.spawnLldbMi(args = None)
+
+        # Test that "settings set target.run-args" passes arguments to executable
+        #FIXME: "--arg1 \"2nd arg\" third_arg fourth=\"4th arg\"" causes an error
+        self.runCmd("-interpreter-exec console \"setting set target.run-args arg1\"")
+        self.expect("\^done")
+
+        # Load executable
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        # Run to BP_argctest
+        line = line_number('main.c', '//BP_argctest')
+        self.runCmd("-break-insert --file main.c:%d" % line)
+        self.expect("\^done")
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+
+        # Test that arguments were passed properly
+        self.expect("~\"argc=2\\\\r\\\\n\"")
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    def test_lldbmi_settings_set_target_run_args_after(self):
+        """Test that 'lldb-mi --interpreter' can set target arguments by 'setting set target.run-args' command after than target was created."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that "settings set target.run-args" passes arguments to executable

lldb/trunk/tools/lldb-mi/MICmdArgValListOfN.h

 {
     // Methods:
   public:
     /* ctor */ CMICmdArgValListOfN(void);
     /* ctor */ CMICmdArgValListOfN(const CMIUtilString &vrArgName, const bool vbMandatory, const bool vbHandleByCmd,
                                    const ArgValType_e veType);
     //
     const VecArgObjPtr_t &GetExpectedOptions(void) const;
-    template <class T1, typename T2> bool GetExpectedOption(T2 &vrwValue) const;
+    template <class T1, typename T2> bool GetExpectedOption(T2 &vrwValue, const VecArgObjPtr_t::size_type vnAt = 0) const;
 
     // Overridden:
   public:
     // From CMICmdArgValBase
     /* dtor */ virtual ~CMICmdArgValListOfN(void);
     // From CMICmdArgSet::IArg
     virtual bool Validate(CMICmdArgContext &vArgContext);
 
     // Methods:
   private:
     bool IsListOfN(const CMIUtilString &vrTxt) const;
     bool CreateList(const CMIUtilString &vrTxt);
 };
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the first argument or option value from the list of 1 or more options
 //          parsed from the command's options string.
 // Type:    Template method.
 // Args:    vrwValue    - (W) Templated type return value.
+//          vnAt        - (R) Value at the specific position.
 //          T1          - The argument value's class type of the data hold in the list of options.
 //          T2          - The type pf the variable which holds the value wanted.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed. List of object was empty.
 // Throws:  None.
 //--
 template <class T1, typename T2>
 bool
-CMICmdArgValListOfN::GetExpectedOption(T2 &vrwValue) const
+CMICmdArgValListOfN::GetExpectedOption(T2 &vrwValue, const VecArgObjPtr_t::size_type vnAt) const
 {
     const VecArgObjPtr_t &rVecOptions(GetExpectedOptions());
-    VecArgObjPtr_t::const_iterator it2 = rVecOptions.begin();
+    if (rVecOptions.size() <= vnAt)
+        return MIstatus::failure;
+
+    VecArgObjPtr_t::const_iterator it2 = rVecOptions.begin() + vnAt;
     if (it2 != rVecOptions.end())
     {
         const T1 *pOption = static_cast<T1 *>(*it2);
         vrwValue = pOption->GetValue();
         return MIstatus::success;
     }
 
     return MIstatus::failure;
 }

lldb/trunk/tools/lldb-mi/MICmdCmdExec.h

 // Overview:    CMICmdCmdExecRun                interface.
 //              CMICmdCmdExecContinue           interface.
 //              CMICmdCmdExecNext               interface.
 //              CMICmdCmdExecStep               interface.
 //              CMICmdCmdExecNextInstruction    interface.
 //              CMICmdCmdExecStepInstruction    interface.
 //              CMICmdCmdExecFinish             interface.
 //              CMICmdCmdExecInterrupt          interface.
+//              CMICmdCmdExecArguments          interface.
 //
 //              To implement new MI commands derive a new command class from the command base
 //              class. To enable the new command for interpretation add the new command class
 //              to the command factory. The files of relevance are:
 //                  MICmdCommands.cpp
 //                  MICmdBase.h / .cpp
 //                  MICmdCmd.h / .cpp
 //              For an introduction to adding a new command see CMICmdCmdSupportInfoMiCmdQuery
public:
     virtual bool Acknowledge(void);
     // From CMICmnBase
     /* dtor */ virtual ~CMICmdCmdExecInterrupt(void);
 
     // Attributes:
   private:
     lldb::SBCommandReturnObject m_lldbResult;
 };
+
+//++ ============================================================================
+// Details: MI command class. MI commands derived from the command base class.
+//          *this class implements MI command "exec-arguments".
+// Gotchas: None.
+// Authors: Ilia Kirianovskii 25/11/2014.
+// Changes: None.
+//--
+class CMICmdCmdExecArguments : public CMICmdBase
+{
+    // Statics:
+  public:
+    // Required by the CMICmdFactory when registering *this command
+    static CMICmdBase *CreateSelf(void);
+
+    // Methods:
+  public:
+    /* ctor */ CMICmdCmdExecArguments(void);
+
+    // Overridden:
+  public:
+    // From CMICmdInvoker::ICmd
+    virtual bool Execute(void);
+    virtual bool Acknowledge(void);
+    virtual bool ParseArgs(void);
+    // From CMICmnBase
+    /* dtor */ virtual ~CMICmdCmdExecArguments(void);
+
+    // Attributes:
+  private:
+    const CMIUtilString m_constStrArgArguments;
+};

lldb/trunk/tools/lldb-mi/MICmdCmdExec.cpp

 // Overview:    CMICmdCmdExecRun                implementation.
 //              CMICmdCmdExecContinue           implementation.
 //              CMICmdCmdExecNext               implementation.
 //              CMICmdCmdExecStep               implementation.
 //              CMICmdCmdExecNextInstruction    implementation.
 //              CMICmdCmdExecStepInstruction    implementation.
 //              CMICmdCmdExecFinish             implementation.
 //              CMICmdCmdExecInterrupt          implementation.
+//              CMICmdCmdExecArguments          implementation.
 //
 // Environment: Compilers:  Visual C++ 12.
 //                          gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
 //              Libraries:  See MIReadmetxt.
 //
 // Copyright:   None.
 //--
 

 // Throws:  None.
 //--
 bool
 CMICmdCmdExecRun::Execute(void)
 {
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     lldb::SBError error;
     lldb::SBStream errMsg;
-    uint32_t launch_flags = lldb::LaunchFlags::eLaunchFlagDebug;
-    lldb::SBProcess process = rSessionInfo.GetTarget().Launch(rSessionInfo.GetListener(), nullptr, nullptr, nullptr, nullptr,
-                                                              nullptr, nullptr, launch_flags, false, error);
-
+    lldb::SBLaunchInfo launchInfo = rSessionInfo.GetTarget().GetLaunchInfo();
+    launchInfo.SetListener(rSessionInfo.GetListener());
+    lldb::SBProcess process = rSessionInfo.GetTarget().Launch(launchInfo, error);
     if ((!process.IsValid()) || (error.Fail()))
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_PROCESS), m_cmdData.strMiCmd.c_str(), errMsg.GetData()));
         return MIstatus::failure;
     }
 
     if (!CMIDriver::Instance().SetDriverStateRunningDebugging())
     {

 // Return:  CMICmdBase * - Pointer to a new command.
 // Throws:  None.
 //--
 CMICmdBase *
 CMICmdCmdExecInterrupt::CreateSelf(void)
 {
     return new CMICmdCmdExecInterrupt();
 }
+
+//---------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------------
+
+//++ ------------------------------------------------------------------------------------
+// Details: CMICmdCmdExecArguments constructor.
+// Type:    Method.
+// Args:    None.
+// Return:  None.
+// Throws:  None.
+//--
+CMICmdCmdExecArguments::CMICmdCmdExecArguments(void)
+    : m_constStrArgArguments("arguments")
+{
+    // Command factory matches this name with that received from the stdin stream
+    m_strMiCmd = "exec-arguments";
+
+    // Required by the CMICmdFactory when registering *this command
+    m_pSelfCreatorFn = &CMICmdCmdExecArguments::CreateSelf;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: CMICmdCmdExecArguments destructor.
+// Type:    Overrideable.
+// Args:    None.
+// Return:  None.
+// Throws:  None.
+//--
+CMICmdCmdExecArguments::~CMICmdCmdExecArguments(void)
+{
+}
+
+//++ ------------------------------------------------------------------------------------
+// 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.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool
+CMICmdCmdExecArguments::ParseArgs(void)
+{
+    bool bOk = m_setCmdArgs.Add(
+        *(new CMICmdArgValListOfN(m_constStrArgArguments, false, true, CMICmdArgValListBase::eArgValType_StringAnything)));
+    return (bOk && ParseValidateCmdOptions());
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: The invoker requires this function. The command does work in this function.
+//          The command is likely to communicate with the LLDB SBDebugger in here.
+// Type:    Overridden.
+// Args:    None.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool
+CMICmdCmdExecArguments::Execute(void)
+{
+    CMICMDBASE_GETOPTION(pArgArguments, ListOfN, m_constStrArgArguments);
+
+    CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
+    lldb::SBTarget sbTarget = rSessionInfo.GetTarget();
+    if (!sbTarget.IsValid())
+    {
+        SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_TARGET_CURRENT), m_cmdData.strMiCmd.c_str()));
+        return MIstatus::failure;
+    }
+
+    lldb::SBLaunchInfo sbLaunchInfo = sbTarget.GetLaunchInfo();
+    sbLaunchInfo.SetArguments(NULL, false);
+
+    CMIUtilString strArg;
+    size_t nArgIndex = 0;
+    while (pArgArguments->GetExpectedOption<CMICmdArgValString, CMIUtilString>(strArg, nArgIndex))
+    {
+        const char *argv[2] = { strArg.c_str(), NULL };
+        sbLaunchInfo.SetArguments(argv, true);
+        ++nArgIndex;
+    }
+
+    sbTarget.SetLaunchInfo(sbLaunchInfo);
+
+    return MIstatus::success;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: The invoker requires this function. The command prepares a MI Record Result
+//          for the work carried out in the Execute().
+// Type:    Overridden.
+// Args:    None.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool
+CMICmdCmdExecArguments::Acknowledge(void)
+{
+    const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done);
+    m_miResultRecord = miRecordResult;
+
+    return MIstatus::success;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Required by the CMICmdFactory when registering *this command. The factory
+//          calls this function to create an instance of *this command.
+// Type:    Static method.
+// Args:    None.
+// Return:  CMICmdBase * - Pointer to a new command.
+// Throws:  None.
+//--
+CMICmdBase *
+CMICmdCmdExecArguments::CreateSelf(void)
+{
+    return new CMICmdCmdExecArguments();
+}

lldb/trunk/tools/lldb-mi/MICmdCommands.cpp

MICmnCommands::RegisterAll(void)
     bOk &= Register<CMICmdCmdDataEvaluateExpression>();
     bOk &= Register<CMICmdCmdDataReadMemoryBytes>();
     bOk &= Register<CMICmdCmdDataReadMemory>();
     bOk &= Register<CMICmdCmdDataListRegisterNames>();
     bOk &= Register<CMICmdCmdDataListRegisterValues>();
     bOk &= Register<CMICmdCmdDataWriteMemory>();
     bOk &= Register<CMICmdCmdEnablePrettyPrinting>();
     bOk &= Register<CMICmdCmdEnvironmentCd>();
+    bOk &= Register<CMICmdCmdExecArguments>();
     bOk &= Register<CMICmdCmdExecContinue>();
     bOk &= Register<CMICmdCmdExecInterrupt>();
     bOk &= Register<CMICmdCmdExecFinish>();
     bOk &= Register<CMICmdCmdExecNext>();
     bOk &= Register<CMICmdCmdExecNextInstruction>();
     bOk &= Register<CMICmdCmdExecRun>();
     bOk &= Register<CMICmdCmdExecStep>();
     bOk &= Register<CMICmdCmdExecStepInstruction>();