Fix arm64 frame-pointer stackwalker

src/processor/stackwalker_arm64.cc

 // Copyright (c) 2013 Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 177 matching lines @@
 
   uint64_t last_fp = last_frame->context.iregs[MD_CONTEXT_ARM64_REG_FP];
 
   uint64_t caller_fp = 0;
   if (last_fp && !memory_->GetMemoryAtAddress(last_fp, &caller_fp)) {
     BPLOG(ERROR) << "Unable to read caller_fp from last_fp: 0x"
                  << std::hex << last_fp;
     return NULL;
   }
 
+  // The memory at last_fp + 8 is the last frame's LR (callee's lr), which is
+  // the PC of the caller.
+  uint64_t caller_pc = 0;
+  if (last_fp && !memory_->GetMemoryAtAddress(last_fp + 8, &caller_pc)) {
+    BPLOG(ERROR) << "Unable to read caller_pc from last_fp + 8: 0x"
+                 << std::hex << (last_fp + 8);
+    return NULL;
+  }
+
   uint64_t caller_lr = 0;
-  if (last_fp && !memory_->GetMemoryAtAddress(last_fp + 8, &caller_lr)) {
-    BPLOG(ERROR) << "Unable to read caller_lr from last_fp + 8: 0x"
-                 << std::hex << (last_fp + 8);
+  if (last_fp && !memory_->GetMemoryAtAddress(caller_fp + 8, &caller_lr)) {
+    BPLOG(ERROR) << "Unable to read caller_lr from caller_fp + 8: 0x"
+                 << std::hex << (caller_fp + 8);
     return NULL;
   }
 
   uint64_t caller_sp = last_fp ? last_fp + 16 :
       last_frame->context.iregs[MD_CONTEXT_ARM64_REG_SP];
 
   // Create a new stack frame (ownership will be transferred to the caller)
   // and fill it in.
   StackFrameARM64* frame = new StackFrameARM64();
 
   frame->trust = StackFrame::FRAME_TRUST_FP;
   frame->context = last_frame->context;
   frame->context.iregs[MD_CONTEXT_ARM64_REG_FP] = caller_fp;
   frame->context.iregs[MD_CONTEXT_ARM64_REG_SP] = caller_sp;
-  frame->context.iregs[MD_CONTEXT_ARM64_REG_PC] =
-      last_frame->context.iregs[MD_CONTEXT_ARM64_REG_LR];
+  frame->context.iregs[MD_CONTEXT_ARM64_REG_PC] = caller_pc;
   frame->context.iregs[MD_CONTEXT_ARM64_REG_LR] = caller_lr;
   frame->context_validity = StackFrameARM64::CONTEXT_VALID_PC |
                             StackFrameARM64::CONTEXT_VALID_LR |
                             StackFrameARM64::CONTEXT_VALID_FP |
                             StackFrameARM64::CONTEXT_VALID_SP;
   return frame;
 }
 
 StackFrame* StackwalkerARM64::GetCallerFrame(const CallStack* stack,
                                              bool stack_scan_allowed) {
@@ skipping 41 matching lines @@
   // the return address gets back to the beginning of the call instruction.
   // Callers that require the exact return address value may access
   // frame->context.iregs[MD_CONTEXT_ARM64_REG_PC].
   frame->instruction = frame->context.iregs[MD_CONTEXT_ARM64_REG_PC] - 4;
 
   return frame.release();
 }
 
 
 }  // namespace google_breakpad