lldb handle breakpoints on ARM64

[pawelo]

Summary

The opcode was taken from gdb sources.

break set -n main
Breakpoint 1: where = example`$x, address = 0x0000000000400c60

Note that for me, gdb worked only with statically linked binaries on emulated AArch64 machine, therefore from now on I'm testing lldb with statically linked binaries too.

Still much work must be done in order to provide full AArch64 support.

[pawelo]

On gdb, the same breakpoint in the same binary is situated 8 bytes further...

(gdb) break main
Breakpoint 1 at 0x400c68

[tfiala]

Look at this now (in isolation from http://reviews.llvm.org/D4803).

[tfiala]

Minor style nit - parens around sizeof arg to match rest of code.

When you address that, if you wanted to fix the Error idiomatic usage I pointed out (which is due to me - you're just following my non-idiomatic usage of Error), feel free to clean that up in those two routines. If not, I'll catch up with it later in another pass.

Other than that, LGTM.

Tested:
Ubuntu 14.04 x86_64, llvm-3.5-built lldb, all tests passed except for unrelated TestCallStopAndContinue.py, which fails intermittently on my system.

source/Plugins/Platform/Linux/PlatformLinux.cpp

429

style: use parens around sizeof's argument to match other code.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2893

Add parens around sizeof arg (i.e. sizeof (g_aarch64_opcode)).

Idiomatic usage: (this is my fault): we generally define an Error at the top of the method, then set it and return the local error value rather than create a new one.

If you want to put an Error object at the top:

Error error;
...
    return error;

and replace the other Error usages in the function, that would be fine. Otherwise, I'll do a clean sweep later and fix that.

2927

parens around sizeof arg.

2928

Idiomatic usage. (again my original sin). You don't have to clean this up, I'll make a pass on it at another time if not.

[pawelo]

I really don't like to put brackets around objects/variables/constants - sizeof requires them only for type names. I'm doing this only to fit into existing code.

[tfiala]

LGTM.

Tested:
Ubuntu 14.04 x86_64: llvm-3.5-built lldb. All tests passed.

[tfiala]

svn commit
Sending source/Plugins/Platform/Linux/PlatformLinux.cpp
Sending source/Plugins/Process/Linux/NativeProcessLinux.cpp
Transmitting file data ..
Committed revision 216188.

source/Plugins/Platform/Linux/PlatformLinux.cpp

PlatformLinux::GetSoftwareBreakpointTrapOpcode (Target &target,
     size_t trap_opcode_size = 0;
 
     switch (arch.GetMachine())
     {
     default:
         assert(false && "CPU type not supported!");
         break;
             
+    case llvm::Triple::aarch64:
+        {
+            static const uint8_t g_aarch64_opcode[] = { 0x00, 0x00, 0x20, 0xd4 };
+            trap_opcode = g_aarch64_opcode;
+            trap_opcode_size = sizeof g_aarch64_opcode;
+        }
+        break;
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
         {
             static const uint8_t g_i386_breakpoint_opcode[] = { 0xCC };
             trap_opcode = g_i386_breakpoint_opcode;
             trap_opcode_size = sizeof(g_i386_breakpoint_opcode);
         }
         break;

source/Plugins/Process/Linux/NativeProcessLinux.cpp

NativeProcessLinux::GetArchitecture (ArchSpec &arch) const
     return true;
 }
 
 Error
 NativeProcessLinux::GetSoftwareBreakpointSize (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size)
 {
     // FIXME put this behind a breakpoint protocol class that can be
     // set per architecture.  Need ARM, MIPS support here.
+    static const uint8_t g_aarch64_opcode[] = { 0x00, 0x00, 0x20, 0xd4 };
     static const uint8_t g_i386_opcode [] = { 0xCC };
 
     switch (m_arch.GetMachine ())
     {
+        case llvm::Triple::aarch64:
+            actual_opcode_size = static_cast<uint32_t> (sizeof g_aarch64_opcode);
+            return Error ();
+
         case llvm::Triple::x86:
         case llvm::Triple::x86_64:
             actual_opcode_size = static_cast<uint32_t> (sizeof(g_i386_opcode));
             return Error ();
 
         default:
             assert(false && "CPU type not supported!");
             return Error ("CPU type not supported");
else
         return SetSoftwareBreakpoint (addr, size);
 }
 
 Error
 NativeProcessLinux::GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes)
 {
     // FIXME put this behind a breakpoint protocol class that can be
     // set per architecture.  Need ARM, MIPS support here.
+    static const uint8_t g_aarch64_opcode[] = { 0x00, 0x00, 0x20, 0xd4 };
     static const uint8_t g_i386_opcode [] = { 0xCC };
 
     switch (m_arch.GetMachine ())
     {
+    case llvm::Triple::aarch64:
+        trap_opcode_bytes = g_aarch64_opcode;
+        actual_opcode_size = sizeof g_aarch64_opcode;
+        return Error ();
+
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
         trap_opcode_bytes = g_i386_opcode;
         actual_opcode_size = sizeof(g_i386_opcode);
         return Error ();
 
     default:
         assert(false && "CPU type not supported!");