[LLDB][MIPS] Added test case support for MIPS

[emaste]

test/python_api/value/change_values/TestChangeValueAPI.py

145

Can you expand on this comment?

[clayborg]

inline comments above

test/python_api/value/change_values/TestChangeValueAPI.py

146–149

Can se just pick a safer SP value that would work on all systems? Maybe 32 or 64? Some systems might require SP to be aligned to a specific 4, 8 or 16 byte boundary and I am guessing that is what this change is trying to fix. Can we just change the SP value to 64?

test/tools/lldb-server/gdbremote_testcase.py

1261–1266

Not sure why we have a test that is counting single steps of instructions? Of course they are going to vary. Maybe you can check with the original author and ask why we are doing this? This doesn't seem portable or like a very good thing to test? I would rather see breakpoints being set at source lines and stop before and after and verify that things changed than to have any tests that expect stepping to work in a specific way. All of the different architectures (arm, arm64, i386, x86_64, mips, mips64, hexagon, etc) have front/back ends that produce different DWARF line tables so even trying to make a test that does something like:

• set breakpoint 1 by file + line
• run to breakpoint 1
• test some initial condition
• step over
• step over
• test something

are doomed to fail. We should be using breakpoints on file + line in order to test things so they work on all architectures and then the test should look like:

• set breakpoint 1 by file + line
• set breakpoint 2 by file + line
• run to breakpoint 1
• test some initial condition
• run to breakpoint 2
• test something

[clayborg]

test/python_api/value/change_values/TestChangeValueAPI.py

146–149

If we can change this to be 64 then we can remove the arch tests...

[labath]

test/tools/lldb-server/gdbremote_testcase.py

1261–1266

As I understand it, these tests are supposed to verify behaviour of the lldb-server, sans lldb. This means they talk raw gdb-remote protocol over sockets and they don't have access to lldb functionality like parsing dwarf line tables.
That said, I don't have an idea how to make this more robust... Perhaps we don't need to care about the exact number of steps - it should be enough to verify that the state is reached within a reasonable number of steps (?)

[tberghammer]

test/tools/lldb-server/gdbremote_testcase.py

1261–1266

Based on my understanding these tests try to verify that the "s" (or the "vCont:s") packet only steps 1 instruction. For architectures where the instruction size is fixed we can compare the PC reported before the step and after the step but it won't work on x86 or with thumb

[clayborg]

Ah, thanks for the info. Feel free to fix the gdbremote_testcase.py however you have to. My comments stand for the SP value in TestChangeValueAPI.py.

[nitesh.jain]

test/python_api/value/change_values/TestChangeValueAPI.py

145

When sp=1 , for MIPS64 it generate 64 bit invalid address causing process to exit. The solution for above problem was to set sp value greater than stack allocated size in Assembly Prologue. But it will vary from process to process hence not suitable approached. The good approach was to handle SIGBUS signal with si_code=SI_KERENEL for invalid 64 bit address.

The Patch [ http://reviews.llvm.org/D11176 | To handle SI_KERENEL generated for invalid 64 bit address ] handle above mentioned case

[nitesh.jain]

test/python_api/value/change_values/TestChangeValueAPI.py

146–149

Even changing sp to 64 couldn't cause the test case to passed. Since it was generating SIGBUS signal with si_code=SI_KERENEL for invalid 64 bit address. which was not handle.

The Patch [ http://reviews.llvm.org/D11176 | To handle SI_KERENEL generated for invalid 64 bit address ] handle above mentioned case.

[clayborg]

ok, it you need to special case for MIPS then you can do so.

test/python_api/value/change_values/TestChangeValueAPI.py

         # Finally, change the stack pointer to 0, and we should not make it to our end breakpoint.
         frame0 = thread.GetFrameAtIndex(0)
         self.assertTrue (frame0.IsValid(), "Second time: got a valid frame.")
-        sp_value = frame0.FindValue ("sp", lldb.eValueTypeRegister);
+        sp_value = frame0.FindValue ("sp", lldb.eValueTypeRegister)
         self.assertTrue (sp_value.IsValid(), "Got a stack pointer value")
-        result = sp_value.SetValueFromCString("1")
+        arch = self.getArchitecture()
+
+        #To get invalid  address in case of MIPS Architecture when sp value is changed. 
+        if arch == "mips" or arch == "mips64" or arch == "mips32el" or arch == "mips64el":
+           result = sp_value.SetValueFromCString("100")
+        else:
+           result = sp_value.SetValueFromCString("1")
         self.assertTrue (result, "Setting sp returned true.")
         actual_value = sp_value.GetValueAsUnsigned (error, 0)
         self.assertTrue (error.Success(), "Got a changed value for sp")
-        self.assertTrue (actual_value == 1, "Got the right changed value for sp.")
+        if arch == "mips" or arch == "mips64" or arch == "mips32el" or arch == "mips64el":
+           self.assertTrue (actual_value == 100, "Got the right changed value for sp.")
+        else:
+            self.assertTrue (actual_value == 1, "Got the right changed value for sp.")
         
         # Boundary condition test the SBValue.CreateValueFromExpression() API.
         # LLDB should not crash!

test/tools/lldb-server/gdbremote_testcase.py

         args["expected_g_c2"] = "1"
         (state_reached, step_count) = self.count_single_steps_until_true(main_thread_id, self.g_c1_c2_contents_are, args, max_step_count=25, use_Hc_packet=use_Hc_packet, step_instruction=step_instruction)
         self.assertTrue(state_reached)
+        expected_step_count = 1
+        arch = self.getArchitecture()
+
+        #MIPS required "3" (ADDIU, SB, LD) machine instructions for updation of variable value
+        if arch == "mips" or arch == "mips64" or arch == "mips32el" or arch == "mips64el":
+           expected_step_count = 3
 
         # Verify we hit the next state.
         args["expected_g_c1"] = "1"
         args["expected_g_c2"] = "0"
         (state_reached, step_count) = self.count_single_steps_until_true(main_thread_id, self.g_c1_c2_contents_are, args, max_step_count=5, use_Hc_packet=use_Hc_packet, step_instruction=step_instruction)
         self.assertTrue(state_reached)
-        self.assertEquals(step_count, 1)
+        self.assertEquals(step_count, expected_step_count)
 
         # Verify we hit the next state.
         args["expected_g_c1"] = "0"
         args["expected_g_c2"] = "0"
         (state_reached, step_count) = self.count_single_steps_until_true(main_thread_id, self.g_c1_c2_contents_are, args, max_step_count=5, use_Hc_packet=use_Hc_packet, step_instruction=step_instruction)
         self.assertTrue(state_reached)
-        self.assertEquals(step_count, 1)
+        self.assertEquals(step_count, expected_step_count)
 
         # Verify we hit the next state.
         args["expected_g_c1"] = "0"
         args["expected_g_c2"] = "1"
         (state_reached, step_count) = self.count_single_steps_until_true(main_thread_id, self.g_c1_c2_contents_are, args, max_step_count=5, use_Hc_packet=use_Hc_packet, step_instruction=step_instruction)
         self.assertTrue(state_reached)
-        self.assertEquals(step_count, 1)
+        self.assertEquals(step_count, expected_step_count)