simpleperf/perf_regs.cpp

   1 /*
   2  * Copyright (C) 2015 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "perf_regs.h"
  18
  19 #include <unordered_map>
  20 #include <android-base/logging.h>
  21 #include <android-base/stringprintf.h>
  22 #include <android-base/strings.h>
  23
  24 #include "perf_event.h"
  25
  26 ArchType ScopedCurrentArch::current_arch = GetBuildArch();
  27
  28 ArchType GetArchType(const std::string& arch) {
  29   if (arch == "x86" || arch == "i686") {
  30     return ARCH_X86_32;
  31   } else if (arch == "x86_64") {
  32     return ARCH_X86_64;
  33   } else if (arch == "aarch64") {
  34     return ARCH_ARM64;
  35   } else if (android::base::StartsWith(arch, "arm")) {
  36     return ARCH_ARM;
  37   }
  38   LOG(ERROR) << "unsupported arch: " << arch;
  39   return ARCH_UNSUPPORTED;
  40 }
  41
  42 ArchType GetArchForAbi(ArchType machine_arch, int abi) {
  43   if (abi == PERF_SAMPLE_REGS_ABI_32) {
  44     if (machine_arch == ARCH_X86_64) {
  45       return ARCH_X86_32;
  46     }
  47     if (machine_arch == ARCH_ARM64) {
  48       return ARCH_ARM;
  49     }
  50   }
  51   return machine_arch;
  52 }
  53
  54 std::string GetArchString(ArchType arch) {
  55   switch (arch) {
  56     case ARCH_X86_32:
  57       return "x86";
  58     case ARCH_X86_64:
  59       return "x86_64";
  60     case ARCH_ARM64:
  61       return "arm64";
  62     case ARCH_ARM:
  63       return "arm";
  64     default:
  65       break;
  66   }
  67   return "unknown";
  68 }
  69
  70 // If strict_check, must have arch1 == arch2.
  71 // Otherwise, allow X86_32 with X86_64, ARM with ARM64.
  72 bool IsArchTheSame(ArchType arch1, ArchType arch2, bool strict_check) {
  73   if (strict_check) {
  74     return arch1 == arch2;
  75   }
  76   switch (arch1) {
  77     case ARCH_X86_32:
  78     case ARCH_X86_64:
  79       return arch2 == ARCH_X86_32 || arch2 == ARCH_X86_64;
  80     case ARCH_ARM64:
  81     case ARCH_ARM:
  82       return arch2 == ARCH_ARM64 || arch2 == ARCH_ARM;
  83     default:
  84       break;
  85   }
  86   return arch1 == arch2;
  87 }
  88
  89 uint64_t GetSupportedRegMask(ArchType arch) {
  90   switch (arch) {
  91     case ARCH_X86_32:
  92       return ((1ULL << PERF_REG_X86_32_MAX) - 1);
  93     case ARCH_X86_64:
  94       return (((1ULL << PERF_REG_X86_64_MAX) - 1) & ~(1ULL << PERF_REG_X86_DS) &
  95               ~(1ULL << PERF_REG_X86_ES) & ~(1ULL << PERF_REG_X86_FS) & ~(1ULL << PERF_REG_X86_GS));
  96     case ARCH_ARM:
  97       return ((1ULL << PERF_REG_ARM_MAX) - 1);
  98     case ARCH_ARM64:
  99       return ((1ULL << PERF_REG_ARM64_MAX) - 1);
 100     default:
 101       return 0;
 102   }
 103   return 0;
 104 }
 105
 106 static std::unordered_map<size_t, std::string> x86_reg_map = {
 107     {PERF_REG_X86_AX, "ax"},       {PERF_REG_X86_BX, "bx"}, {PERF_REG_X86_CX, "cx"},
 108     {PERF_REG_X86_DX, "dx"},       {PERF_REG_X86_SI, "si"}, {PERF_REG_X86_DI, "di"},
 109     {PERF_REG_X86_BP, "bp"},       {PERF_REG_X86_SP, "sp"}, {PERF_REG_X86_IP, "ip"},
 110     {PERF_REG_X86_FLAGS, "flags"}, {PERF_REG_X86_CS, "cs"}, {PERF_REG_X86_SS, "ss"},
 111     {PERF_REG_X86_DS, "ds"},       {PERF_REG_X86_ES, "es"}, {PERF_REG_X86_FS, "fs"},
 112     {PERF_REG_X86_GS, "gs"},
 113 };
 114
 115 static std::unordered_map<size_t, std::string> arm_reg_map = {
 116     {PERF_REG_ARM_FP, "fp"}, {PERF_REG_ARM_IP, "ip"}, {PERF_REG_ARM_SP, "sp"},
 117     {PERF_REG_ARM_LR, "lr"}, {PERF_REG_ARM_PC, "pc"},
 118 };
 119
 120 static std::unordered_map<size_t, std::string> arm64_reg_map = {
 121     {PERF_REG_ARM64_LR, "lr"}, {PERF_REG_ARM64_SP, "sp"}, {PERF_REG_ARM64_PC, "pc"},
 122 };
 123
 124 std::string GetRegName(size_t regno, ArchType arch) {
 125   // Cast regno to int type to avoid -Werror=type-limits.
 126   int reg = static_cast<int>(regno);
 127   switch (arch) {
 128     case ARCH_X86_64: {
 129       if (reg >= PERF_REG_X86_R8 && reg <= PERF_REG_X86_R15) {
 130         return android::base::StringPrintf("r%d", reg - PERF_REG_X86_R8 + 8);
 131       }
 132     }  // go through
 133     case ARCH_X86_32: {
 134       auto it = x86_reg_map.find(reg);
 135       CHECK(it != x86_reg_map.end()) << "unknown reg " << reg;
 136       return it->second;
 137     }
 138     case ARCH_ARM: {
 139       if (reg >= PERF_REG_ARM_R0 && reg <= PERF_REG_ARM_R10) {
 140         return android::base::StringPrintf("r%d", reg - PERF_REG_ARM_R0);
 141       }
 142       auto it = arm_reg_map.find(reg);
 143       CHECK(it != arm_reg_map.end()) << "unknown reg " << reg;
 144       return it->second;
 145     }
 146     case ARCH_ARM64: {
 147       if (reg >= PERF_REG_ARM64_X0 && reg <= PERF_REG_ARM64_X29) {
 148         return android::base::StringPrintf("r%d", reg - PERF_REG_ARM64_X0);
 149       }
 150       auto it = arm64_reg_map.find(reg);
 151       CHECK(it != arm64_reg_map.end()) << "unknown reg " << reg;
 152       return it->second;
 153     }
 154     default:
 155       return "unknown";
 156   }
 157 }
 158
 159 RegSet CreateRegSet(uint64_t valid_mask, const std::vector<uint64_t>& valid_regs) {
 160   RegSet regs;
 161   regs.valid_mask = valid_mask;
 162   for (int i = 0, j = 0; i < 64; ++i) {
 163     if ((valid_mask >> i) & 1) {
 164       regs.data[i] = valid_regs[j++];
 165     }
 166   }
 167   return regs;
 168 }
 169
 170 bool GetRegValue(const RegSet& regs, size_t regno, uint64_t* value) {
 171   CHECK_LT(regno, 64U);
 172   if ((regs.valid_mask >> regno) & 1) {
 173     *value = regs.data[regno];
 174     return true;
 175   }
 176   return false;
 177 }
 178
 179 bool GetSpRegValue(const RegSet& regs, ArchType arch, uint64_t* value) {
 180   size_t regno;
 181   switch (arch) {
 182     case ARCH_X86_32:
 183       regno = PERF_REG_X86_SP;
 184       break;
 185     case ARCH_X86_64:
 186       regno = PERF_REG_X86_SP;
 187       break;
 188     case ARCH_ARM:
 189       regno = PERF_REG_ARM_SP;
 190       break;
 191     case ARCH_ARM64:
 192       regno = PERF_REG_ARM64_SP;
 193       break;
 194     default:
 195       return false;
 196   }
 197   return GetRegValue(regs, regno, value);
 198 }