Expose top-level expressions via the LLDB command line and public API

[spyffe]

Summary

A recent series of commits have added the infrastructure to support top-level expressions in LLDB; this patch exposes and tests the functionality.

It is exposed via a new argument to expression, -p / --top-level. When this command is provided, the expression is compiled and injected into the process via the JIT, and the resultant declarations and types are stored. However, only static initializers are run; there is no concept of a top-level expression. The intent is that later code can use the variables, functions, and classes defined by these expressions.

I've also added a testcase that verifies that top-level code acts exactly the same way as if it were written in a source file. Complicated inline functions are also included. This testcase requires a clang patch (fixing some missing cases in ASTImporter) to work correctly, but it should give you an idea of what I expect to work.

[jingham]

Looks good to me too.

[ldrumm]

Hi Sean

Thanks for you patience - just got back from holiday. This looks good in general, but I have a few minor nitpicks that I think are worth a look.

L

include/lldb/API/SBExpressionOptions.h

118

Please make b a more descriptive name, and perhaps add documentation for these methods.

packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py

11

os and time appear to be unused imports and may be removed

67

This parsing of expressions can be simplified to the following:

with open("test.cpp") as f:
    expressions = f.read().split("// --")

This also has the nice property of closing the file automatically.

81

I'm not sure about whether LLVM dictates a special style for Python code, but my preference would be to follow the spirit of PEP8 i.e. result_from_top_level = ..., reformat the spaces before parens for function calls, stick to 80columns etc.

If however LLDB uses some other style for Python, please ignore me :)

source/API/SBExpressionOptions.cpp

207

As above, I feel b should be renamed - perhaps top_level?

include/lldb/API/SBExpressionOptions.h

 
     void
     SetPrefix (const char *prefix);
+    
+    bool
+    GetTopLevel ();
+    
+    void
+    SetTopLevel (bool b = true);
 
 protected:
 

include/lldb/Target/Target.h

 {
 public:
     static const uint32_t default_timeout = 500000;
+    static const ExecutionPolicy default_execution_policy = eExecutionPolicyOnlyWhenNeeded;
+    
     EvaluateExpressionOptions() :
-        m_execution_policy(eExecutionPolicyOnlyWhenNeeded),
+        m_execution_policy(default_execution_policy),
         m_language (lldb::eLanguageTypeUnknown),
         m_prefix (), // A prefix specific to this expression that is added after the prefix from the settings (if any)
         m_coerce_to_id (false),

packages/Python/lldbsuite/test/expression_command/top-level/Makefile

+LEVEL = ../../make
+
+default: a.out dummy
+
+CXX_SOURCES := main.cpp test.cpp
+
+dummy: dummy.cpp
+
+clean::
+  rm -rf dummy dummy.dSYM
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/expression_command/top-level/TestTopLevelExprs.py

+"""
+Test top-level expressions.
+"""
+
+from __future__ import print_function
+
+
+
+import unittest2
+
+import os, time
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TopLevelExpressionsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break for main.c.
+        self.line = line_number('main.cpp',
+                                '// Set breakpoint here')
+        self.dummy_line = line_number('dummy.cpp',
+                                      '// Set breakpoint here')
+
+        # Disable confirmation prompt to avoid infinite wait
+        self.runCmd("settings set auto-confirm true")
+        self.addTearDownHook(lambda: self.runCmd("settings clear auto-confirm"))
+
+
+    def build_and_run(self):
+        """Test top-level expressions."""
+        self.build()
+
+        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=False)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+    def run_dummy(self):
+        self.runCmd("file dummy", CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_file_and_line (self, "dummy.cpp", self.dummy_line, num_expected_locations=1, loc_exact=False)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+    @add_test_categories(['pyapi'])
+    def test_top_level_expressions(self):
+        self.build_and_run()
+
+        resultFromCode = self.frame().EvaluateExpression("doTest()").GetValueAsUnsigned()
+
+        self.runCmd("kill")
+
+        self.run_dummy()
+
+        codeFile = open('test.cpp', 'r')
+
+        expressions = []
+        current_expression = ""
+
+        for line in codeFile:
+            if line.startswith("// --"):
+                expressions.append(current_expression)
+                current_expression = ""
+            else:
+                current_expression += line
+
+        options = lldb.SBExpressionOptions()
+        options.SetLanguage(lldb.eLanguageTypeC_plus_plus)
+        options.SetTopLevel(True)
+
+        for expression in expressions:
+            self.frame().EvaluateExpression(expression, options)
+
+        resultFromTopLevel = self.frame().EvaluateExpression("doTest()").GetValueAsUnsigned()
+
+        self.assertEqual(resultFromCode, resultFromTopLevel)

packages/Python/lldbsuite/test/expression_command/top-level/dummy.cpp

+#include <stdio.h>
+
+int main()
+{
+    printf("This is a dummy\n"); // Set breakpoint here   
+    return 0;
+}

packages/Python/lldbsuite/test/expression_command/top-level/main.cpp

+#include <stdio.h>
+
+extern int doTest();
+
+int main()
+{
+    printf("%d\n", doTest()); // Set breakpoint here   
+    return 0;
+}

packages/Python/lldbsuite/test/expression_command/top-level/test.cpp

+class MyClass
+{
+public:
+  int memberResult()
+  {
+    return 1;
+  }
+  static int staticResult()
+  {
+    return 1;
+  }
+  int externResult();
+};
+
+// --
+
+int MyClass::externResult()
+{
+  return 1;
+}
+
+// --
+
+MyClass m;
+
+// --
+
+enum MyEnum {
+  myEnumOne = 1,
+  myEnumTwo,
+  myEnumThree
+};
+
+// --
+
+class AnotherClass
+{
+public:
+    __attribute__ ((always_inline)) int complicatedFunction() 
+    {
+        struct {
+            int i;
+        } s = { 15 };
+    
+        int as[4] = { 2, 3, 4, 5 };
+    
+        for (signed char a : as)
+        {
+            s.i -= a;
+        }
+    
+        return s.i;
+    }
+};
+
+// --
+
+int doTest()
+{
+    return m.memberResult() + MyClass::staticResult() + m.externResult() + MyEnum::myEnumThree + myEnumOne + AnotherClass().complicatedFunction();
+}
+
+// --

source/API/SBExpressionOptions.cpp

     return m_opaque_ap->SetPrefix(prefix);
 }
 
+bool
+SBExpressionOptions::GetTopLevel ()
+{
+    return m_opaque_ap->GetExecutionPolicy() == eExecutionPolicyTopLevel;
+}
+
+void
+SBExpressionOptions::SetTopLevel (bool b)
+{
+    m_opaque_ap->SetExecutionPolicy(b ? eExecutionPolicyTopLevel : m_opaque_ap->default_execution_policy);
+}
+
 EvaluateExpressionOptions *
 SBExpressionOptions::get() const
 {

source/Commands/CommandObjectExpression.h

         // Options table: Required for subclasses of Options.
 
         static OptionDefinition g_option_table[];
+        bool        top_level;
         bool        unwind_on_error;
         bool        ignore_breakpoints;
         bool        show_types;

source/Commands/CommandObjectExpression.cpp

     { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "debug",              'g', OptionParser::eNoArgument      , nullptr, nullptr, 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, nullptr, nullptr, 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, nullptr, g_description_verbosity_type, 0, eArgTypeDescriptionVerbosity,        "How verbose should the output of this expression be, if the object description is asked for."},
+    { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "top-level",          'p', OptionParser::eNoArgument      , NULL, NULL, 0, eArgTypeNone,       "Interpret the expression as top-level definitions rather than code to be immediately executed."}
 };
 
 uint32_t

         unwind_on_error = false;
         ignore_breakpoints = false;
         break;
+    
+    case 'p':
+        top_level = true;
+        break;
 
     default:
         error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);

     debug = false;
     language = eLanguageTypeUnknown;
     m_verbosity = eLanguageRuntimeDescriptionDisplayVerbosityCompact;
+    top_level = false;
 }
 
 const OptionDefinition*

         options.SetTryAllThreads(m_command_options.try_all_threads);
         options.SetDebug(m_command_options.debug);
         options.SetLanguage(m_command_options.language);
+        if (m_command_options.top_level)
+            options.SetExecutionPolicy(eExecutionPolicyTopLevel);
 
         // 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