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 <string.h>
20
21 #include <android-base/logging.h>
22 #include <android-base/stringprintf.h>
23 #include <android-base/strings.h>
24 #include <unordered_map>
25
26 #include "perf_event.h"
27
28 namespace simpleperf {
29
30 ArchType ScopedCurrentArch::current_arch = ARCH_UNSUPPORTED;
31
GetArchType(const std::string & arch)32 ArchType GetArchType(const std::string& arch) {
33 if (arch == "x86" || arch == "i686") {
34 return ARCH_X86_32;
35 } else if (arch == "x86_64") {
36 return ARCH_X86_64;
37 } else if (arch == "aarch64") {
38 return ARCH_ARM64;
39 } else if (android::base::StartsWith(arch, "arm")) {
40 // If arch is "armv8l", it is likely that we are using a 32-bit simpleperf
41 // binary on a aarch64 device. In this case, the profiling environment is
42 // ARCH_ARM64, because the kernel is aarch64.
43 if (arch[3] == 'v') {
44 int version = atoi(&arch[4]);
45 if (version >= 8) {
46 return ARCH_ARM64;
47 }
48 }
49 return ARCH_ARM;
50 }
51 LOG(ERROR) << "unsupported arch: " << arch;
52 return ARCH_UNSUPPORTED;
53 }
54
GetArchForAbi(ArchType machine_arch,int abi)55 ArchType GetArchForAbi(ArchType machine_arch, int abi) {
56 if (abi == PERF_SAMPLE_REGS_ABI_32) {
57 if (machine_arch == ARCH_X86_64) {
58 return ARCH_X86_32;
59 }
60 if (machine_arch == ARCH_ARM64) {
61 return ARCH_ARM;
62 }
63 } else if (abi == PERF_SAMPLE_REGS_ABI_64) {
64 if (machine_arch == ARCH_X86_32) {
65 return ARCH_X86_64;
66 }
67 if (machine_arch == ARCH_ARM) {
68 return ARCH_ARM64;
69 }
70 }
71 return machine_arch;
72 }
73
GetArchString(ArchType arch)74 std::string GetArchString(ArchType arch) {
75 switch (arch) {
76 case ARCH_X86_32:
77 return "x86";
78 case ARCH_X86_64:
79 return "x86_64";
80 case ARCH_ARM64:
81 return "arm64";
82 case ARCH_ARM:
83 return "arm";
84 default:
85 break;
86 }
87 return "unknown";
88 }
89
GetSupportedRegMask(ArchType arch)90 uint64_t GetSupportedRegMask(ArchType arch) {
91 switch (arch) {
92 case ARCH_X86_32:
93 return ((1ULL << PERF_REG_X86_32_MAX) - 1) & ~(1ULL << PERF_REG_X86_DS) &
94 ~(1ULL << PERF_REG_X86_ES) & ~(1ULL << PERF_REG_X86_FS) & ~(1ULL << PERF_REG_X86_GS);
95 case ARCH_X86_64:
96 return (((1ULL << PERF_REG_X86_64_MAX) - 1) & ~(1ULL << PERF_REG_X86_DS) &
97 ~(1ULL << PERF_REG_X86_ES) & ~(1ULL << PERF_REG_X86_FS) & ~(1ULL << PERF_REG_X86_GS));
98 case ARCH_ARM:
99 return ((1ULL << PERF_REG_ARM_MAX) - 1);
100 case ARCH_ARM64:
101 return ((1ULL << PERF_REG_ARM64_MAX) - 1);
102 default:
103 return 0;
104 }
105 return 0;
106 }
107
108 static std::unordered_map<size_t, std::string> x86_reg_map = {
109 {PERF_REG_X86_AX, "ax"}, {PERF_REG_X86_BX, "bx"}, {PERF_REG_X86_CX, "cx"},
110 {PERF_REG_X86_DX, "dx"}, {PERF_REG_X86_SI, "si"}, {PERF_REG_X86_DI, "di"},
111 {PERF_REG_X86_BP, "bp"}, {PERF_REG_X86_SP, "sp"}, {PERF_REG_X86_IP, "ip"},
112 {PERF_REG_X86_FLAGS, "flags"}, {PERF_REG_X86_CS, "cs"}, {PERF_REG_X86_SS, "ss"},
113 {PERF_REG_X86_DS, "ds"}, {PERF_REG_X86_ES, "es"}, {PERF_REG_X86_FS, "fs"},
114 {PERF_REG_X86_GS, "gs"},
115 };
116
117 static std::unordered_map<size_t, std::string> arm_reg_map = {
118 {PERF_REG_ARM_FP, "fp"}, {PERF_REG_ARM_IP, "ip"}, {PERF_REG_ARM_SP, "sp"},
119 {PERF_REG_ARM_LR, "lr"}, {PERF_REG_ARM_PC, "pc"},
120 };
121
122 static std::unordered_map<size_t, std::string> arm64_reg_map = {
123 {PERF_REG_ARM64_LR, "lr"},
124 {PERF_REG_ARM64_SP, "sp"},
125 {PERF_REG_ARM64_PC, "pc"},
126 };
127
GetRegName(size_t regno,ArchType arch)128 std::string GetRegName(size_t regno, ArchType arch) {
129 // Cast regno to int type to avoid -Werror=type-limits.
130 int reg = static_cast<int>(regno);
131 switch (arch) {
132 case ARCH_X86_64: {
133 if (reg >= PERF_REG_X86_R8 && reg <= PERF_REG_X86_R15) {
134 return android::base::StringPrintf("r%d", reg - PERF_REG_X86_R8 + 8);
135 }
136 FALLTHROUGH_INTENDED;
137 }
138 case ARCH_X86_32: {
139 auto it = x86_reg_map.find(reg);
140 CHECK(it != x86_reg_map.end()) << "unknown reg " << reg;
141 return it->second;
142 }
143 case ARCH_ARM: {
144 if (reg >= PERF_REG_ARM_R0 && reg <= PERF_REG_ARM_R10) {
145 return android::base::StringPrintf("r%d", reg - PERF_REG_ARM_R0);
146 }
147 if (auto it = arm_reg_map.find(reg); it != arm_reg_map.end()) {
148 return it->second;
149 }
150 FALLTHROUGH_INTENDED;
151 }
152 case ARCH_ARM64: {
153 if (reg >= PERF_REG_ARM64_X0 && reg <= PERF_REG_ARM64_X29) {
154 return android::base::StringPrintf("r%d", reg - PERF_REG_ARM64_X0);
155 }
156 auto it = arm64_reg_map.find(reg);
157 CHECK(it != arm64_reg_map.end()) << "unknown reg " << reg;
158 return it->second;
159 }
160 default:
161 return "unknown";
162 }
163 }
164
RegSet(int abi,uint64_t valid_mask,const uint64_t * valid_regs)165 RegSet::RegSet(int abi, uint64_t valid_mask, const uint64_t* valid_regs) : valid_mask(valid_mask) {
166 arch = GetArchForAbi(ScopedCurrentArch::GetCurrentArch(), abi);
167 memset(data, 0, sizeof(data));
168 for (int i = 0, j = 0; i < 64; ++i) {
169 if ((valid_mask >> i) & 1) {
170 data[i] = valid_regs[j++];
171 }
172 }
173 if (ScopedCurrentArch::GetCurrentArch() == ARCH_ARM64 && abi == PERF_SAMPLE_REGS_ABI_32) {
174 // The kernel dumps arm64 regs, but we need arm regs. So map arm64 regs into arm regs.
175 data[PERF_REG_ARM_PC] = data[PERF_REG_ARM64_PC];
176 }
177 }
178
GetRegValue(size_t regno,uint64_t * value) const179 bool RegSet::GetRegValue(size_t regno, uint64_t* value) const {
180 CHECK_LT(regno, 64U);
181 if ((valid_mask >> regno) & 1) {
182 *value = data[regno];
183 return true;
184 }
185 return false;
186 }
187
GetSpRegValue(uint64_t * value) const188 bool RegSet::GetSpRegValue(uint64_t* value) const {
189 size_t regno;
190 switch (arch) {
191 case ARCH_X86_32:
192 regno = PERF_REG_X86_SP;
193 break;
194 case ARCH_X86_64:
195 regno = PERF_REG_X86_SP;
196 break;
197 case ARCH_ARM:
198 regno = PERF_REG_ARM_SP;
199 break;
200 case ARCH_ARM64:
201 regno = PERF_REG_ARM64_SP;
202 break;
203 default:
204 return false;
205 }
206 return GetRegValue(regno, value);
207 }
208
GetIpRegValue(uint64_t * value) const209 bool RegSet::GetIpRegValue(uint64_t* value) const {
210 size_t regno;
211 switch (arch) {
212 case ARCH_X86_64:
213 case ARCH_X86_32:
214 regno = PERF_REG_X86_IP;
215 break;
216 case ARCH_ARM:
217 regno = PERF_REG_ARM_PC;
218 break;
219 case ARCH_ARM64:
220 regno = PERF_REG_ARM64_PC;
221 break;
222 default:
223 return false;
224 }
225 return GetRegValue(regno, value);
226 }
227
228 } // namespace simpleperf
229