vendor/lldb/lldb-trunk-r351319

33 files changed, 630 insertions, 192 deletions

diff --git a/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py b/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py
index 6a8fb5db5439..1108b1215329 100644
--- a/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py
+++ b/packages/Python/lldbsuite/test/expression_command/anonymous-struct/TestCallUserAnonTypedef.py
@@ -23,7 +23,6 @@ class TestExprLookupAnonStructTypedef(TestBase):
         # Find the breakpoint
         self.line = line_number('main.cpp', '// lldb testsuite break')
 
-    @expectedFailureAll(oslist=["windows"])
     @expectedFailureAll(
         oslist=['linux'],
         archs=['arm'],
diff --git a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallBuiltinFunction.py b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallBuiltinFunction.py
new file mode 100644
index 000000000000..87787f3479a2
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallBuiltinFunction.py
@@ -0,0 +1,53 @@
+"""
+Tests calling builtin functions using expression evaluation.
+"""
+
+from __future__ import print_function
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class ExprCommandCallBuiltinFunction(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # Builtins are expanded by Clang, so debug info shouldn't matter.
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def setUp(self):
+        TestBase.setUp(self)
+        # Find the line number to break for main.c.
+        self.line = line_number(
+            'main.cpp',
+            '// Please test these expressions while stopped at this line:')
+
+    def test(self):
+        self.build()
+
+        # Set breakpoint in main and run exe
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+        lldbutil.run_break_set_by_file_and_line(
+            self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        interp = self.dbg.GetCommandInterpreter()
+        result = lldb.SBCommandReturnObject()
+
+        # Test different builtin functions.
+
+        interp.HandleCommand("expr __builtin_isinf(0.0f)", result)
+        self.assertEqual(result.GetOutput(), "(int) $0 = 0\n")
+
+        interp.HandleCommand("expr __builtin_isnormal(0.0f)", result)
+        self.assertEqual(result.GetOutput(), "(int) $1 = 0\n")
+
+        interp.HandleCommand("expr __builtin_constant_p(1)", result)
+        self.assertEqual(result.GetOutput(), "(int) $2 = 1\n")
+
+        interp.HandleCommand("expr __builtin_abs(-14)", result)
+        self.assertEqual(result.GetOutput(), "(int) $3 = 14\n")
diff --git a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py
index 63511779a927..d832983bdb64 100644
--- a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py
+++ b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallStopAndContinue.py
@@ -6,7 +6,6 @@ from __future__ import print_function
 
 
 import lldb
-from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
@@ -24,10 +23,6 @@ class ExprCommandCallStopContinueTestCase(TestBase):
             '// Please test these expressions while stopped at this line:')
         self.func_line = line_number('main.cpp', '{5, "five"}')
 
-    @expectedFlakeyDarwin("llvm.org/pr20274")
-    @expectedFailureAll(
-        oslist=["windows"],
-        bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test(self):
         """Test gathering result from interrupted function call."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py
index ff3bd99ced99..0eb7086b6160 100644
--- a/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py
+++ b/packages/Python/lldbsuite/test/expression_command/call-function/TestCallUserDefinedFunction.py
@@ -28,10 +28,6 @@ class ExprCommandCallUserDefinedFunction(TestBase):
             'main.cpp',
             '// Please test these expressions while stopped at this line:')
 
-    @expectedFlakeyDsym("llvm.org/pr20274")
-    @expectedFailureAll(
-        oslist=["windows"],
-        bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test(self):
         """Test return values of user defined function calls."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py b/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py
index b328ece6d39c..a9679b7dd368 100644
--- a/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py
+++ b/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py
@@ -41,7 +41,6 @@ class ExprCharTestCase(TestBase):
         self.assertTrue(value.GetError().Success())
         self.assertEqual(value.GetValueAsSigned(0), 3)
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_default_char(self):
         self.do_test()
 
@@ -52,7 +51,6 @@ class ExprCharTestCase(TestBase):
             "powerpc64le",
             "s390x"],
         bugnumber="llvm.org/pr23069")
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_signed_char(self):
         self.do_test(dictionary={'CFLAGS_EXTRAS': '-fsigned-char'})
 
@@ -64,7 +62,6 @@ class ExprCharTestCase(TestBase):
             'armv7',
             'armv7k'],
         bugnumber="llvm.org/pr23069, <rdar://problem/28721938>")
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     @expectedFailureAll(triple='mips*', bugnumber="llvm.org/pr23069")
     def test_unsigned_char(self):
         self.do_test(dictionary={'CFLAGS_EXTRAS': '-funsigned-char'})
diff --git a/packages/Python/lldbsuite/test/expression_command/completion/.categories b/packages/Python/lldbsuite/test/expression_command/completion/.categories
new file mode 100644
index 000000000000..3a3f4df6416b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/completion/.categories
@@ -0,0 +1 @@
+cmdline
diff --git a/packages/Python/lldbsuite/test/expression_command/completion/Makefile b/packages/Python/lldbsuite/test/expression_command/completion/Makefile
new file mode 100644
index 000000000000..6fc26a9193f0
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/completion/Makefile
@@ -0,0 +1,5 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp other.cpp
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/expression_command/completion/TestExprCompletion.py b/packages/Python/lldbsuite/test/expression_command/completion/TestExprCompletion.py
new file mode 100644
index 000000000000..536b9e0abcdd
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/completion/TestExprCompletion.py
@@ -0,0 +1,257 @@
+"""
+Test the lldb command line completion mechanism for the 'expr' command.
+"""
+
+from __future__ import print_function
+
+import random
+import os
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbplatform
+from lldbsuite.test import lldbutil
+
+class CommandLineExprCompletionTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_expr_completion(self):
+        self.build()
+        self.main_source = "main.cpp"
+        self.main_source_spec = lldb.SBFileSpec(self.main_source)
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        # Try the completion before we have a context to complete on.
+        self.assume_no_completions('expr some_expr')
+        self.assume_no_completions('expr ')
+        self.assume_no_completions('expr f')
+
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                          '// Break here', self.main_source_spec)
+
+        # Completing member functions
+        self.complete_exactly('expr some_expr.FooNoArgs',
+                              'expr some_expr.FooNoArgsBar()')
+        self.complete_exactly('expr some_expr.FooWithArgs',
+                              'expr some_expr.FooWithArgsBar(')
+        self.complete_exactly('expr some_expr.FooWithMultipleArgs',
+                              'expr some_expr.FooWithMultipleArgsBar(')
+        self.complete_exactly('expr some_expr.FooUnderscore',
+                              'expr some_expr.FooUnderscoreBar_()')
+        self.complete_exactly('expr some_expr.FooNumbers',
+                              'expr some_expr.FooNumbersBar1()')
+        self.complete_exactly('expr some_expr.StaticMemberMethod',
+                              'expr some_expr.StaticMemberMethodBar()')
+
+        # Completing static functions
+        self.complete_exactly('expr Expr::StaticMemberMethod',
+                              'expr Expr::StaticMemberMethodBar()')
+
+        # Completing member variables
+        self.complete_exactly('expr some_expr.MemberVariab',
+                              'expr some_expr.MemberVariableBar')
+
+        # Multiple completions
+        self.completions_contain('expr some_expr.',
+                                 ['some_expr.FooNumbersBar1()',
+                                  'some_expr.FooUnderscoreBar_()',
+                                  'some_expr.FooWithArgsBar(',
+                                  'some_expr.MemberVariableBar'])
+
+        self.completions_contain('expr some_expr.Foo',
+                                 ['some_expr.FooNumbersBar1()',
+                                  'some_expr.FooUnderscoreBar_()',
+                                  'some_expr.FooWithArgsBar('])
+
+        self.completions_contain('expr ',
+                                 ['static_cast',
+                                  'reinterpret_cast',
+                                  'dynamic_cast'])
+
+        self.completions_contain('expr 1 + ',
+                                 ['static_cast',
+                                  'reinterpret_cast',
+                                  'dynamic_cast'])
+
+        # Completion expr without spaces
+        # This is a bit awkward looking for the user, but that's how
+        # the completion API works at the moment.
+        self.completions_contain('expr 1+',
+                                 ['1+some_expr', "1+static_cast"])
+
+        # Test with spaces
+        self.complete_exactly('expr   some_expr .FooNoArgs',
+                              'expr   some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr  some_expr .FooNoArgs',
+                              'expr  some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr some_expr .FooNoArgs',
+                              'expr some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr some_expr. FooNoArgs',
+                              'expr some_expr. FooNoArgsBar()')
+        self.complete_exactly('expr some_expr . FooNoArgs',
+                              'expr some_expr . FooNoArgsBar()')
+        self.complete_exactly('expr Expr :: StaticMemberMethod',
+                              'expr Expr :: StaticMemberMethodBar()')
+        self.complete_exactly('expr Expr ::StaticMemberMethod',
+                              'expr Expr ::StaticMemberMethodBar()')
+        self.complete_exactly('expr Expr:: StaticMemberMethod',
+                              'expr Expr:: StaticMemberMethodBar()')
+
+        # Test that string literals don't break our parsing logic.
+        self.complete_exactly('expr const char *cstr = "some_e"; char c = *cst',
+                              'expr const char *cstr = "some_e"; char c = *cstr')
+        self.complete_exactly('expr const char *cstr = "some_e" ; char c = *cst',
+                              'expr const char *cstr = "some_e" ; char c = *cstr')
+        # Requesting completions inside an incomplete string doesn't provide any
+        # completions.
+        self.complete_exactly('expr const char *cstr = "some_e',
+                              'expr const char *cstr = "some_e')
+
+        # Completing inside double dash should do nothing
+        self.assume_no_completions('expr -i0 -- some_expr.', 10)
+        self.assume_no_completions('expr -i0 -- some_expr.', 11)
+
+        # Test with expr arguments
+        self.complete_exactly('expr -i0 -- some_expr .FooNoArgs',
+                              'expr -i0 -- some_expr .FooNoArgsBar()')
+        self.complete_exactly('expr  -i0 -- some_expr .FooNoArgs',
+                              'expr  -i0 -- some_expr .FooNoArgsBar()')
+
+        # Addrof and deref
+        self.complete_exactly('expr (*(&some_expr)).FooNoArgs',
+                              'expr (*(&some_expr)).FooNoArgsBar()')
+        self.complete_exactly('expr (*(&some_expr)) .FooNoArgs',
+                              'expr (*(&some_expr)) .FooNoArgsBar()')
+        self.complete_exactly('expr (* (&some_expr)) .FooNoArgs',
+                              'expr (* (&some_expr)) .FooNoArgsBar()')
+        self.complete_exactly('expr (* (& some_expr)) .FooNoArgs',
+                              'expr (* (& some_expr)) .FooNoArgsBar()')
+
+        # Addrof and deref (part 2)
+        self.complete_exactly('expr (&some_expr)->FooNoArgs',
+                              'expr (&some_expr)->FooNoArgsBar()')
+        self.complete_exactly('expr (&some_expr) ->FooNoArgs',
+                              'expr (&some_expr) ->FooNoArgsBar()')
+        self.complete_exactly('expr (&some_expr) -> FooNoArgs',
+                              'expr (&some_expr) -> FooNoArgsBar()')
+        self.complete_exactly('expr (&some_expr)-> FooNoArgs',
+                              'expr (&some_expr)-> FooNoArgsBar()')
+
+        # Builtin arg
+        self.complete_exactly('expr static_ca',
+                              'expr static_cast')
+
+        # From other files
+        self.complete_exactly('expr fwd_decl_ptr->Hidden',
+                              'expr fwd_decl_ptr->HiddenMember')
+
+
+        # Types
+        self.complete_exactly('expr LongClassNa',
+                              'expr LongClassName')
+        self.complete_exactly('expr LongNamespaceName::NestedCla',
+                              'expr LongNamespaceName::NestedClass')
+
+        # Namespaces
+        self.complete_exactly('expr LongNamespaceNa',
+                              'expr LongNamespaceName::')
+
+        # Multiple arguments
+        self.complete_exactly('expr &some_expr + &some_e',
+                              'expr &some_expr + &some_expr')
+        self.complete_exactly('expr SomeLongVarNameWithCapitals + SomeLongVarName',
+                              'expr SomeLongVarNameWithCapitals + SomeLongVarNameWithCapitals')
+        self.complete_exactly('expr SomeIntVar + SomeIntV',
+                              'expr SomeIntVar + SomeIntVar')
+
+        # Multiple statements
+        self.complete_exactly('expr long LocalVariable = 0; LocalVaria',
+                              'expr long LocalVariable = 0; LocalVariable')
+
+        # Custom Decls
+        self.complete_exactly('expr auto l = [](int LeftHandSide, int bx){ return LeftHandS',
+                              'expr auto l = [](int LeftHandSide, int bx){ return LeftHandSide')
+        self.complete_exactly('expr struct LocalStruct { long MemberName; } ; LocalStruct S; S.Mem',
+                              'expr struct LocalStruct { long MemberName; } ; LocalStruct S; S.MemberName')
+
+        # Completing function call arguments
+        self.complete_exactly('expr some_expr.FooWithArgsBar(some_exp',
+                              'expr some_expr.FooWithArgsBar(some_expr')
+        self.complete_exactly('expr some_expr.FooWithArgsBar(SomeIntV',
+                              'expr some_expr.FooWithArgsBar(SomeIntVar')
+        self.complete_exactly('expr some_expr.FooWithMultipleArgsBar(SomeIntVar, SomeIntVa',
+                              'expr some_expr.FooWithMultipleArgsBar(SomeIntVar, SomeIntVar')
+
+        # Function return values
+        self.complete_exactly('expr some_expr.Self().FooNoArgs',
+                              'expr some_expr.Self().FooNoArgsBar()')
+        self.complete_exactly('expr some_expr.Self() .FooNoArgs',
+                              'expr some_expr.Self() .FooNoArgsBar()')
+        self.complete_exactly('expr some_expr.Self(). FooNoArgs',
+                              'expr some_expr.Self(). FooNoArgsBar()')
+
+    def test_expr_completion_with_descriptions(self):
+        self.build()
+        self.main_source = "main.cpp"
+        self.main_source_spec = lldb.SBFileSpec(self.main_source)
+        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                          '// Break here', self.main_source_spec)
+
+        self.check_completion_with_desc("expr ", [
+            # VarDecls have their type as description.
+            ["some_expr", "Expr &"],
+            # builtin types have no description.
+            ["int", ""],
+            ["float", ""]
+        ])
+        self.check_completion_with_desc("expr some_expr.", [
+            # Functions have their signature as description.
+            ["some_expr.Self()", "Expr &Self()"],
+            ["some_expr.operator=(", "inline Expr &operator=(const Expr &)"],
+            ["some_expr.FooNumbersBar1()", "int FooNumbersBar1()"],
+            ["some_expr.StaticMemberMethodBar()", "static int StaticMemberMethodBar()"],
+            ["some_expr.FooWithArgsBar(", "int FooWithArgsBar(int)"],
+            ["some_expr.FooNoArgsBar()", "int FooNoArgsBar()"],
+            ["some_expr.FooUnderscoreBar_()", "int FooUnderscoreBar_()"],
+            ["some_expr.FooWithMultipleArgsBar(", "int FooWithMultipleArgsBar(int, int)"],
+            ["some_expr.~Expr()", "inline ~Expr()"],
+            # FieldDecls have their type as description.
+            ["some_expr.MemberVariableBar", "int"],
+        ])
+
+    def assume_no_completions(self, str_input, cursor_pos = None):
+        interp = self.dbg.GetCommandInterpreter()
+        match_strings = lldb.SBStringList()
+        if cursor_pos is None:
+          cursor_pos = len(str_input)
+        num_matches = interp.HandleCompletion(str_input, cursor_pos, 0, -1, match_strings)
+
+        available_completions = []
+        for m in match_strings:
+            available_completions.append(m)
+
+        self.assertEquals(num_matches, 0, "Got matches, but didn't expect any: " + str(available_completions))
+
+    def completions_contain(self, str_input, items):
+        interp = self.dbg.GetCommandInterpreter()
+        match_strings = lldb.SBStringList()
+        num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
+        common_match = match_strings.GetStringAtIndex(0)
+
+        for item in items:
+            found = False
+            for m in match_strings:
+                if m == item:
+                    found = True
+            if not found:
+                # Transform match_strings to a python list with strings
+                available_completions = []
+                for m in match_strings:
+                     available_completions.append(m)
+                self.assertTrue(found, "Couldn't find completion " + item + " in completions " + str(available_completions))
diff --git a/packages/Python/lldbsuite/test/expression_command/completion/main.cpp b/packages/Python/lldbsuite/test/expression_command/completion/main.cpp
new file mode 100644
index 000000000000..908bebbebff5
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/completion/main.cpp
@@ -0,0 +1,35 @@
+namespace LongNamespaceName { class NestedClass { long m; }; }
+
+// Defined in other.cpp, we only have a forward declaration here.
+struct ForwardDecl;
+extern ForwardDecl fwd_decl;
+
+class LongClassName { long i ; };
+
+class Expr {
+public:
+    int FooNoArgsBar() { return 1; }
+    int FooWithArgsBar(int i) { return i; }
+    int FooWithMultipleArgsBar(int i, int j) { return i + j; }
+    int FooUnderscoreBar_() { return 4; }
+    int FooNumbersBar1() { return 8; }
+    int MemberVariableBar = 0;
+    Expr &Self() { return *this; }
+    static int StaticMemberMethodBar() { return 82; }
+};
+
+int main()
+{
+    LongClassName a;
+    LongNamespaceName::NestedClass NestedFoo;
+    long SomeLongVarNameWithCapitals = 44;
+    int SomeIntVar = 33;
+    Expr some_expr;
+    some_expr.FooNoArgsBar();
+    some_expr.FooWithArgsBar(1);
+    some_expr.FooUnderscoreBar_();
+    some_expr.FooNumbersBar1();
+    Expr::StaticMemberMethodBar();
+    ForwardDecl *fwd_decl_ptr = &fwd_decl;
+    return 0; // Break here
+}
diff --git a/packages/Python/lldbsuite/test/expression_command/completion/other.cpp b/packages/Python/lldbsuite/test/expression_command/completion/other.cpp
new file mode 100644
index 000000000000..1f8a488639b9
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/completion/other.cpp
@@ -0,0 +1,4 @@
+struct ForwardDecl {
+   long HiddenMemberName;
+};
+ForwardDecl fwd_decl;
diff --git a/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/Makefile b/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/Makefile
new file mode 100644
index 000000000000..50d4ab65a6ec
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../make
+
+C_SOURCES := main.c
+CFLAGS_EXTRAS += -std=c99
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/TestAllowJIT.py b/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/TestAllowJIT.py
new file mode 100644
index 000000000000..05c67902a3ab
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/TestAllowJIT.py
@@ -0,0 +1,90 @@
+"""
+Test that --allow-jit=false does disallow JITting:
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import re
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+
+class TestAllowJIT(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # If your test case doesn't stress debug info, the
+    # set this to true.  That way it won't be run once for
+    # each debug info format.
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_allow_jit_expr_command(self):
+        """Test the --allow-jit command line flag"""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        self.expr_cmd_test()
+
+    def test_allow_jit_options(self):
+        """Test the SetAllowJIT SBExpressionOption setting"""
+        self.build()
+        self.main_source_file = lldb.SBFileSpec("main.c")
+        self.expr_options_test()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+
+    def expr_cmd_test(self):
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                   "Set a breakpoint here", self.main_source_file)
+
+        frame = thread.GetFrameAtIndex(0)
+        
+        # First make sure we can call the function with 
+        interp = self.dbg.GetCommandInterpreter()
+        self.expect("expr --allow-jit 1 -- call_me(10)",
+                    substrs = ["(int) $", "= 18"])
+        # Now make sure it fails with the "can't IR interpret message" if allow-jit is false:
+        self.expect("expr --allow-jit 0 -- call_me(10)",
+                    error=True,
+                    substrs = ["Can't run the expression locally"])
+        
+    def expr_options_test(self):
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                   "Set a breakpoint here", self.main_source_file)
+
+        frame = thread.GetFrameAtIndex(0)
+
+        # First make sure we can call the function with the default option set. 
+        options = lldb.SBExpressionOptions()
+        # Check that the default is to allow JIT:
+        self.assertEqual(options.GetAllowJIT(), True, "Default is true")
+
+        # Now use the options:
+        result = frame.EvaluateExpression("call_me(10)", options)
+        self.assertTrue(result.GetError().Success(), "expression succeeded")
+        self.assertEqual(result.GetValueAsSigned(), 18, "got the right value.")
+
+        # Now disallow JIT and make sure it fails:
+        options.SetAllowJIT(False)
+        # Check that we got the right value:
+        self.assertEqual(options.GetAllowJIT(), False, "Got False after setting to False")
+
+        # Again use it and ensure we fail:
+        result = frame.EvaluateExpression("call_me(10)", options)
+        self.assertTrue(result.GetError().Fail(), "expression failed with no JIT")
+        self.assertTrue("Can't run the expression locally" in result.GetError().GetCString(), "Got right error")
+
+        # Finally set the allow JIT value back to true and make sure that works:
+        options.SetAllowJIT(True)
+        self.assertEqual(options.GetAllowJIT(), True, "Set back to True correctly")
+
+        # And again, make sure this works:
+        result = frame.EvaluateExpression("call_me(10)", options)
+        self.assertTrue(result.GetError().Success(), "expression succeeded")
+        self.assertEqual(result.GetValueAsSigned(), 18, "got the right value.")
+
diff --git a/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/main.c b/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/main.c
new file mode 100644
index 000000000000..ebd8ae11a73a
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/dont_allow_jit/main.c
@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+int
+call_me(int input)
+{
+  return printf("I was called: %d.\n", input);
+}
+
+int
+main()
+{
+  int test_var = 10;
+  printf ("Set a breakpoint here: %d.\n", test_var);
+  return call_me(100);
+}
diff --git a/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py b/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py
index f14b02bbd7c4..ee5c4a0ee1df 100644
--- a/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py
+++ b/packages/Python/lldbsuite/test/expression_command/formatters/TestFormatters.py
@@ -57,14 +57,21 @@ class ExprFormattersTestCase(TestBase):
             self.runCmd("frame variable foo1.b --show-types")
             self.runCmd("frame variable foo1.b.b_ref --show-types")
 
-        self.expect(
-            "expression --show-types -- *(new foo(47))",
-            substrs=[
-                '(int) a = 47',
-                '(bar) b = {',
-                '(int) i = 94',
-                '(baz) b = {',
-                '(int) k = 99'])
+        self.filecheck("expression --show-types -- *(new foo(47))", __file__,
+                '-check-prefix=EXPR-TYPES-NEW-FOO')
+        # EXPR-TYPES-NEW-FOO: (foo) ${{.*}} = {
+        # EXPR-TYPES-NEW-FOO-NEXT:   (int) a = 47
+        # EXPR-TYPES-NEW-FOO-NEXT:   (int *) a_ptr = 0x
+        # EXPR-TYPES-NEW-FOO-NEXT:   (bar) b = {
+        # EXPR-TYPES-NEW-FOO-NEXT:     (int) i = 94
+        # EXPR-TYPES-NEW-FOO-NEXT:     (int *) i_ptr = 0x
+        # EXPR-TYPES-NEW-FOO-NEXT:     (baz) b = {
+        # EXPR-TYPES-NEW-FOO-NEXT:       (int) h = 97
+        # EXPR-TYPES-NEW-FOO-NEXT:       (int) k = 99
+        # EXPR-TYPES-NEW-FOO-NEXT:     }
+        # EXPR-TYPES-NEW-FOO-NEXT:     (baz &) b_ref = 0x
+        # EXPR-TYPES-NEW-FOO-NEXT:   }
+        # EXPR-TYPES-NEW-FOO-NEXT: }
 
         self.runCmd("type summary add -F formatters.foo_SummaryProvider foo")
 
@@ -80,68 +87,49 @@ class ExprFormattersTestCase(TestBase):
         self.expect("expression foo1.a_ptr",
                     substrs=['(int *) $', '= 0x', ' -> 13'])
 
-        self.expect(
-            "expression foo1",
-            substrs=[
-                '(foo) $',
-                ' a = 12',
-                'a_ptr = ',
-                ' -> 13',
-                'i = 24',
-                'i_ptr = ',
-                ' -> 25'])
-
-        self.expect(
-            "expression --ptr-depth=1 -- new foo(47)",
-            substrs=[
-                '(foo *) $',
-                'a = 47',
-                'a_ptr = ',
-                ' -> 48',
-                'i = 94',
-                'i_ptr = ',
-                ' -> 95'])
-
-        self.expect(
-            "expression foo2",
-            substrs=[
-                '(foo) $',
-                'a = 121',
-                'a_ptr = ',
-                ' -> 122',
-                'i = 242',
-                'i_ptr = ',
-                ' -> 243'])
+        self.filecheck("expression foo1", __file__, '-check-prefix=EXPR-FOO1')
+        # EXPR-FOO1: (foo) $
+        # EXPR-FOO1-SAME: a = 12
+        # EXPR-FOO1-SAME: a_ptr = {{[0-9]+}} -> 13
+        # EXPR-FOO1-SAME: i = 24
+        # EXPR-FOO1-SAME: i_ptr = {{[0-9]+}} -> 25
+        # EXPR-FOO1-SAME: b_ref = {{[0-9]+}}
+        # EXPR-FOO1-SAME: h = 27
+        # EXPR-FOO1-SAME: k = 29
+
+        self.filecheck("expression --ptr-depth=1 -- new foo(47)", __file__,
+                '-check-prefix=EXPR-PTR-DEPTH1')
+        # EXPR-PTR-DEPTH1: (foo *) $
+        # EXPR-PTR-DEPTH1-SAME: a = 47
+        # EXPR-PTR-DEPTH1-SAME: a_ptr = {{[0-9]+}} -> 48
+        # EXPR-PTR-DEPTH1-SAME: i = 94
+        # EXPR-PTR-DEPTH1-SAME: i_ptr = {{[0-9]+}} -> 95
+
+        self.filecheck("expression foo2", __file__, '-check-prefix=EXPR-FOO2')
+        # EXPR-FOO2: (foo) $
+        # EXPR-FOO2-SAME: a = 121
+        # EXPR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
+        # EXPR-FOO2-SAME: i = 242
+        # EXPR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
+        # EXPR-FOO2-SAME: h = 245
+        # EXPR-FOO2-SAME: k = 247
 
         object_name = self.res.GetOutput()
         object_name = object_name[7:]
         object_name = object_name[0:object_name.find(' =')]
 
-        self.expect(
-            "frame variable foo2",
-            substrs=[
-                '(foo)',
-                'foo2',
-                'a = 121',
-                'a_ptr = ',
-                ' -> 122',
-                'i = 242',
-                'i_ptr = ',
-                ' -> 243'])
-
-        self.expect(
-            "expression $" +
-            object_name,
-            substrs=[
-                '(foo) $',
-                'a = 121',
-                'a_ptr = ',
-                ' -> 122',
-                'i = 242',
-                'i_ptr = ',
-                ' -> 243',
-                'h = 245',
-                'k = 247'])
+        self.filecheck("frame variable foo2", __file__, '-check-prefix=VAR-FOO2')
+        # VAR-FOO2: (foo) foo2
+        # VAR-FOO2-SAME: a = 121
+        # VAR-FOO2-SAME: a_ptr = {{[0-9]+}} -> 122
+        # VAR-FOO2-SAME: i = 242
+        # VAR-FOO2-SAME: i_ptr = {{[0-9]+}} -> 243
+        # VAR-FOO2-SAME: h = 245
+        # VAR-FOO2-SAME: k = 247
+
+        # The object is the same as foo2, so use the EXPR-FOO2 checks.
+        self.filecheck("expression $" + object_name, __file__,
+                '-check-prefix=EXPR-FOO2')
 
         self.runCmd("type summary delete foo")
         self.runCmd(
diff --git a/packages/Python/lldbsuite/test/expression_command/formatters/main.cpp b/packages/Python/lldbsuite/test/expression_command/formatters/main.cpp
index 4c3b180f3709..1b8ce48041f9 100644
--- a/packages/Python/lldbsuite/test/expression_command/formatters/main.cpp
+++ b/packages/Python/lldbsuite/test/expression_command/formatters/main.cpp
@@ -45,4 +45,4 @@ int main(int argc, char** argv)
 	
 	return 0;
 	
-}
\ No newline at end of file
+}
diff --git a/packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py b/packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py
deleted file mode 100644
index 7f639a462201..000000000000
--- a/packages/Python/lldbsuite/test/expression_command/multiline/TestMultilineExpressions.py
+++ /dev/null
@@ -1,90 +0,0 @@
-"""Test multiline expressions."""
-
-from __future__ import print_function
-
-import os
-import lldb
-from lldbsuite.test.decorators import *
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbutil
-
-
-class MultilineExpressionsTestCase(TestBase):
-
-    mydir = TestBase.compute_mydir(__file__)
-    NO_DEBUG_INFO_TESTCASE = True
-
-    def setUp(self):
-        # Call super's setUp().
-        TestBase.setUp(self)
-        # Find the line number to break on inside main.cpp.
-        self.line = line_number('main.c', 'break')
-
-    @skipIfRemote
-    @expectedFailureAll(
-        oslist=["windows"],
-        bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
-    def test_with_run_commands(self):
-        """Test that multiline expressions work correctly"""
-        self.build()
-        import pexpect
-        exe = self.getBuildArtifact("a.out")
-        prompt = "(lldb) "
-
-        # So that the child gets torn down after the test.
-        self.child = pexpect.spawn(
-            '%s %s %s' %
-            (lldbtest_config.lldbExec, self.lldbOption, exe))
-        child = self.child
-        # Turn on logging for what the child sends back.
-        if self.TraceOn():
-            child.logfile_read = sys.stdout
-
-        # Set the breakpoint, run the inferior, when it breaks, issue print on
-        # the various convenience variables.
-        child.expect_exact(prompt)
-        child.sendline('breakpoint set -f main.c -l %d' % self.line)
-        child.expect_exact(prompt)
-        child.sendline('run')
-        child.expect_exact("stop reason = breakpoint 1.1")
-        child.expect_exact(prompt)
-        child.sendline('expr')
-        child.expect_exact('1:')
-
-        child.sendline('2+')
-        child.expect_exact('2:')
-
-        child.sendline('3')
-        child.expect_exact('3:')
-
-        child.sendline('')
-        child.expect_exact(prompt)
-        self.expect(child.before, exe=False,
-                    patterns=['= 5'])
-
-    @skipIfRemote
-    @expectedFailureAll(
-        oslist=["windows"],
-        bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
-    def test_empty_list(self):
-        """Test printing an empty list of expressions"""
-        import pexpect
-        prompt = "(lldb) "
-
-        # So that the child gets torn down after the test
-        self.child = pexpect.spawn(
-                "%s %s" %
-                (lldbtest_config.lldbExec, self.lldbOption))
-        child = self.child
-
-        # Turn on logging for what the child sends back.
-        if self.TraceOn():
-            child.logfile_read = sys.stdout
-
-        # We expect a prompt, then send "print" to start a list of expressions,
-        # then an empty line. We expect a prompt back.
-        child.expect_exact(prompt)
-        child.sendline("print")
-        child.expect_exact('1:')
-        child.sendline("")
-        child.expect_exact(prompt)
diff --git a/packages/Python/lldbsuite/test/expression_command/multiline/main.c b/packages/Python/lldbsuite/test/expression_command/multiline/main.c
deleted file mode 100644
index da16b1e7846f..000000000000
--- a/packages/Python/lldbsuite/test/expression_command/multiline/main.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdio.h>
-
-int main(int argc, char const *argv[]) {
-    printf("Hello world.\n"); // break here
-    return 0;
-}
diff --git a/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py b/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py
index 1dbafc36a82a..13bc3b7ce2ac 100644
--- a/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py
+++ b/packages/Python/lldbsuite/test/expression_command/options/TestExprOptions.py
@@ -14,6 +14,7 @@ import os
 import time
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 
@@ -63,3 +64,30 @@ class ExprOptionsTestCase(TestBase):
         val = frame.EvaluateExpression('foo != nullptr', options)
         self.assertTrue(val.IsValid())
         self.assertFalse(val.GetError().Success())
+
+    @skipIfDarwin
+    def test_expr_options_lang(self):
+        """These expression language options should work as expected."""
+        self.build()
+
+        # Set debugger into synchronous mode
+        self.dbg.SetAsync(False)
+
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, '// breakpoint_in_main', self.main_source_spec)
+
+        frame = thread.GetFrameAtIndex(0)
+        options = lldb.SBExpressionOptions()
+
+        # Make sure we can retrieve `id` variable if language is set to C++11:
+        options.SetLanguage(lldb.eLanguageTypeC_plus_plus_11)
+        val = frame.EvaluateExpression('id == 0', options)
+        self.assertTrue(val.IsValid())
+        self.assertTrue(val.GetError().Success())
+        self.DebugSBValue(val)
+
+        # Make sure we can't retrieve `id` variable if language is set to ObjC:
+        options.SetLanguage(lldb.eLanguageTypeObjC)
+        val = frame.EvaluateExpression('id == 0', options)
+        self.assertTrue(val.IsValid())
+        self.assertFalse(val.GetError().Success())
diff --git a/packages/Python/lldbsuite/test/expression_command/options/main.cpp b/packages/Python/lldbsuite/test/expression_command/options/main.cpp
index ecd9a90f6626..0d30c79bd229 100644
--- a/packages/Python/lldbsuite/test/expression_command/options/main.cpp
+++ b/packages/Python/lldbsuite/test/expression_command/options/main.cpp
@@ -1,11 +1,13 @@
 extern "C" int foo(void);
 static int static_value = 0;
+static int id = 1234;
 
 int
 bar()
 {
     static_value++;
-    return static_value;
+    id++;
+    return static_value + id;
 }
 
 int main (int argc, char const *argv[])
diff --git a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py
index f4ee1b0fb625..8630d6f41b34 100644
--- a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py
+++ b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestNestedPersistentTypes.py
@@ -17,7 +17,6 @@ class NestedPersistentTypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_persistent_types(self):
         """Test that nested persistent types work."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py
index f56cb11a80d8..403d24246a9d 100644
--- a/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py
+++ b/packages/Python/lldbsuite/test/expression_command/persistent_types/TestPersistentTypes.py
@@ -17,7 +17,6 @@ class PersistenttypesTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_persistent_types(self):
         """Test that lldb persistent types works correctly."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/pr35310/TestExprsBug35310.py b/packages/Python/lldbsuite/test/expression_command/pr35310/TestExprsBug35310.py
index dd3d06fd672f..6d019c7415fc 100644
--- a/packages/Python/lldbsuite/test/expression_command/pr35310/TestExprsBug35310.py
+++ b/packages/Python/lldbsuite/test/expression_command/pr35310/TestExprsBug35310.py
@@ -16,7 +16,6 @@ class ExprBug35310(TestBase):
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_issue35310(self):
         """Test invoking functions with non-standard linkage names.
 
diff --git a/packages/Python/lldbsuite/test/expression_command/radar_43822994/Makefile b/packages/Python/lldbsuite/test/expression_command/radar_43822994/Makefile
new file mode 100644
index 000000000000..83b24da17b4d
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/radar_43822994/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+CXXFLAGS += -std=c++11
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/expression_command/radar_43822994/TestScopedEnumType.py b/packages/Python/lldbsuite/test/expression_command/radar_43822994/TestScopedEnumType.py
new file mode 100644
index 000000000000..028047fc46bf
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/radar_43822994/TestScopedEnumType.py
@@ -0,0 +1,44 @@
+from __future__ import print_function
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class ScopedEnumType(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test(self):
+        self.build()
+
+        self.main_source = "main.cpp"
+        self.main_source_spec = lldb.SBFileSpec(self.main_source)
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                          '// Set break point at this line.', self.main_source_spec)
+        frame = thread.GetFrameAtIndex(0)
+
+        self.expect("expr f == Foo::FooBar",
+                substrs=['(bool) $0 = true'])
+
+        value = frame.EvaluateExpression("f == Foo::FooBar")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsUnsigned(), 1)
+
+        value = frame.EvaluateExpression("b == BarBar")
+        self.assertTrue(value.IsValid())
+        self.assertTrue(value.GetError().Success())
+        self.assertEqual(value.GetValueAsUnsigned(), 1)
+
+        ## b is not a Foo
+        value = frame.EvaluateExpression("b == Foo::FooBar")
+        self.assertTrue(value.IsValid())
+        self.assertFalse(value.GetError().Success())
+
+        ## integral is not implicitly convertible to a scoped enum
+        value = frame.EvaluateExpression("1 == Foo::FooBar")
+        self.assertTrue(value.IsValid())
+        self.assertFalse(value.GetError().Success())
diff --git a/packages/Python/lldbsuite/test/expression_command/radar_43822994/main.cpp b/packages/Python/lldbsuite/test/expression_command/radar_43822994/main.cpp
new file mode 100644
index 000000000000..b0d67d23dc5e
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/radar_43822994/main.cpp
@@ -0,0 +1,16 @@
+enum class Foo {
+  FooBar = 42
+};
+
+enum Bar {
+    BarBar = 3,
+    BarBarBar = 42
+};
+
+int main(int argc, const char **argv) {
+  Foo f = Foo::FooBar;
+  Bar b = BarBar;
+  bool b1 = f == Foo::FooBar;
+  bool b2 = b == BarBar;
+  return 0; // Set break point at this line.
+}
diff --git a/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py b/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py
index c44cb6fc39da..dc8ee77fd6fb 100644
--- a/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py
+++ b/packages/Python/lldbsuite/test/expression_command/radar_9531204/TestPrintfAfterUp.py
@@ -18,7 +18,6 @@ class Radar9531204TestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     # rdar://problem/9531204
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_expr_commands(self):
         """The evaluating printf(...) after break stop and then up a stack frame."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py b/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py
index dfef8735071b..d18720ccf3f1 100644
--- a/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py
+++ b/packages/Python/lldbsuite/test/expression_command/radar_9673664/TestExprHelpExamples.py
@@ -24,7 +24,6 @@ class Radar9673644TestCase(TestBase):
         self.main_source = "main.c"
         self.line = line_number(self.main_source, '// Set breakpoint here.')
 
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_expr_commands(self):
         """The following expression commands should just work."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/multiline/Makefile b/packages/Python/lldbsuite/test/expression_command/rdar44436068/Makefile
index 0d70f2595019..f5a47fcc46cc 100644
--- a/packages/Python/lldbsuite/test/expression_command/multiline/Makefile
+++ b/packages/Python/lldbsuite/test/expression_command/rdar44436068/Makefile
@@ -1,5 +1,3 @@
 LEVEL = ../../make
-
 C_SOURCES := main.c
-
 include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/expression_command/rdar44436068/Test128BitsInteger.py b/packages/Python/lldbsuite/test/expression_command/rdar44436068/Test128BitsInteger.py
new file mode 100644
index 000000000000..c8308c16011e
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/rdar44436068/Test128BitsInteger.py
@@ -0,0 +1,4 @@
+from lldbsuite.test import lldbinline
+from lldbsuite.test import decorators
+
+lldbinline.MakeInlineTest(__file__, globals())
diff --git a/packages/Python/lldbsuite/test/expression_command/rdar44436068/main.c b/packages/Python/lldbsuite/test/expression_command/rdar44436068/main.c
new file mode 100644
index 000000000000..156dbf04a1b7
--- /dev/null
+++ b/packages/Python/lldbsuite/test/expression_command/rdar44436068/main.c
@@ -0,0 +1,8 @@
+int main(void)
+{
+    __int128_t n = 1;
+    n = n + n;
+    return n; //%self.expect("p n", substrs=['(__int128_t) $0 = 2'])
+              //%self.expect("p n + 6", substrs=['(__int128) $1 = 8'])
+              //%self.expect("p n + n", substrs=['(__int128) $2 = 4'])
+}
diff --git a/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py b/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py
index 3af7d808e128..deae7feb3ac1 100644
--- a/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py
+++ b/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py
@@ -102,7 +102,6 @@ class BasicExprCommandsTestCase(TestBase):
         # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out"
 
     @add_test_categories(['pyapi'])
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_evaluate_expression_python(self):
         """Test SBFrame.EvaluateExpression() API for evaluating an expression."""
         self.build()
@@ -203,7 +202,6 @@ class BasicExprCommandsTestCase(TestBase):
     # rdar://problem/8686536
     # CommandInterpreter::HandleCommand is stripping \'s from input for
     # WantsRawCommand commands
-    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_expr_commands_can_handle_quotes(self):
         """Throw some expression commands with quotes at lldb."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py b/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py
index f5ec4f027866..88412e6b7c82 100644
--- a/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py
+++ b/packages/Python/lldbsuite/test/expression_command/test/TestExprs2.py
@@ -24,9 +24,6 @@ class ExprCommands2TestCase(TestBase):
             'main.cpp',
             '// Please test many expressions while stopped at this line:')
 
-    @expectedFailureAll(
-        oslist=["windows"],
-        bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
     def test_more_expr_commands(self):
         """Test some more expression commands."""
         self.build()
@@ -60,9 +57,7 @@ class ExprCommands2TestCase(TestBase):
         # (int) $5 = 6
 
     @skipIfLinux
-    @expectedFailureAll(
-            oslist=["windows"],
-            bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows")
+    @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test_expr_symbols(self):
         """Test symbols."""
         self.build()
diff --git a/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py b/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py
index c942427a8e66..108de8867d50 100644
--- a/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py
+++ b/packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py
@@ -55,7 +55,6 @@ class UnwindFromExpressionTest(TestBase):
 
 
     @add_test_categories(['pyapi'])
-    @expectedFailureAll(oslist=["windows"])
     def test_unwind_expression(self):
         """Test unwinding from an expression."""
         self.build_and_run_to_bkpt()