[LLDB][PPC64] Fix single step and LldbGdbServer tests

[luporl]

Summary

On PPC64, the tested functions were being entered through their local entry point, while the tests expected the program to stop at the function start address, that, for PPC64, corresponds to the global entry point.

To fix the issue, the test program was modified to call the functions to be tested through function pointers, which, on PPC64, force the calls through the global entry point, while not affecting the test on other platforms.

[labath]

I think we should find some other way to fix this. Is there a way to force the inferior to go through the global entry point? Would putting the function in a different compilation unit help? Or calling it through a function pointer?

[luporl]

In D43768#1019395, @labath wrote:

I think we should find some other way to fix this. Is there a way to force the inferior to go through the global entry point? Would putting the function in a different compilation unit help? Or calling it through a function pointer?

Yes, there are some ways to force the inferior to go through the global entry point.

Simply putting the function in a different compilation unit won't help, because the linker is able to optimize calls to functions to use the local entry point if the object files get linked together.
I guess this would work only if the function is put in a different shared object.

Calling the function through a pointer seems to work, at least in my test program.
Can I change the test to always perform the call through a function pointer on all platforms?

[labath]

In D43768#1019451, @luporl wrote:

Can I change the test to always perform the call through a function pointer on all platforms?

Yes, these test only care that we are actually able to hit a breakpoint that we set, they don't care about how we actually get to that point. We could even generate some assembly and put a breakpoint there if that would make things easier. (It would probably be even better, as some of the tests here already depend on exact counts of assembly instructions, etc.)

[luporl]

• Merge branch 'master' into fix-tests-brkpts
• Forcing PPC64 to use function global entry point

Also, there were two tests that started failing after last merge with master,
that assumed that a generic FP register would always exist.
These were fixed as well.

[luporl]

• Merge branch 'master' into fix-tests-brkpts

This fixes some minor conflicts with latest ppc64 patches merged into master.

[luporl]

Thank you @labath. Can you check this in for me?

[labath]

Please update the patch description to what you want the commit message to say. (e.g., it this case the description is obsolete and very unhelpful to anyone who would be reading it in the future). I just noticed that I've already committed a couple of patches from you guys with not-so-ideal commit messages.

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

def qRegisterInfo_contains_required_generics(self):
         # Collect all generic registers found.
         generic_regs = {
             reg_info['generic']: 1 for reg_info in reg_infos if 'generic' in reg_info}
 
         # Ensure we have a program counter register.
         self.assertTrue('pc' in generic_regs)
 
         # Ensure we have a frame pointer register. PPC64le's FP is the same as SP
-        if(self.getArchitecture() != 'powerpc64le'):
+        if self.getArchitecture() != 'powerpc64le':
             self.assertTrue('fp' in generic_regs)
 
         # Ensure we have a stack pointer register.
         self.assertTrue('sp' in generic_regs)
 
         # Ensure we have a flags register.
         self.assertTrue('flags' in generic_regs)
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def select_modifiable_register(self, reg_infos):
         alternative_register_index = None
 
         self.assertIsNotNone(reg_infos)
         for reg_info in reg_infos:
             if ("name" in reg_info) and (
                     reg_info["name"] in PREFERRED_REGISTER_NAMES):
                 # We found a preferred register.  Use it.
                 return reg_info["lldb_register_index"]
-            if ("generic" in reg_info) and (reg_info["generic"] == "fp"):
-                # A frame pointer register will do as a register to modify
-                # temporarily.
+            if ("generic" in reg_info) and (reg_info["generic"] == "fp" or
+                    reg_info["generic"] == "arg1"):
+                # A frame pointer or first arg register will do as a
+                # register to modify temporarily.
                 alternative_register_index = reg_info["lldb_register_index"]
 
         # We didn't find a preferred register.  Return whatever alternative register
         # we found, if any.
         return alternative_register_index
 
     def extract_registers_from_stop_notification(self, stop_key_vals_text):
         self.assertIsNotNone(stop_key_vals_text)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/main.cpp

if (std::strstr(argv[i], STDERR_PREFIX)) {
       else if (std::strstr(argv[i] + strlen(GET_CODE_ADDRESS_PREFIX),
                            "swap_chars"))
         func_p = swap_chars;
 
       pthread_mutex_lock(&g_print_mutex);
       printf("code address: %p\n", func_p);
       pthread_mutex_unlock(&g_print_mutex);
     } else if (std::strstr(argv[i], CALL_FUNCTION_PREFIX)) {
+      void (*func_p)() = nullptr;
+
       // Defaut to providing the address of main.
       if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX), "hello") == 0)
-        hello();
+        func_p = hello;
       else if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX),
                            "swap_chars") == 0)
-        swap_chars();
+        func_p = swap_chars;
       else {
         pthread_mutex_lock(&g_print_mutex);
         printf("unknown function: %s\n",
                argv[i] + strlen(CALL_FUNCTION_PREFIX));
         pthread_mutex_unlock(&g_print_mutex);
       }
+      if (func_p)
+        func_p();
     } else if (std::strstr(argv[i], THREAD_PREFIX)) {
       // Check if we're creating a new thread.
       if (std::strstr(argv[i] + strlen(THREAD_PREFIX), THREAD_COMMAND_NEW)) {
         // Create a new thread.
         pthread_t new_thread;
         const int err =
             ::pthread_create(&new_thread, nullptr, thread_func, nullptr);
         if (err) {