Specify a language to use when parsing expressions.

[dawn]

Summary

This patch adds the option -l/--language to the expression command, for use when setting the language options or choosing an alternate FE. If not specified, the target.language setting is used. It is the expression counterpart of http://reviews.llvm.org/D11119 which added the --language option to breakpoint set command.

[dawn]

Please review. I have another patch which depends on this one.

[clayborg]

Looks good.

[clayborg]

One thing you might want to fix is to use:

self.dbg.HandleCommand("...")

This avoids the need for the command to succeed.

[clayborg]

runCmd can take a named argument "check = False" that will stop the mandatory checking of the success of the command.

test/expression_command/options/TestExprOptions.py

36–41 ↗

(On Diff #30443)

Actually don't make tests that use runCmd for creating targets use the following code:

# Set debugger into synchronous mode
self.dbg.SetAsync(False)

# Create a target by the debugger.
exe = os.path.join(os.getcwd(), "a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)

# Set breakpoints inside and outside methods that take pointers to the containing struct.
lldbutil.run_break_set_by_file_and_line (self, self.source, line, num_expected_locations=1, loc_exact=True)

# Register our shared libraries for remote targets so they get automatically uploaded
arguments = None
environment = None 

# Now launch the process, and do not stop at entry point.
process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID)

[clayborg]

See inlined comments.

test/expression_command/options/TestExprOptions.py

46–55 ↗

(On Diff #30443)

use self.runCmd(check=False,...) instead of self.expect(...). You should actually use the "lldb.SB*" API if possible unless you are explicitly trying to test textual output from commands. Please don't use self.expect() or self.runCmd() if you can use "lldb.SB*" API calls.

[dawn]

In D11447#211105, @clayborg wrote:

See inlined comments.

I am trying to check textual output from commands. expect() doesn't take a check=False option, and runCmd() doesn't check for output afaik. It would be possible to pipe all the output and check that way, but what a major pain.

How do you suggest I get this to fly?:

self.expect("expression blabla", startstr = "error")

I want to test that lldb returns error without FAILing

[dawn]

Ah! expect takes a 'error' argument :) This works:

self.expect("expression blabla", error=True, startstr = "error")

[clayborg]

To evaluate an expression use the SB API:

threads = lldbutil.get_threads_stopped_at_breakpoint (process, breakpoint)
self.assertTrue(len(threads) == 1)
thread = threads[0]
frame = thread.GetFrameAtIndex(0)

options = lldb.SBExpressionOptions()
value = frame.EvaluateExpression ("expression blabla", options)
self.assertTrue (value.GetError().Fail())

[clayborg]

There are many tests that evaluate expressions using the SB API:

expression_command/call-restarts/TestCallThatRestarts.py
expression_command/call-throws/TestCallThatThrows.py
expression_command/char/TestExprsChar.py
expression_command/formatters/TestFormatters.py
expression_command/test/TestExprs.py
expression_command/timeout/TestCallWithTimeout.py
functionalities/asan/TestMemoryHistory.py
functionalities/expr-doesnt-deadlock/TestExprDoesntBlock.py
functionalities/inline-stepping/TestInlineStepping.py
functionalities/watchpoint/watchpoint_commands/command/TestWatchpointCommandPython.py
lang/c/stepping/TestStepAndBreakpoints.py
lang/cpp/dynamic-value/TestDynamicValue.py
lang/objc/blocks/TestObjCIvarsInBlocks.py
lang/objc/objc-checker/TestObjCCheckers.py
lang/objc/objc-class-method/TestObjCClassMethod.py
lang/objc/objc-dynamic-value/TestObjCDynamicValue.py
lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py
lang/objc/objc-property/TestObjCProperty.py
lang/objc/objc-static-method/TestObjCStaticMethod.py
lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py
lang/objc/objc-struct-argument/TestObjCStructArgument.py
lang/objc/objc-struct-return/TestObjCStructReturn.py
lang/objc/objc-super/TestObjCSuper.py
lang/swift/different_clang_flags/TestSwiftDifferentClangFlags.py
lang/swift/expression/access_control/TestExpressionAccessControl.py
lang/swift/expression/classes/TestExpressionInMethods.py
lang/swift/expression/errors/TestExpressionErrors.py
lang/swift/expression/generic/TestGenericExpressions.py
lang/swift/expression/scopes/TestExpressionScopes.py
lang/swift/expression/simple/TestSimpleExpressions.py
lang/swift/expression/static/TestGenericExpressions.py
lang/swift/file_private/TestFilePrivate.py
lang/swift/struct_change_rerun/TestSwiftStructChangeRerun.py
lang/swift/swiftieformatting/TestSwiftieFormatting.py
lang/swift/variables/globals/TestSwiftGlobals.py
lang/swift/variables/inout/TestInOutVariables.py
lldbinline.py
python_api/default-constructor/sb_frame.py
python_api/frame/TestFrames.py
python_api/value/TestValueAPI.py

[dawn]

Test case was fixed as directed.

[clayborg]

Please use SB API calls for expression evaluation instead of self.expect calls.

test/expression_command/options/TestExprOptions.py

57–87 ↗

(On Diff #30546)

Please use SB API calls for expression evaluation instead of self.expect calls.

[spyffe]

This all looks all right to me, except that we should print errors if C or Objective-C is requested, because we can only run in C++ or Objective-C++ mode.
We should be careful to switch away from ObjC++ only on request, and not based on the current compilation unit's language, but that's a different patch.

[dawn]

Changed test to use SB APIs.

[clayborg]

Looks good, thanks for fixing everything.

lldb/trunk/source/Commands/CommandObjectExpression.h

public:
         static OptionDefinition g_option_table[];
         bool        unwind_on_error;
         bool        ignore_breakpoints;
         bool        show_types;
         bool        show_summary;
         bool        debug;
         uint32_t    timeout;
         bool        try_all_threads;
+        lldb::LanguageType language;
         LanguageRuntimeDescriptionDisplayVerbosity m_verbosity;
     };
 
     CommandObjectExpression (CommandInterpreter &interpreter);
 
     virtual
     ~CommandObjectExpression ();
 

lldb/trunk/source/Commands/CommandObjectExpression.cpp

 OptionDefinition
 CommandObjectExpression::CommandOptions::g_option_table[] =
 {
     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "all-threads",        'a', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,    "Should we run all threads if the execution doesn't complete on one thread."},
     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "ignore-breakpoints", 'i', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,    "Ignore breakpoint hits while running expressions"},
     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "timeout",            't', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeUnsignedInteger,  "Timeout value (in microseconds) for running the expression."},
     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "unwind-on-error",    'u', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBoolean,    "Clean up program state if the expression causes a crash, or raises a signal.  Note, unlike gdb hitting a breakpoint is controlled by another option (-i)."},
     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "debug",              'g', OptionParser::eNoArgument      , NULL, NULL, 0, eArgTypeNone,       "When specified, debug the JIT code by setting a breakpoint on the first instruction and forcing breakpoints to not be ignored (-i0) and no unwinding to happen on error (-u0)."},
+    { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "language",           'l', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeLanguage,   "Specifies the Language to use when parsing the expression.  If not set the target.language setting is used." },
     { LLDB_OPT_SET_1, false, "description-verbosity", 'v', OptionParser::eOptionalArgument, NULL, g_description_verbosity_type, 0, eArgTypeDescriptionVerbosity,        "How verbose should the output of this expression be, if the object description is asked for."},
 };
 
 
 uint32_t
 CommandObjectExpression::CommandOptions::GetNumDefinitions ()
 {
     return llvm::array_lengthof(g_option_table);
 }
 
 Error
 CommandObjectExpression::CommandOptions::SetOptionValue (CommandInterpreter &interpreter,
                                                          uint32_t option_idx,
                                                          const char *option_arg)
 {
     Error error;
 
     const int short_option = g_option_table[option_idx].short_option;
 
     switch (short_option)
     {
-      //case 'l':
-      //if (language.SetLanguageFromCString (option_arg) == false)
-      //{
-      //    error.SetErrorStringWithFormat("invalid language option argument '%s'", option_arg);
-      //}
-      //break;
+    case 'l':
+        language = LanguageRuntime::GetLanguageTypeFromString (option_arg);
+        if (language == eLanguageTypeUnknown)
+            error.SetErrorStringWithFormat ("unknown language type: '%s' for expression", option_arg);
+        break;
 
     case 'a':
         {
             bool success;
             bool result;
             result = Args::StringToBoolean(option_arg, true, &success);
             if (!success)
                 error.SetErrorStringWithFormat("invalid all-threads value setting: \"%s\"", option_arg);
else
         ignore_breakpoints = true;
         unwind_on_error = true;
     }
     
     show_summary = true;
     try_all_threads = true;
     timeout = 0;
     debug = false;
+    language = eLanguageTypeUnknown;
     m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact;
 }
 
 const OptionDefinition*
 CommandObjectExpression::CommandOptions::GetDefinitions ()
 {
     return g_option_table;
 }
 
 CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interpreter) :
     CommandObjectRaw (interpreter,
                       "expression",
-                      "Evaluate a C/ObjC/C++ expression in the current program context, using user defined variables and variables currently in scope.",
+                      "Evaluate an expression in the current program context, using user defined variables and variables currently in scope.",
                       NULL,
                       eCommandProcessMustBePaused | eCommandTryTargetAPILock),
     IOHandlerDelegate (IOHandlerDelegate::Completion::Expression),
     m_option_group (interpreter),
     m_format_options (eFormatDefault),
     m_command_options (),
     m_expr_line_count (0),
     m_expr_lines ()
if (target)
         options.SetCoerceToId(m_varobj_options.use_objc);
         options.SetUnwindOnError(m_command_options.unwind_on_error);
         options.SetIgnoreBreakpoints (m_command_options.ignore_breakpoints);
         options.SetKeepInMemory(keep_in_memory);
         options.SetUseDynamic(m_varobj_options.use_dynamic);
         options.SetTryAllThreads(m_command_options.try_all_threads);
         options.SetDebug(m_command_options.debug);
         
+        // If the language was not specified, set it from target's properties
+        if (m_command_options.language != eLanguageTypeUnknown)
+            options.SetLanguage(m_command_options.language);
+        else
+            options.SetLanguage(target->GetLanguage());
+
         // If there is any chance we are going to stop and want to see
         // what went wrong with our expression, we should generate debug info
         if (!m_command_options.ignore_breakpoints ||
             !m_command_options.unwind_on_error)
             options.SetGenerateDebugInfo(true);
         
         if (m_command_options.timeout > 0)
             options.SetTimeoutUsec(m_command_options.timeout);

lldb/trunk/test/expression_command/options/Makefile

+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp foo.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/trunk/test/expression_command/options/TestExprOptions.py

+"""
+Test expression command options.
+
+Test cases:
+
+o test_expr_options:
+  Test expression command options.
+"""
+
+import os, time
+import unittest2
+import lldb
+import lldbutil
+from lldbtest import *
+
+class ExprOptionsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+        self.main_source = "main.cpp"
+        self.main_source_spec = lldb.SBFileSpec (self.main_source)
+        self.line = line_number('main.cpp', '// breakpoint_in_main')
+        self.exe = os.path.join(os.getcwd(), "a.out")
+
+    def test_expr_options(self):
+        """These expression command options should work as expected."""
+        self.buildDefault()
+
+        # Set debugger into synchronous mode
+        self.dbg.SetAsync(False)
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTarget(self.exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        # Set breakpoints inside main.
+        breakpoint = target.BreakpointCreateBySourceRegex('// breakpoint_in_main', self.main_source_spec)
+        self.assertTrue(breakpoint)
+
+        # Now launch the process, and do not stop at entry point.
+        process = target.LaunchSimple(None, None, self.get_process_working_directory())
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint)
+        self.assertEqual(len(threads), 1)
+
+        frame = threads[0].GetFrameAtIndex(0)
+        options = lldb.SBExpressionOptions()
+
+        # -- test --language on ObjC builtin type using the SB API's --
+        # Make sure we can evaluate the ObjC builtin type 'id':
+        val = frame.EvaluateExpression('id my_id = 0; my_id')
+        self.assertTrue(val.IsValid())
+        self.assertTrue(val.GetError().Success())
+        self.assertEqual(val.GetValueAsUnsigned(0), 0)
+        self.DebugSBValue(val)
+
+        # Make sure it still works if language is set to ObjC:
+        options.SetLanguage(lldb.eLanguageTypeObjC)
+        val = frame.EvaluateExpression('id my_id = 0; my_id', options)
+        self.assertTrue(val.IsValid())
+        self.assertTrue(val.GetError().Success())
+        self.assertEqual(val.GetValueAsUnsigned(0), 0)
+        self.DebugSBValue(val)
+
+        # Make sure it fails if language is set to C:
+        options.SetLanguage(lldb.eLanguageTypeC)
+        val = frame.EvaluateExpression('id my_id = 0; my_id', options)
+        self.assertTrue(val.IsValid())
+        self.assertFalse(val.GetError().Success())
+
+        # -- test --language on C++ expression using the SB API's --
+        # Make sure we can evaluate 'ns::func'.
+        val = frame.EvaluateExpression('ns::func')
+        self.assertTrue(val.IsValid())
+        self.assertTrue(val.GetError().Success())
+        self.DebugSBValue(val)
+
+        # Make sure it still works if language is set to C++:
+        options.SetLanguage(lldb.eLanguageTypeC_plus_plus)
+        val = frame.EvaluateExpression('ns::func', options)
+        self.assertTrue(val.IsValid())
+        self.assertTrue(val.GetError().Success())
+        self.DebugSBValue(val)
+
+        # Make sure it fails if language is set to C:
+        options.SetLanguage(lldb.eLanguageTypeC)
+        val = frame.EvaluateExpression('ns::func', options)
+        self.assertTrue(val.IsValid())
+        self.assertFalse(val.GetError().Success())
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

lldb/trunk/test/expression_command/options/foo.cpp

+namespace ns {
+    int func(void)
+    {
+        return 0;
+    }
+}
+
+extern "C" int foo(void)
+{
+    return ns::func();
+}

lldb/trunk/test/expression_command/options/main.cpp

+extern "C" int foo(void);
+static int static_value = 0;
+
+int
+bar()
+{
+    static_value++;
+    return static_value;
+}
+
+int main (int argc, char const *argv[])
+{
+    bar(); // breakpoint_in_main
+    return foo();
+}