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> |
| 28 | |
| 29 | #include <unwindstack/Elf.h> |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 30 | #include <unwindstack/JitDebug.h> |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 31 | #include <unwindstack/MapInfo.h> |
| 32 | #include <unwindstack/Unwinder.h> |
| 33 | |
| 34 | namespace unwindstack { |
| 35 | |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 36 | void Unwinder::FillInFrame(MapInfo* map_info, Elf* elf, uint64_t adjusted_rel_pc, uint64_t func_pc) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 37 | size_t frame_num = frames_.size(); |
| 38 | frames_.resize(frame_num + 1); |
| 39 | FrameData* frame = &frames_.at(frame_num); |
| 40 | frame->num = frame_num; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 41 | frame->sp = regs_->sp(); |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 42 | frame->rel_pc = adjusted_rel_pc; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 43 | |
| 44 | if (map_info == nullptr) { |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 45 | frame->pc = regs_->pc(); |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 46 | return; |
| 47 | } |
| 48 | |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 49 | frame->pc = map_info->start + adjusted_rel_pc; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 50 | frame->map_name = map_info->name; |
Christopher Ferris | c5a3baa | 2017-10-17 18:42:03 -0700 | [diff] [blame] | 51 | frame->map_offset = map_info->offset; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 52 | frame->map_start = map_info->start; |
| 53 | frame->map_end = map_info->end; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 54 | frame->map_flags = map_info->flags; |
| 55 | frame->map_load_bias = elf->GetLoadBias(); |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 56 | |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 57 | if (!elf->GetFunctionName(func_pc, &frame->function_name, &frame->function_offset)) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 58 | frame->function_name = ""; |
| 59 | frame->function_offset = 0; |
| 60 | } |
| 61 | } |
| 62 | |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 63 | static bool ShouldStop(const std::vector<std::string>* map_suffixes_to_ignore, |
| 64 | std::string& map_name) { |
Christopher Ferris | e69f470 | 2017-10-19 16:08:58 -0700 | [diff] [blame] | 65 | if (map_suffixes_to_ignore == nullptr) { |
| 66 | return false; |
| 67 | } |
| 68 | auto pos = map_name.find_last_of('.'); |
| 69 | if (pos == std::string::npos) { |
| 70 | return false; |
| 71 | } |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 72 | |
| 73 | return std::find(map_suffixes_to_ignore->begin(), map_suffixes_to_ignore->end(), |
| 74 | map_name.substr(pos + 1)) != map_suffixes_to_ignore->end(); |
Christopher Ferris | e69f470 | 2017-10-19 16:08:58 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 77 | void Unwinder::Unwind(const std::vector<std::string>* initial_map_names_to_skip, |
| 78 | const std::vector<std::string>* map_suffixes_to_ignore) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 79 | frames_.clear(); |
| 80 | |
| 81 | bool return_address_attempt = false; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 82 | bool adjust_pc = false; |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 83 | std::unique_ptr<JitDebug> jit_debug; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 84 | for (; frames_.size() < max_frames_;) { |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 85 | uint64_t cur_pc = regs_->pc(); |
| 86 | uint64_t cur_sp = regs_->sp(); |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 87 | |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 88 | MapInfo* map_info = maps_->Find(regs_->pc()); |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 89 | uint64_t rel_pc; |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 90 | uint64_t adjusted_pc; |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 91 | uint64_t adjusted_rel_pc; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 92 | Elf* elf; |
| 93 | if (map_info == nullptr) { |
| 94 | rel_pc = regs_->pc(); |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 95 | adjusted_rel_pc = rel_pc; |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 96 | adjusted_pc = rel_pc; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 97 | } else { |
Christopher Ferris | e69f470 | 2017-10-19 16:08:58 -0700 | [diff] [blame] | 98 | if (ShouldStop(map_suffixes_to_ignore, map_info->name)) { |
| 99 | break; |
| 100 | } |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 101 | elf = map_info->GetElf(process_memory_, true); |
| 102 | rel_pc = elf->GetRelPc(regs_->pc(), map_info); |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 103 | if (adjust_pc) { |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 104 | adjusted_pc = regs_->GetAdjustedPc(rel_pc, elf); |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 105 | } else { |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 106 | adjusted_pc = rel_pc; |
| 107 | } |
| 108 | adjusted_rel_pc = adjusted_pc; |
| 109 | |
| 110 | // If the pc is in an invalid elf file, try and get an Elf object |
| 111 | // using the jit debug information. |
| 112 | if (!elf->valid() && jit_debug_ != nullptr) { |
| 113 | uint64_t adjusted_jit_pc = regs_->pc() - (rel_pc - adjusted_pc); |
| 114 | Elf* jit_elf = jit_debug_->GetElf(maps_, adjusted_jit_pc); |
| 115 | if (jit_elf != nullptr) { |
| 116 | // The jit debug information requires a non relative adjusted pc. |
| 117 | adjusted_pc = adjusted_jit_pc; |
| 118 | adjusted_rel_pc = adjusted_pc - map_info->start; |
| 119 | elf = jit_elf; |
| 120 | } |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 121 | } |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 122 | } |
| 123 | |
| 124 | if (map_info == nullptr || initial_map_names_to_skip == nullptr || |
Christopher Ferris | 1cb84ce | 2017-10-24 15:36:00 -0700 | [diff] [blame] | 125 | std::find(initial_map_names_to_skip->begin(), initial_map_names_to_skip->end(), |
| 126 | basename(map_info->name.c_str())) == initial_map_names_to_skip->end()) { |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 127 | FillInFrame(map_info, elf, adjusted_rel_pc, adjusted_pc); |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 128 | |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 129 | // Once a frame is added, stop skipping frames. |
| 130 | initial_map_names_to_skip = nullptr; |
| 131 | } |
| 132 | adjust_pc = true; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 133 | |
| 134 | bool stepped; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 135 | bool in_device_map = false; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 136 | if (map_info == nullptr) { |
| 137 | stepped = false; |
| 138 | } else { |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 139 | if (map_info->flags & MAPS_FLAGS_DEVICE_MAP) { |
| 140 | // Do not stop here, fall through in case we are |
| 141 | // in the speculative unwind path and need to remove |
| 142 | // some of the speculative frames. |
| 143 | stepped = false; |
| 144 | in_device_map = true; |
| 145 | } else { |
| 146 | MapInfo* sp_info = maps_->Find(regs_->sp()); |
| 147 | if (sp_info != nullptr && sp_info->flags & MAPS_FLAGS_DEVICE_MAP) { |
| 148 | // Do not stop here, fall through in case we are |
| 149 | // in the speculative unwind path and need to remove |
| 150 | // some of the speculative frames. |
| 151 | stepped = false; |
| 152 | in_device_map = true; |
| 153 | } else { |
| 154 | bool finished; |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 155 | stepped = elf->Step(rel_pc, adjusted_pc, map_info->elf_offset, regs_, |
Christopher Ferris | c3d79f7 | 2017-11-28 19:14:54 -0800 | [diff] [blame] | 156 | process_memory_.get(), &finished); |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 157 | if (stepped && finished) { |
| 158 | break; |
| 159 | } |
| 160 | } |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 161 | } |
| 162 | } |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 163 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 164 | if (!stepped) { |
| 165 | if (return_address_attempt) { |
| 166 | // Remove the speculative frame. |
| 167 | frames_.pop_back(); |
| 168 | break; |
Christopher Ferris | f6f691b | 2017-09-25 19:23:07 -0700 | [diff] [blame] | 169 | } else if (in_device_map) { |
| 170 | // Do not attempt any other unwinding, pc or sp is in a device |
| 171 | // map. |
| 172 | break; |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 173 | } else { |
| 174 | // Steping didn't work, try this secondary method. |
| 175 | if (!regs_->SetPcFromReturnAddress(process_memory_.get())) { |
| 176 | break; |
| 177 | } |
| 178 | return_address_attempt = true; |
| 179 | } |
| 180 | } else { |
| 181 | return_address_attempt = false; |
| 182 | } |
Christopher Ferris | fda7edd | 2017-10-31 16:10:42 -0700 | [diff] [blame] | 183 | |
| 184 | // If the pc and sp didn't change, then consider everything stopped. |
| 185 | if (cur_pc == regs_->pc() && cur_sp == regs_->sp()) { |
| 186 | break; |
| 187 | } |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 188 | } |
| 189 | } |
| 190 | |
| 191 | std::string Unwinder::FormatFrame(size_t frame_num) { |
| 192 | if (frame_num >= frames_.size()) { |
| 193 | return ""; |
| 194 | } |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 195 | return FormatFrame(frames_[frame_num], regs_->Is32Bit()); |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 196 | } |
| 197 | |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 198 | std::string Unwinder::FormatFrame(const FrameData& frame, bool is32bit) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 199 | std::string data; |
| 200 | |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 201 | if (is32bit) { |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 202 | data += android::base::StringPrintf(" #%02zu pc %08" PRIx64, frame.num, frame.rel_pc); |
| 203 | } else { |
| 204 | data += android::base::StringPrintf(" #%02zu pc %016" PRIx64, frame.num, frame.rel_pc); |
| 205 | } |
| 206 | |
| 207 | if (frame.map_offset != 0) { |
| 208 | data += android::base::StringPrintf(" (offset 0x%" PRIx64 ")", frame.map_offset); |
| 209 | } |
| 210 | |
| 211 | if (frame.map_start == frame.map_end) { |
| 212 | // No valid map associated with this frame. |
| 213 | data += " <unknown>"; |
| 214 | } else if (!frame.map_name.empty()) { |
| 215 | data += " " + frame.map_name; |
| 216 | } else { |
| 217 | data += android::base::StringPrintf(" <anonymous:%" PRIx64 ">", frame.map_start); |
| 218 | } |
| 219 | if (!frame.function_name.empty()) { |
| 220 | data += " (" + frame.function_name; |
| 221 | if (frame.function_offset != 0) { |
| 222 | data += android::base::StringPrintf("+%" PRId64, frame.function_offset); |
| 223 | } |
| 224 | data += ')'; |
| 225 | } |
| 226 | return data; |
| 227 | } |
| 228 | |
Christopher Ferris | 150db12 | 2017-12-20 18:49:01 -0800 | [diff] [blame^] | 229 | void Unwinder::SetJitDebug(JitDebug* jit_debug, ArchEnum arch) { |
| 230 | jit_debug->SetArch(arch); |
| 231 | jit_debug_ = jit_debug; |
| 232 | } |
| 233 | |
Christopher Ferris | b9de87f | 2017-09-20 13:37:24 -0700 | [diff] [blame] | 234 | } // namespace unwindstack |