Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 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 | |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 17 | #define _GNU_SOURCE 1 |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 18 | #include <elf.h> |
| 19 | #include <inttypes.h> |
| 20 | #include <stdint.h> |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 21 | #include <string.h> |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 22 | #include <sys/types.h> |
| 23 | #include <unistd.h> |
| 24 | |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 25 | #include <algorithm> |
| 26 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 27 | #include <android-base/stringprintf.h> |
Christopher Ferris | 98aaf4c | 2019-05-03 11:13:17 -0700 | [diff] [blame^] | 28 | #include <android-base/strings.h> |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 29 | |
Christopher Ferris | eb0772f | 2018-12-05 15:57:02 -0800 | [diff] [blame] | 30 | #include <demangle.h> |
| 31 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 32 | #include <unwindstack/Elf.h> |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame] | 33 | #include <unwindstack/JitDebug.h> |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 34 | #include <unwindstack/MapInfo.h> |
Yabin Cui | d5b22c5 | 2018-02-22 17:11:31 -0800 | [diff] [blame] | 35 | #include <unwindstack/Maps.h> |
Christopher Ferris | eb0772f | 2018-12-05 15:57:02 -0800 | [diff] [blame] | 36 | #include <unwindstack/Memory.h> |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 37 | #include <unwindstack/Unwinder.h> |
| 38 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 39 | #if !defined(NO_LIBDEXFILE_SUPPORT) |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 40 | #include <unwindstack/DexFiles.h> |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 41 | #endif |
| 42 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 43 | namespace unwindstack { |
| 44 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 45 | // Inject extra 'virtual' frame that represents the dex pc data. |
| 46 | // The dex pc is a magic register defined in the Mterp interpreter, |
| 47 | // and thus it will be restored/observed in the frame after it. |
| 48 | // Adding the dex frame first here will create something like: |
| 49 | // #7 pc 0015fa20 core.vdex java.util.Arrays.binarySearch+8 |
| 50 | // #8 pc 006b1ba1 libartd.so ExecuteMterpImpl+14625 |
| 51 | // #9 pc 0039a1ef libartd.so art::interpreter::Execute+719 |
| 52 | void Unwinder::FillInDexFrame() { |
| 53 | size_t frame_num = frames_.size(); |
| 54 | frames_.resize(frame_num + 1); |
| 55 | FrameData* frame = &frames_.at(frame_num); |
Christopher Ferris | 559c7f2 | 2018-02-12 20:18:03 -0800 | [diff] [blame] | 56 | frame->num = frame_num; |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 57 | |
| 58 | uint64_t dex_pc = regs_->dex_pc(); |
| 59 | frame->pc = dex_pc; |
| 60 | frame->sp = regs_->sp(); |
| 61 | |
Christopher Ferris | 7747b60 | 2018-01-31 19:05:19 -0800 | [diff] [blame] | 62 | MapInfo* info = maps_->Find(dex_pc); |
Christopher Ferris | e762f1f | 2018-02-06 14:51:48 -0800 | [diff] [blame] | 63 | if (info != nullptr) { |
| 64 | frame->map_start = info->start; |
| 65 | frame->map_end = info->end; |
Christopher Ferris | a09c4a6 | 2018-12-13 16:08:50 -0800 | [diff] [blame] | 66 | frame->map_elf_start_offset = info->elf_start_offset; |
| 67 | frame->map_exact_offset = info->offset; |
Christopher Ferris | e762f1f | 2018-02-06 14:51:48 -0800 | [diff] [blame] | 68 | frame->map_load_bias = info->load_bias; |
| 69 | frame->map_flags = info->flags; |
David Srbecky | e62f4c4 | 2018-03-16 18:44:04 +0000 | [diff] [blame] | 70 | if (resolve_names_) { |
| 71 | frame->map_name = info->name; |
| 72 | } |
Christopher Ferris | e762f1f | 2018-02-06 14:51:48 -0800 | [diff] [blame] | 73 | frame->rel_pc = dex_pc - info->start; |
| 74 | } else { |
| 75 | frame->rel_pc = dex_pc; |
| 76 | return; |
| 77 | } |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 78 | |
Christopher Ferris | e4b3a6a | 2018-02-20 13:58:40 -0800 | [diff] [blame] | 79 | if (!resolve_names_) { |
| 80 | return; |
| 81 | } |
| 82 | |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 83 | #if !defined(NO_LIBDEXFILE_SUPPORT) |
Christopher Ferris | 7747b60 | 2018-01-31 19:05:19 -0800 | [diff] [blame] | 84 | if (dex_files_ == nullptr) { |
| 85 | return; |
| 86 | } |
| 87 | |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 88 | dex_files_->GetMethodInformation(maps_, info, dex_pc, &frame->function_name, |
| 89 | &frame->function_offset); |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 90 | #endif |
| 91 | } |
| 92 | |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 93 | FrameData* Unwinder::FillInFrame(MapInfo* map_info, Elf* elf, uint64_t rel_pc, |
| 94 | uint64_t pc_adjustment) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 95 | size_t frame_num = frames_.size(); |
| 96 | frames_.resize(frame_num + 1); |
| 97 | FrameData* frame = &frames_.at(frame_num); |
| 98 | frame->num = frame_num; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 99 | frame->sp = regs_->sp(); |
Christopher Ferris | a2ec50b | 2018-02-21 15:39:07 -0800 | [diff] [blame] | 100 | frame->rel_pc = rel_pc - pc_adjustment; |
| 101 | frame->pc = regs_->pc() - pc_adjustment; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 102 | |
| 103 | if (map_info == nullptr) { |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 104 | // Nothing else to update. |
| 105 | return nullptr; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 106 | } |
| 107 | |
David Srbecky | e62f4c4 | 2018-03-16 18:44:04 +0000 | [diff] [blame] | 108 | if (resolve_names_) { |
| 109 | frame->map_name = map_info->name; |
Christopher Ferris | 02a6c44 | 2019-03-11 14:43:33 -0700 | [diff] [blame] | 110 | if (embedded_soname_ && map_info->elf_start_offset != 0 && !frame->map_name.empty()) { |
| 111 | std::string soname = elf->GetSoname(); |
| 112 | if (!soname.empty()) { |
| 113 | frame->map_name += '!' + soname; |
| 114 | } |
| 115 | } |
David Srbecky | e62f4c4 | 2018-03-16 18:44:04 +0000 | [diff] [blame] | 116 | } |
Christopher Ferris | a09c4a6 | 2018-12-13 16:08:50 -0800 | [diff] [blame] | 117 | frame->map_elf_start_offset = map_info->elf_start_offset; |
| 118 | frame->map_exact_offset = map_info->offset; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 119 | frame->map_start = map_info->start; |
| 120 | frame->map_end = map_info->end; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 121 | frame->map_flags = map_info->flags; |
| 122 | frame->map_load_bias = elf->GetLoadBias(); |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 123 | return frame; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 124 | } |
| 125 | |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 126 | static bool ShouldStop(const std::vector<std::string>* map_suffixes_to_ignore, |
| 127 | std::string& map_name) { |
Christopher Ferris | e69f470 | 2017-10-19 16:08:58 -0700 | [diff] [blame] | 128 | if (map_suffixes_to_ignore == nullptr) { |
| 129 | return false; |
| 130 | } |
| 131 | auto pos = map_name.find_last_of('.'); |
| 132 | if (pos == std::string::npos) { |
| 133 | return false; |
| 134 | } |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 135 | |
| 136 | return std::find(map_suffixes_to_ignore->begin(), map_suffixes_to_ignore->end(), |
| 137 | map_name.substr(pos + 1)) != map_suffixes_to_ignore->end(); |
Christopher Ferris | e69f470 | 2017-10-19 16:08:58 -0700 | [diff] [blame] | 138 | } |
| 139 | |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 140 | void Unwinder::Unwind(const std::vector<std::string>* initial_map_names_to_skip, |
| 141 | const std::vector<std::string>* map_suffixes_to_ignore) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 142 | frames_.clear(); |
Christopher Ferris | 2fcf4cf | 2018-01-23 17:52:23 -0800 | [diff] [blame] | 143 | last_error_.code = ERROR_NONE; |
| 144 | last_error_.address = 0; |
Christopher Ferris | 4ae266c | 2019-04-03 09:27:12 -0700 | [diff] [blame] | 145 | elf_from_memory_not_file_ = false; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 146 | |
Christopher Ferris | 4568f4b | 2018-10-23 17:42:41 -0700 | [diff] [blame] | 147 | ArchEnum arch = regs_->Arch(); |
| 148 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 149 | bool return_address_attempt = false; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 150 | bool adjust_pc = false; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 151 | for (; frames_.size() < max_frames_;) { |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 152 | uint64_t cur_pc = regs_->pc(); |
| 153 | uint64_t cur_sp = regs_->sp(); |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 154 | |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 155 | MapInfo* map_info = maps_->Find(regs_->pc()); |
Christopher Ferris | a2ec50b | 2018-02-21 15:39:07 -0800 | [diff] [blame] | 156 | uint64_t pc_adjustment = 0; |
| 157 | uint64_t step_pc; |
Yabin Cui | d5b22c5 | 2018-02-22 17:11:31 -0800 | [diff] [blame] | 158 | uint64_t rel_pc; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 159 | Elf* elf; |
| 160 | if (map_info == nullptr) { |
Yabin Cui | d5b22c5 | 2018-02-22 17:11:31 -0800 | [diff] [blame] | 161 | step_pc = regs_->pc(); |
| 162 | rel_pc = step_pc; |
Christopher Ferris | 2fcf4cf | 2018-01-23 17:52:23 -0800 | [diff] [blame] | 163 | last_error_.code = ERROR_INVALID_MAP; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 164 | } else { |
Christopher Ferris | e69f470 | 2017-10-19 16:08:58 -0700 | [diff] [blame] | 165 | if (ShouldStop(map_suffixes_to_ignore, map_info->name)) { |
| 166 | break; |
| 167 | } |
Christopher Ferris | 4568f4b | 2018-10-23 17:42:41 -0700 | [diff] [blame] | 168 | elf = map_info->GetElf(process_memory_, arch); |
Christopher Ferris | 4ae266c | 2019-04-03 09:27:12 -0700 | [diff] [blame] | 169 | // If this elf is memory backed, and there is a valid file, then set |
| 170 | // an indicator that we couldn't open the file. |
| 171 | if (!elf_from_memory_not_file_ && map_info->memory_backed_elf && !map_info->name.empty() && |
Christopher Ferris | 98aaf4c | 2019-05-03 11:13:17 -0700 | [diff] [blame^] | 172 | map_info->name[0] != '[' && !android::base::StartsWith(map_info->name, "/memfd:")) { |
Christopher Ferris | 4ae266c | 2019-04-03 09:27:12 -0700 | [diff] [blame] | 173 | elf_from_memory_not_file_ = true; |
| 174 | } |
Yabin Cui | d5b22c5 | 2018-02-22 17:11:31 -0800 | [diff] [blame] | 175 | step_pc = regs_->pc(); |
| 176 | rel_pc = elf->GetRelPc(step_pc, map_info); |
| 177 | // Everyone except elf data in gdb jit debug maps uses the relative pc. |
| 178 | if (!(map_info->flags & MAPS_FLAGS_JIT_SYMFILE_MAP)) { |
| 179 | step_pc = rel_pc; |
| 180 | } |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 181 | if (adjust_pc) { |
Christopher Ferris | a2ec50b | 2018-02-21 15:39:07 -0800 | [diff] [blame] | 182 | pc_adjustment = regs_->GetPcAdjustment(rel_pc, elf); |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 183 | } else { |
Christopher Ferris | a2ec50b | 2018-02-21 15:39:07 -0800 | [diff] [blame] | 184 | pc_adjustment = 0; |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame] | 185 | } |
Yabin Cui | d5b22c5 | 2018-02-22 17:11:31 -0800 | [diff] [blame] | 186 | step_pc -= pc_adjustment; |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame] | 187 | |
| 188 | // If the pc is in an invalid elf file, try and get an Elf object |
| 189 | // using the jit debug information. |
| 190 | if (!elf->valid() && jit_debug_ != nullptr) { |
Christopher Ferris | a2ec50b | 2018-02-21 15:39:07 -0800 | [diff] [blame] | 191 | uint64_t adjusted_jit_pc = regs_->pc() - pc_adjustment; |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 192 | Elf* jit_elf = jit_debug_->GetElf(maps_, adjusted_jit_pc); |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame] | 193 | if (jit_elf != nullptr) { |
| 194 | // The jit debug information requires a non relative adjusted pc. |
Christopher Ferris | a2ec50b | 2018-02-21 15:39:07 -0800 | [diff] [blame] | 195 | step_pc = adjusted_jit_pc; |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame] | 196 | elf = jit_elf; |
| 197 | } |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 198 | } |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 199 | } |
| 200 | |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 201 | FrameData* frame = nullptr; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 202 | if (map_info == nullptr || initial_map_names_to_skip == nullptr || |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 203 | std::find(initial_map_names_to_skip->begin(), initial_map_names_to_skip->end(), |
| 204 | basename(map_info->name.c_str())) == initial_map_names_to_skip->end()) { |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 205 | if (regs_->dex_pc() != 0) { |
| 206 | // Add a frame to represent the dex file. |
| 207 | FillInDexFrame(); |
Christopher Ferris | a8c3973 | 2018-02-12 08:46:19 -0800 | [diff] [blame] | 208 | // Clear the dex pc so that we don't repeat this frame later. |
| 209 | regs_->set_dex_pc(0); |
Christopher Ferris | 9d0ad23 | 2018-10-12 16:33:42 -0700 | [diff] [blame] | 210 | |
| 211 | // Make sure there is enough room for the real frame. |
| 212 | if (frames_.size() == max_frames_) { |
| 213 | last_error_.code = ERROR_MAX_FRAMES_EXCEEDED; |
| 214 | break; |
| 215 | } |
Christopher Ferris | d70ea5e | 2018-01-30 19:47:24 -0800 | [diff] [blame] | 216 | } |
| 217 | |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 218 | frame = FillInFrame(map_info, elf, rel_pc, pc_adjustment); |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 219 | |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 220 | // Once a frame is added, stop skipping frames. |
| 221 | initial_map_names_to_skip = nullptr; |
| 222 | } |
| 223 | adjust_pc = true; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 224 | |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 225 | bool stepped = false; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 226 | bool in_device_map = false; |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 227 | bool finished = false; |
| 228 | if (map_info != nullptr) { |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 229 | if (map_info->flags & MAPS_FLAGS_DEVICE_MAP) { |
| 230 | // Do not stop here, fall through in case we are |
| 231 | // in the speculative unwind path and need to remove |
| 232 | // some of the speculative frames. |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 233 | in_device_map = true; |
| 234 | } else { |
| 235 | MapInfo* sp_info = maps_->Find(regs_->sp()); |
| 236 | if (sp_info != nullptr && sp_info->flags & MAPS_FLAGS_DEVICE_MAP) { |
| 237 | // Do not stop here, fall through in case we are |
| 238 | // in the speculative unwind path and need to remove |
| 239 | // some of the speculative frames. |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 240 | in_device_map = true; |
| 241 | } else { |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 242 | if (elf->StepIfSignalHandler(rel_pc, regs_, process_memory_.get())) { |
| 243 | stepped = true; |
| 244 | if (frame != nullptr) { |
| 245 | // Need to adjust the relative pc because the signal handler |
| 246 | // pc should not be adjusted. |
| 247 | frame->rel_pc = rel_pc; |
| 248 | frame->pc += pc_adjustment; |
| 249 | step_pc = rel_pc; |
| 250 | } |
| 251 | } else if (elf->Step(step_pc, regs_, process_memory_.get(), &finished)) { |
| 252 | stepped = true; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 253 | } |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 254 | elf->GetLastError(&last_error_); |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 255 | } |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 256 | } |
| 257 | } |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 258 | |
Christopher Ferris | d11ed86 | 2019-04-11 19:45:35 -0700 | [diff] [blame] | 259 | if (frame != nullptr) { |
| 260 | if (!resolve_names_ || |
| 261 | !elf->GetFunctionName(step_pc, &frame->function_name, &frame->function_offset)) { |
| 262 | frame->function_name = ""; |
| 263 | frame->function_offset = 0; |
| 264 | } |
| 265 | } |
| 266 | |
| 267 | if (finished) { |
| 268 | break; |
| 269 | } |
| 270 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 271 | if (!stepped) { |
| 272 | if (return_address_attempt) { |
Christopher Ferris | 065f156 | 2018-12-13 09:33:45 -0800 | [diff] [blame] | 273 | // Only remove the speculative frame if there are more than two frames |
| 274 | // or the pc in the first frame is in a valid map. |
| 275 | // This allows for a case where the code jumps into the middle of |
| 276 | // nowhere, but there is no other unwind information after that. |
Florian Mayer | c479e4e | 2019-01-23 13:35:40 +0000 | [diff] [blame] | 277 | if (frames_.size() > 2 || (frames_.size() > 0 && maps_->Find(frames_[0].pc) != nullptr)) { |
Christopher Ferris | 065f156 | 2018-12-13 09:33:45 -0800 | [diff] [blame] | 278 | // Remove the speculative frame. |
| 279 | frames_.pop_back(); |
| 280 | } |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 281 | break; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 282 | } else if (in_device_map) { |
| 283 | // Do not attempt any other unwinding, pc or sp is in a device |
| 284 | // map. |
| 285 | break; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 286 | } else { |
| 287 | // Steping didn't work, try this secondary method. |
| 288 | if (!regs_->SetPcFromReturnAddress(process_memory_.get())) { |
| 289 | break; |
| 290 | } |
| 291 | return_address_attempt = true; |
| 292 | } |
| 293 | } else { |
| 294 | return_address_attempt = false; |
Christopher Ferris | 2fcf4cf | 2018-01-23 17:52:23 -0800 | [diff] [blame] | 295 | if (max_frames_ == frames_.size()) { |
| 296 | last_error_.code = ERROR_MAX_FRAMES_EXCEEDED; |
| 297 | } |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 298 | } |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 299 | |
| 300 | // If the pc and sp didn't change, then consider everything stopped. |
| 301 | if (cur_pc == regs_->pc() && cur_sp == regs_->sp()) { |
Christopher Ferris | 2fcf4cf | 2018-01-23 17:52:23 -0800 | [diff] [blame] | 302 | last_error_.code = ERROR_REPEATED_FRAME; |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 303 | break; |
| 304 | } |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 305 | } |
| 306 | } |
| 307 | |
Christopher Ferris | 7813345 | 2019-03-14 13:44:38 -0700 | [diff] [blame] | 308 | std::string Unwinder::FormatFrame(const FrameData& frame) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 309 | std::string data; |
Christopher Ferris | 7813345 | 2019-03-14 13:44:38 -0700 | [diff] [blame] | 310 | if (regs_->Is32Bit()) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 311 | data += android::base::StringPrintf(" #%02zu pc %08" PRIx64, frame.num, frame.rel_pc); |
| 312 | } else { |
| 313 | data += android::base::StringPrintf(" #%02zu pc %016" PRIx64, frame.num, frame.rel_pc); |
| 314 | } |
| 315 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 316 | if (frame.map_start == frame.map_end) { |
| 317 | // No valid map associated with this frame. |
| 318 | data += " <unknown>"; |
| 319 | } else if (!frame.map_name.empty()) { |
| 320 | data += " " + frame.map_name; |
| 321 | } else { |
| 322 | data += android::base::StringPrintf(" <anonymous:%" PRIx64 ">", frame.map_start); |
| 323 | } |
Christopher Ferris | a09c4a6 | 2018-12-13 16:08:50 -0800 | [diff] [blame] | 324 | |
| 325 | if (frame.map_elf_start_offset != 0) { |
| 326 | data += android::base::StringPrintf(" (offset 0x%" PRIx64 ")", frame.map_elf_start_offset); |
| 327 | } |
| 328 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 329 | if (!frame.function_name.empty()) { |
Christopher Ferris | eb0772f | 2018-12-05 15:57:02 -0800 | [diff] [blame] | 330 | data += " (" + demangle(frame.function_name.c_str()); |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 331 | if (frame.function_offset != 0) { |
| 332 | data += android::base::StringPrintf("+%" PRId64, frame.function_offset); |
| 333 | } |
| 334 | data += ')'; |
| 335 | } |
Christopher Ferris | 7813345 | 2019-03-14 13:44:38 -0700 | [diff] [blame] | 336 | |
| 337 | MapInfo* map_info = maps_->Find(frame.map_start); |
| 338 | if (map_info != nullptr && display_build_id_) { |
| 339 | std::string build_id = map_info->GetPrintableBuildID(); |
| 340 | if (!build_id.empty()) { |
| 341 | data += " (BuildId: " + build_id + ')'; |
| 342 | } |
| 343 | } |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 344 | return data; |
| 345 | } |
| 346 | |
Christopher Ferris | 7813345 | 2019-03-14 13:44:38 -0700 | [diff] [blame] | 347 | std::string Unwinder::FormatFrame(size_t frame_num) { |
| 348 | if (frame_num >= frames_.size()) { |
| 349 | return ""; |
| 350 | } |
| 351 | return FormatFrame(frames_[frame_num]); |
| 352 | } |
| 353 | |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 354 | void Unwinder::SetJitDebug(JitDebug* jit_debug, ArchEnum arch) { |
| 355 | jit_debug->SetArch(arch); |
| 356 | jit_debug_ = jit_debug; |
| 357 | } |
| 358 | |
| 359 | #if !defined(NO_LIBDEXFILE_SUPPORT) |
| 360 | void Unwinder::SetDexFiles(DexFiles* dex_files, ArchEnum arch) { |
| 361 | dex_files->SetArch(arch); |
| 362 | dex_files_ = dex_files; |
| 363 | } |
| 364 | #endif |
| 365 | |
| 366 | bool UnwinderFromPid::Init(ArchEnum arch) { |
Christopher Ferris | eb0772f | 2018-12-05 15:57:02 -0800 | [diff] [blame] | 367 | if (pid_ == getpid()) { |
| 368 | maps_ptr_.reset(new LocalMaps()); |
| 369 | } else { |
| 370 | maps_ptr_.reset(new RemoteMaps(pid_)); |
| 371 | } |
| 372 | if (!maps_ptr_->Parse()) { |
| 373 | return false; |
| 374 | } |
| 375 | maps_ = maps_ptr_.get(); |
| 376 | |
| 377 | process_memory_ = Memory::CreateProcessMemoryCached(pid_); |
| 378 | |
David Srbecky | b9cc4fb | 2019-04-05 18:23:32 +0000 | [diff] [blame] | 379 | jit_debug_ptr_.reset(new JitDebug(process_memory_)); |
| 380 | jit_debug_ = jit_debug_ptr_.get(); |
| 381 | SetJitDebug(jit_debug_, arch); |
| 382 | #if !defined(NO_LIBDEXFILE_SUPPORT) |
| 383 | dex_files_ptr_.reset(new DexFiles(process_memory_)); |
| 384 | dex_files_ = dex_files_ptr_.get(); |
| 385 | SetDexFiles(dex_files_, arch); |
| 386 | #endif |
| 387 | |
Christopher Ferris | eb0772f | 2018-12-05 15:57:02 -0800 | [diff] [blame] | 388 | return true; |
| 389 | } |
| 390 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 391 | } // namespace unwindstack |