Fix test expectation for aarch64 in several test case

[tberghammer]

Summary

Fix test expectation for aarch64 in several test case

These test cases check if they are able to read registers after the
inferior is crashed. Previously they did it with reading the eax
register what is only available on i386 and x86_64. This CL add code to
do the check based on the target architecture (currently i386, x86_64
and aarch64 is supported)

[emaste]

Looks reasonable. I wonder if we should have a machine-dependent test library though to host these sorts of things. We'll probably have several more when the test suite fully runs on !x86 architectures, no?

[tberghammer]

In D8702#148933, @emaste wrote:

Looks reasonable. I wonder if we should have a machine-dependent test library though to host these sorts of things. We'll probably have several more when the test suite fully runs on !x86 architectures, no?

We already have some basic things in lldbtest.py but it is very far from being enough. I absolutely support creating something what can be used with all target and all host so we don't have to handle it in each test case but I think we should have a longer discussion about it (on lldb-dev) to come up with a good design what we can easily use in all case.

[omjavaid]

Hi Tamas,

Some inline comments about these tests.

test/functionalities/inferior-assert/TestInferiorAssert.py

98

Hi Tamas,

Can we put this function in one place and use it from there instead on duplicating it in every other file?

In my opinion we should consider separating such tests by architecture and put them in a library or file that can imported otherwise these will be very hard to maintain as our test set grows large.

[ovyalov]

Please see my comments.

test/functionalities/inferior-assert/TestInferiorAssert.py

98

+1

105

Could you print here self.getArchitecture()?

[tberghammer]

Move duplicated code the utility file

[ovyalov]

Please see my comments.

test/lldbplatformutil.py

1

s/modul/module

4

self argument looks a little awkward here since there is no class around - maybe use test_case instead of self?

4

Since this function depends on methods and data from lldbtest what do you think about moving it into lldbtest.py?

[tberghammer]

test/lldbplatformutil.py

4

I think lldbtest.py already have too much different responsibility so I prefer to keep this platform dependent code separately for readability reasons. Currently it looks a bit strange with just 1 small function in it but I guess there is a lot of duplicated logic in the test cases what should be moved out to a utility class like this.

If you read the comment at the top of lldbtest.py you will see that it already do much more then it was originally designed for (and currently documented). I would prefer to split that class up in the future instead of adding more thing into it.

[tberghammer]

Fix typo and rename argument to test_case

[ovyalov]

Looks good.

test/functionalities/inferior-assert/TestInferiorAssert.py

 """Test that lldb functions correctly after the inferior has asserted."""
 
 import os, time
 import unittest2
-import lldb, lldbutil
+import lldb, lldbutil, lldbplatformutil
 from lldbtest import *
 
 class AssertingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     @unittest2.expectedFailure("rdar://15367233")
def check_stop_reason(self):
 
         # The stop reason of the thread should be an abort signal or exception.
         self.expect("thread list", STOPPED_DUE_TO_ASSERT,
             substrs = ['stopped',
                        stop_reason])
 
         return stop_reason
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number of the call to assert.
         self.line = line_number('main.c', '// Assert here.')
 
     def inferior_asserting(self):
         """Inferior asserts upon launching; lldb should catch the event and stop."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         stop_reason = self.check_stop_reason()
 
         # And it should report a backtrace that includes the assert site.
         self.expect("thread backtrace all",
def inferior_asserting_registers(self):
         """Test that lldb can read registers after asserting."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # lldb should be able to read from registers from the inferior after asserting.
-        self.expect("register read eax",
-            substrs = ['eax = 0x'])
+        lldbplatformutil.check_first_register_readable(self)
 
     def inferior_asserting_disassemble(self):
         """Test that lldb can disassemble frames after asserting."""
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

test/functionalities/inferior-crashing/TestInferiorCrashing.py

 """Test that lldb functions correctly after the inferior has crashed."""
 
 import os, time
 import unittest2
-import lldb, lldbutil
+import lldb, lldbutil, lldbplatformutil
 from lldbtest import *
 
 class CrashingInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     def test_inferior_crashing_dsym(self):
def inferior_crashing_registers(self):
         """Test that lldb can read registers after crashing."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # lldb should be able to read from registers from the inferior after crashing.
-        self.expect("register read eax",
-            substrs = ['eax = 0x'])
+        lldbplatformutil.check_first_register_readable(self)
 
     def inferior_crashing_expr(self):
         """Test that the lldb expression interpreter can read symbols after crashing."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
def inferior_crashing_step(self):
 
         # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
         self.expect("p argv[0]",
             substrs = ['a.out'])
         self.expect("p null_ptr",
             substrs = ['= 0x0'])
 
         # lldb should be able to read from registers from the inferior after crashing.
-        self.expect("register read eax",
-            substrs = ['eax = 0x'])
+        lldbplatformutil.check_first_register_readable(self)
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
             substrs = [stop_reason,
                        'main.c:%d' % self.line])
 
     def inferior_crashing_step_after_break(self):
         """Test that lldb behaves correctly when stepping after a crash."""

test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

 """Test that lldb functions correctly after the inferior has crashed while in a recursive routine."""
 
 import os, time
 import unittest2
-import lldb, lldbutil
+import lldb, lldbutil, lldbplatformutil
 import sys
 from lldbtest import *
 
 class CrashingRecursiveInferiorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
def recursive_inferior_crashing_registers(self):
         """Test that lldb can read registers after crashing."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         # lldb should be able to read from registers from the inferior after crashing.
-        self.expect("register read eax",
-            substrs = ['eax = 0x'])
+        lldbplatformutil.check_first_register_readable(self)
 
     def recursive_inferior_crashing_expr(self):
         """Test that the lldb expression interpreter can read symbols after crashing."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
def recursive_inferior_crashing_step(self):
         self.runCmd("next")
         stop_reason = self.check_stop_reason()
 
         # The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
         self.expect("p i",
             substrs = ['(int) $0 ='])
 
         # lldb should be able to read from registers from the inferior after crashing.
-        self.expect("register read eax",
-            substrs = ['eax = 0x'])
+        lldbplatformutil.check_first_register_readable(self)
 
         # And it should report the correct line number.
         self.expect("thread backtrace all",
             substrs = [stop_reason,
                        'main.c:%d' % self.line])
 
     def recursive_inferior_crashing_step_after_break(self):
         """Test that lldb behaves correctly when stepping after a crash."""

test/lldbplatformutil.py

+""" This modul contains functions used by the test cases to hide the
+architecture and/or the platform dependent nature of the tests. """
+
+def check_first_register_readable(self):
+    if self.getArchitecture() in ['x86_64', 'i386']:
+        self.expect("register read eax", substrs = ['eax = 0x'])
+    elif self.getArchitecture() in ['aarch64']:
+        self.expect("register read x0", substrs = ['x0 = 0x'])
+    else:
+        # TODO: Add check for other architectures
+        self.fail("Unsupported architecture for test case (arch: %s)" % self.getArchitecture())