Proyectos de Subversion Iphone Microlearning

// Copyright 2019 Google

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#include "Crashlytics/Crashlytics/Unwind/Compact/FIRCLSCompactUnwind.h"

#include "Crashlytics/Crashlytics/Unwind/Compact/FIRCLSCompactUnwind_Private.h"

#include "Crashlytics/Crashlytics/Helpers/FIRCLSDefines.h"

#include "Crashlytics/Crashlytics/Unwind/Dwarf/FIRCLSDwarfUnwind.h"

#include "Crashlytics/Crashlytics/Helpers/FIRCLSFeatures.h"

#include "Crashlytics/Crashlytics/Unwind/FIRCLSUnwind.h"

#include "Crashlytics/Crashlytics/Unwind/FIRCLSUnwind_arch.h"

#include "Crashlytics/Crashlytics/Helpers/FIRCLSUtility.h"

#if CLS_CPU_ARM || CLS_CPU_ARM64

static bool FIRCLSUnwindWithLRRegister(FIRCLSThreadContext* registers) {

  if (!FIRCLSIsValidPointer(registers)) {

    return false;

  }

  // Return address is in LR, SP is pointing to the next frame.

  uintptr_t value = FIRCLSThreadContextGetLinkRegister(registers);

  if (!FIRCLSIsValidPointer(value)) {

    FIRCLSSDKLog("Error: LR value is invalid\n");

    return false;

  }

  return FIRCLSThreadContextSetPC(registers, value);

}

bool FIRCLSUnwindWithFramePointer(FIRCLSThreadContext* registers, bool allowScanning) {

  if (allowScanning) {

    // The LR register does have the return address here, but there are situations where

    // this can produce false matches. Better backend rules can fix this up in many cases.

    if (FIRCLSUnwindWithLRRegister(registers)) {

      return true;

    } else {

      // In this case, we're unable to use the LR. We don't want to just stop unwinding, so

      // proceed with the normal, non-scanning path

      FIRCLSSDKLog("Unable to use LR, skipping\n");

    }

  }

  // read the values from the stack

  const uintptr_t framePointer = FIRCLSThreadContextGetFramePointer(registers);

  uintptr_t stack[2];

  if (!FIRCLSReadMemory((vm_address_t)framePointer, stack, sizeof(stack))) {

    // unable to read the first stack frame

    FIRCLSSDKLog("Error: failed to read memory at address %p\n", (void*)framePointer);

    return false;

  }

  if (!FIRCLSThreadContextSetPC(registers, stack[1])) {

    return false;

  }

  if (!FIRCLSThreadContextSetFramePointer(registers, stack[0])) {

    return false;

  }

  if (!FIRCLSThreadContextSetStackPointer(registers,

                                          FIRCLSUnwindStackPointerFromFramePointer(framePointer))) {

    return false;

  }

  return true;

}

uintptr_t FIRCLSUnwindStackPointerFromFramePointer(uintptr_t framePtr) {

  // the stack pointer is the frame pointer plus the two saved pointers for the frame

  return framePtr + 2 * sizeof(void*);

}

#if CLS_COMPACT_UNWINDING_SUPPORTED

bool FIRCLSCompactUnwindComputeRegisters(FIRCLSCompactUnwindContext* context,

                                         FIRCLSCompactUnwindResult* result,

                                         FIRCLSThreadContext* registers) {

  if (!context || !result || !registers) {

    return false;

  }

  // Note that compact_uwnind_encoding.h has a few bugs in it prior to iOS 8.0.

  // Only refer to the >= 8.0 header.

  switch (result->encoding & UNWIND_ARM64_MODE_MASK) {

    case UNWIND_ARM64_MODE_FRAMELESS:

      // Interestingly, we also know the size of the stack frame, by

      // using UNWIND_ARM64_FRAMELESS_STACK_SIZE_MASK. Is that useful?

      return FIRCLSUnwindWithLRRegister(registers);

      break;

    case UNWIND_ARM64_MODE_DWARF:

      return FIRCLSCompactUnwindDwarfFrame(

          context, result->encoding & UNWIND_ARM64_DWARF_SECTION_OFFSET, registers);

      break;

    case UNWIND_ARM64_MODE_FRAME:

      return FIRCLSUnwindWithFramePointer(registers, false);

    default:

      FIRCLSSDKLog("Invalid encoding 0x%x\n", result->encoding);

      break;

  }

  return false;

}

#endif

#if CLS_DWARF_UNWINDING_SUPPORTED

uintptr_t FIRCLSDwarfUnwindGetRegisterValue(const FIRCLSThreadContext* registers, uint64_t num) {

  switch (num) {

    case CLS_DWARF_ARM64_X0:

      return registers->__ss.__x[0];

    case CLS_DWARF_ARM64_X1:

      return registers->__ss.__x[1];

    case CLS_DWARF_ARM64_X2:

      return registers->__ss.__x[2];

    case CLS_DWARF_ARM64_X3:

      return registers->__ss.__x[3];

    case CLS_DWARF_ARM64_X4:

      return registers->__ss.__x[4];

    case CLS_DWARF_ARM64_X5:

      return registers->__ss.__x[5];

    case CLS_DWARF_ARM64_X6:

      return registers->__ss.__x[6];

    case CLS_DWARF_ARM64_X7:

      return registers->__ss.__x[7];

    case CLS_DWARF_ARM64_X8:

      return registers->__ss.__x[8];

    case CLS_DWARF_ARM64_X9:

      return registers->__ss.__x[9];

    case CLS_DWARF_ARM64_X10:

      return registers->__ss.__x[10];

    case CLS_DWARF_ARM64_X11:

      return registers->__ss.__x[11];

    case CLS_DWARF_ARM64_X12:

      return registers->__ss.__x[12];

    case CLS_DWARF_ARM64_X13:

      return registers->__ss.__x[13];

    case CLS_DWARF_ARM64_X14:

      return registers->__ss.__x[14];

    case CLS_DWARF_ARM64_X15:

      return registers->__ss.__x[15];

    case CLS_DWARF_ARM64_X16:

      return registers->__ss.__x[16];

    case CLS_DWARF_ARM64_X17:

      return registers->__ss.__x[17];

    case CLS_DWARF_ARM64_X18:

      return registers->__ss.__x[18];

    case CLS_DWARF_ARM64_X19:

      return registers->__ss.__x[19];

    case CLS_DWARF_ARM64_X20:

      return registers->__ss.__x[20];

    case CLS_DWARF_ARM64_X21:

      return registers->__ss.__x[21];

    case CLS_DWARF_ARM64_X22:

      return registers->__ss.__x[22];

    case CLS_DWARF_ARM64_X23:

      return registers->__ss.__x[23];

    case CLS_DWARF_ARM64_X24:

      return registers->__ss.__x[24];

    case CLS_DWARF_ARM64_X25:

      return registers->__ss.__x[25];

    case CLS_DWARF_ARM64_X26:

      return registers->__ss.__x[26];

    case CLS_DWARF_ARM64_X27:

      return registers->__ss.__x[27];

    case CLS_DWARF_ARM64_X28:

      return registers->__ss.__x[28];

    case CLS_DWARF_ARM64_FP:

      return FIRCLSThreadContextGetFramePointer(registers);

    case CLS_DWARF_ARM64_LR:

      return FIRCLSThreadContextGetLinkRegister(registers);

    case CLS_DWARF_ARM64_SP:

      return FIRCLSThreadContextGetStackPointer(registers);

    default:

      break;

  }

  FIRCLSSDKLog("Error: Unrecognized get register number %llu\n", num);

  return 0;

}

bool FIRCLSDwarfUnwindSetRegisterValue(FIRCLSThreadContext* registers,

                                       uint64_t num,

                                       uintptr_t value) {

  switch (num) {

    case CLS_DWARF_ARM64_X0:

      registers->__ss.__x[0] = value;

      return true;

    case CLS_DWARF_ARM64_X1:

      registers->__ss.__x[1] = value;

      return true;

    case CLS_DWARF_ARM64_X2:

      registers->__ss.__x[2] = value;

      return true;

    case CLS_DWARF_ARM64_X3:

      registers->__ss.__x[3] = value;

      return true;

    case CLS_DWARF_ARM64_X4:

      registers->__ss.__x[4] = value;

      return true;

    case CLS_DWARF_ARM64_X5:

      registers->__ss.__x[5] = value;

      return true;

    case CLS_DWARF_ARM64_X6:

      registers->__ss.__x[6] = value;

      return true;

    case CLS_DWARF_ARM64_X7:

      registers->__ss.__x[7] = value;

      return true;

    case CLS_DWARF_ARM64_X8:

      registers->__ss.__x[8] = value;

      return true;

    case CLS_DWARF_ARM64_X9:

      registers->__ss.__x[9] = value;

      return true;

    case CLS_DWARF_ARM64_X10:

      registers->__ss.__x[10] = value;

      return true;

    case CLS_DWARF_ARM64_X11:

      registers->__ss.__x[11] = value;

      return true;

    case CLS_DWARF_ARM64_X12:

      registers->__ss.__x[12] = value;

      return true;

    case CLS_DWARF_ARM64_X13:

      registers->__ss.__x[13] = value;

      return true;

    case CLS_DWARF_ARM64_X14:

      registers->__ss.__x[14] = value;

      return true;

    case CLS_DWARF_ARM64_X15:

      registers->__ss.__x[15] = value;

      return true;

    case CLS_DWARF_ARM64_X16:

      registers->__ss.__x[16] = value;

      return true;

    case CLS_DWARF_ARM64_X17:

      registers->__ss.__x[17] = value;

      return true;

    case CLS_DWARF_ARM64_X18:

      registers->__ss.__x[18] = value;

      return true;

    case CLS_DWARF_ARM64_X19:

      registers->__ss.__x[19] = value;

      return true;

    case CLS_DWARF_ARM64_X20:

      registers->__ss.__x[20] = value;

      return true;

    case CLS_DWARF_ARM64_X21:

      registers->__ss.__x[21] = value;

      return true;

    case CLS_DWARF_ARM64_X22:

      registers->__ss.__x[22] = value;

      return true;

    case CLS_DWARF_ARM64_X23:

      registers->__ss.__x[23] = value;

      return true;

    case CLS_DWARF_ARM64_X24:

      registers->__ss.__x[24] = value;

      return true;

    case CLS_DWARF_ARM64_X25:

      registers->__ss.__x[25] = value;

      return true;

    case CLS_DWARF_ARM64_X26:

      registers->__ss.__x[26] = value;

      return true;

    case CLS_DWARF_ARM64_X27:

      registers->__ss.__x[27] = value;

      return true;

    case CLS_DWARF_ARM64_X28:

      registers->__ss.__x[28] = value;

      return true;

    case CLS_DWARF_ARM64_FP:

      FIRCLSThreadContextSetFramePointer(registers, value);

      return true;

    case CLS_DWARF_ARM64_SP:

      FIRCLSThreadContextSetStackPointer(registers, value);

      return true;

    case CLS_DWARF_ARM64_LR:

      // Here's what's going on. For x86, the "return register" is virtual. The architecture

      // doesn't actually have one, but DWARF does have the concept. So, when the system

      // tries to set the return register, we set the PC. You can see this behavior

      // in the FIRCLSDwarfUnwindSetRegisterValue implemenation for that architecture. In the

      // case of ARM64, the register is real. So, we have to be extra careful to make sure

      // we update the PC here. Otherwise, when a DWARF unwind completes, it won't have

      // changed the PC to the right value.

      FIRCLSThreadContextSetLinkRegister(registers, value);

      FIRCLSThreadContextSetPC(registers, value);

      return true;

    default:

      break;

  }

  FIRCLSSDKLog("Unrecognized set register number %llu\n", num);

  return false;

}

#endif

#else

INJECT_STRIP_SYMBOL(unwind_arm)

#endif