Add and fix some tests for PPC64

[alexandreyy]

Summary

TestExprsChar.py
Char is unsigned char by default in PowerPC.

TestDisassembleBreakpoint.py
Modify disassemble testcase to consider multiple architectures.

TestThreadJump.py
Jumping directly to the return line on PowerPC architecture dos not
means returning the value that is seen on the code. The last test fails,
because it needs the execution of some assembly in the beginning of the
function. Avoiding this test for this architecture.

TestEhFrameUnwind.py
Implement func for ppc64le test case.

TestWatchLocation.py
TestStepOverWatchpoint.py
PowerPC currently supports only one H/W watchpoint.

TestDisassembleRawData.py
Add PowerPC opcode and instruction for disassemble testcase.

[labath]

I wonder if we shouldn't just fix the TestDisassembleBreakpoint to not require adding every single architecture. That test was added because lldb-server was not removing the traps from the memory read packets. This is something that is completely independent of us later trying to disassemble the memory we got back. To test that, it should be sufficient to compare the memory contents before and after setting a breakpoint.

Guessing what instructions will the compiler emit for a particular piece of C will just make the test fragile...

packages/Python/lldbsuite/test/make/Makefile.rules

189 ↗

(On Diff #138361)

Why do you need both powerpc64le and ppc64le?

[alexandreyy]

Modified TestDisassembleBreakpoint.py to consider multiple architectures.

[alexandreyy]

In D44472#1038656, @labath wrote:

I wonder if we shouldn't just fix the TestDisassembleBreakpoint to not require adding every single architecture. That test was added because lldb-server was not removing the traps from the memory read packets. This is something that is completely independent of us later trying to disassemble the memory we got back. To test that, it should be sufficient to compare the memory contents before and after setting a breakpoint.

Guessing what instructions will the compiler emit for a particular piece of C will just make the test fragile...

I executed the tests again and we don't really need both powerpc64le and ppc64le.
Some tests required "ppc64le" to be built. But they are working now without it.
I modified the disassemble test as you suggested.

[labath]

I like what you did with the test. Originally, I wanted to just compare the raw memory contents, but this keeps it more inline with the spirit of the original test. I have just one question about the list zipping, but otherwise lgtm.

packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py

48–49 ↗

(On Diff #138610)

what will this do if the lists are of different length? Should you assert that the length matches as well?

[alexandreyy]

The test would pass if one of the disassembled code had more instructions.
That should be considered.
I added the assertion for that.
Thanks @labath .

[alexandreyy]

In D44472#1039812, @labath wrote:

I like what you did with the test. Originally, I wanted to just compare the raw memory contents, but this keeps it more inline with the spirit of the original test. I have just one question about the list zipping, but otherwise lgtm.

Hi @labath .
Could you merge this patch?

[davide]

Leonardo, this breaks the Mac OS X bot.
I'm going to revert this to get the bots green again, unless you have
a super quick fix (please let me know :)

[lbianc]

@davide Are you sure this is the correct patch? This one was not merged yet.
Could you give more details about the issue? Is it related with one of our changes?

[davide]

In D44472#1043464, @lbianc wrote:

@davide Are you sure this is the correct patch? This one was not merged yet.
Could you give more details about the issue? Is it related with one of our changes?

Apologies, this is the right one

commit 983ecd497e223b35e46fd3306bd7ac300da94793 (HEAD -> master)
Author: Davide Italiano <[e-mail]>
Date: Tue Mar 20 11:12:19 2018 -0700

Revert "Fix some tests for PPC64le architecture"

It broke the lldb Mac OSX greendragon bot.

[davide]

In D44472#1043510, @davide wrote:

In D44472#1043464, @lbianc wrote:

@davide Are you sure this is the correct patch? This one was not merged yet.
Could you give more details about the issue? Is it related with one of our changes?

Apologies, this is the right one

commit 983ecd497e223b35e46fd3306bd7ac300da94793 (HEAD -> master)
Author: Davide Italiano <[e-mail]>
Date: Tue Mar 20 11:12:19 2018 -0700

Revert "Fix some tests for PPC64le architecture"

It broke the lldb Mac OSX greendragon bot.

here are the bot logs (for your convenience)
http://lab.llvm.org:8080/green/view/LLDB/job/lldb-cmake/5869/console

[lbianc]

@davide, I think the error is the variable number, as this is the only command in the test case, could you just change from

# Do anonymous symbols work?
self.expect("expression ((char**)environ)[0]",
        startstr="(char *) $1 = 0x")

to

# Do anonymous symbols work?
self.expect("expression ((char**)environ)[0]",
        startstr="(char *) $0 = 0x")

and check if it works?

[lbianc]

@davide Let me know if you need that I change it on my diff or any other help.

[davide]

I think I understand why this is failing:

AssertionError: False is not True : 'expression ((char**)environ)[0]'
returns expected result, got '(char *) $0 = 0x00007ffeefbff753
"COMMAND_MODE=unix2003"'
Config=x86_64-/Users/davide/work/llvm-monorepo/build-release/bin/clang-7.0

but the test shows $1. How did this work for you? Are you running on
Linux by any chance?

Thanks,

Davide

[lbianc]

Yes, I'm running Linux and this test was not working for me, so as discussion above, it was separated to be executed on non Linux and Windows, but the variable number got wrong. Sorry for that.

[alexandreyy]

Hi @labath .
Could you please commit this patch?

lldb/trunk/packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py

class ExprCharTestCase(TestBase):
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test_default_char(self):
         self.do_test()
 
     @expectedFailureAll(
         archs=[
             "arm",
             "aarch64",
+            "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'})
 
     @expectedFailureAll(
         archs=[

lldb/trunk/packages/Python/lldbsuite/test/functionalities/disassembly/TestDisassembleBreakpoint.py

@expectedFailureAll(
         oslist=["windows"],
         bugnumber="function names print fully demangled instead of name-only")
     def test(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe,
                     patterns=["Current executable set to .*a.out.*"])
 
+        self.runCmd("dis -n main")
+        disassembly_before_break = self.res.GetOutput().splitlines()
+
         match_object = lldbutil.run_break_set_command(self, "br s -n sum")
         lldbutil.check_breakpoint_result(
             self,
             match_object,
             symbol_name='sum',
             symbol_match_exact=False,
             num_locations=1)
 
         self.expect("run",
                     patterns=["Process .* launched: "])
 
-        self.runCmd("dis -f")
-        disassembly = self.res.GetOutput()
+        self.runCmd("dis -n main")
+        disassembly_after_break = self.res.GetOutput().splitlines()
 
-        # ARCH, if not specified, defaults to x86_64.
-        arch = self.getArchitecture()
-        if arch in ["", 'x86_64', 'i386', 'i686']:
-            breakpoint_opcodes = ["int3"]
-            instructions = [' mov', ' addl ', 'ret']
-        elif arch in ["arm", "aarch64", "arm64", "armv7", "armv7k"]:
-            breakpoint_opcodes = ["brk", "udf"]
-            instructions = [' add ', ' ldr ', ' str ']
-        elif re.match("mips", arch):
-            breakpoint_opcodes = ["break"]
-            instructions = ['lw', 'sw']
-        elif arch in ["s390x"]:
-            breakpoint_opcodes = [".long"]
-            instructions = [' l ', ' a ', ' st ']
-        else:
-            # TODO please add your arch here
-            self.fail(
-                'unimplemented for arch = "{arch}"'.format(
-                    arch=self.getArchitecture()))
-
-        # make sure that the software breakpoint has been removed
-        for op in breakpoint_opcodes:
-            self.assertFalse(op in disassembly)
-
-        # make sure a few reasonable assembly instructions are here
-        self.expect(
-            disassembly,
-            exe=False,
-            startstr="a.out`sum",
-            substrs=instructions)
+        # make sure all assembly instructions are the same as the original
+        # instructions before inserting breakpoints.
+        self.assertEqual(len(disassembly_before_break),
+                         len(disassembly_after_break))
+
+        for dis_inst_before, dis_inst_after in \
+                zip(disassembly_before_break, disassembly_after_break):
+            inst_before = dis_inst_before.split(':')[-1]
+            inst_after = dis_inst_after.split(':')[-1]
+            self.assertEqual(inst_before, inst_after)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/unwind/ehframe/main.c

 void func() {
 
-#ifndef __mips__
+#ifdef __powerpc64__
+  __asm__ (
+    "mflr 0;"
+    "std 0,16(1);"
+    "addi 1,1,-24;"
+    "mr 31,1;"
+    ".cfi_def_cfa_offset 24;"
+    "addi 0,0,0;"
+    "addi 1,1,24;"
+    "ld 0,16(1);"
+    ".cfi_def_cfa_offset 0;"
+  );
+#elif !defined __mips__
   __asm__ (
     "pushq $0x10;"
     ".cfi_def_cfa_offset 16;"
     "jmp label;"
     "movq $0x48, %rax;"
 "label: subq $0x38, %rax;"
     "movq $0x48, %rcx;"
     "movq $0x48, %rdx;"

lldb/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/hello_watchlocation/TestWatchLocation.py

def setUp(self):
         self.d = {'CXX_SOURCES': self.source, 'EXE': self.exe_name}
 
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24446: WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows")
     # Most of the MIPS boards provide only one H/W watchpoints, and S/W
     # watchpoints are not supported yet
     @expectedFailureAll(triple=re.compile('^mips'))
-    # SystemZ also currently supports only one H/W watchpoint
-    @expectedFailureAll(archs=['s390x'])
+    # SystemZ and PowerPC also currently supports only one H/W watchpoint
+    @expectedFailureAll(archs=['powerpc64le', 's390x'])
     @skipIfDarwin
     def test_hello_watchlocation(self):
         """Test watching a location with '-s size' option."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         exe = self.getBuildArtifact(self.exe_name)
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/trunk/packages/Python/lldbsuite/test/functionalities/watchpoint/step_over_watchpoint/TestStepOverWatchpoint.py

def test(self):
 
         write_value = frame.FindValue('g_watch_me_write',
                                       lldb.eValueTypeVariableGlobal)
         self.assertTrue(write_value, "Failed to find write value.")
 
         # Most of the MIPS boards provide only one H/W watchpoints, and S/W
         # watchpoints are not supported yet
         arch = self.getArchitecture()
-        if re.match("^mips", arch):
+        if re.match("^mips", arch) or re.match("powerpc64le", arch):
             self.runCmd("watchpoint delete 1")
 
         # resolve_location=True, read=False, write=True
         write_watchpoint = write_value.Watch(True, False, True, error)
         self.assertTrue(write_watchpoint, "Failed to set write watchpoint.")
         self.assertTrue(error.Success(),
                         "Error while setting watchpoint: %s" %
                         error.GetCString())

lldb/trunk/packages/Python/lldbsuite/test/python_api/disassemble-raw-data/TestDisassembleRawData.py

def test_disassemble_raw_data(self):
         # Create a target from the debugger.
         arch = self.getArchitecture()
         if re.match("mips*el", arch):
             target = self.dbg.CreateTargetWithFileAndTargetTriple("", "mipsel")
             raw_bytes = bytearray([0x21, 0xf0, 0xa0, 0x03])
         elif re.match("mips", arch):
             target = self.dbg.CreateTargetWithFileAndTargetTriple("", "mips")
             raw_bytes = bytearray([0x03, 0xa0, 0xf0, 0x21])
+        elif re.match("powerpc64le", arch):
+            target = self.dbg.CreateTargetWithFileAndTargetTriple("", "powerpc64le")
+            raw_bytes = bytearray([0x00, 0x00, 0x80, 0x38])
         else:
             target = self.dbg.CreateTargetWithFileAndTargetTriple("", "x86_64")
             raw_bytes = bytearray([0x48, 0x89, 0xe5])
 
         self.assertTrue(target, VALID_TARGET)
         insts = target.GetInstructions(lldb.SBAddress(0, target), raw_bytes)
 
         inst = insts.GetInstructionAtIndex(0)
 
         if self.TraceOn():
             print()
             print("Raw bytes:    ", [hex(x) for x in raw_bytes])
             print("Disassembled%s" % str(inst))
         if re.match("mips", arch):
             self.assertTrue(inst.GetMnemonic(target) == "move")
             self.assertTrue(inst.GetOperands(target) ==
                             '$' + "fp, " + '$' + "sp")
+        elif re.match("powerpc64le", arch):
+            self.assertTrue(inst.GetMnemonic(target) == "li")
+            self.assertTrue(inst.GetOperands(target) == "4, 0")
         else:
             self.assertTrue(inst.GetMnemonic(target) == "movq")
             self.assertTrue(inst.GetOperands(target) ==
                             '%' + "rsp, " + '%' + "rbp")