1 /*
2 * Copyright (C) 2016 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 <elf.h>
18 #include <stdint.h>
19
20 #include <unwindstack/MachineArm.h>
21 #include <unwindstack/Memory.h>
22 #include <unwindstack/RegsArm.h>
23
24 #include "ArmExidx.h"
25 #include "ElfInterfaceArm.h"
26
27 namespace unwindstack {
28
Init(int64_t * load_bias)29 bool ElfInterfaceArm::Init(int64_t* load_bias) {
30 if (!ElfInterface32::Init(load_bias)) {
31 return false;
32 }
33 load_bias_ = *load_bias;
34 return true;
35 }
36
FindEntry(uint32_t pc,uint64_t * entry_offset)37 bool ElfInterfaceArm::FindEntry(uint32_t pc, uint64_t* entry_offset) {
38 if (start_offset_ == 0 || total_entries_ == 0) {
39 last_error_.code = ERROR_UNWIND_INFO;
40 return false;
41 }
42
43 size_t first = 0;
44 size_t last = total_entries_;
45 while (first < last) {
46 size_t current = (first + last) / 2;
47 uint32_t addr = addrs_[current];
48 if (addr == 0) {
49 if (!GetPrel31Addr(start_offset_ + current * 8, &addr)) {
50 return false;
51 }
52 addrs_[current] = addr;
53 }
54 if (pc == addr) {
55 *entry_offset = start_offset_ + current * 8;
56 return true;
57 }
58 if (pc < addr) {
59 last = current;
60 } else {
61 first = current + 1;
62 }
63 }
64 if (last != 0) {
65 *entry_offset = start_offset_ + (last - 1) * 8;
66 return true;
67 }
68 last_error_.code = ERROR_UNWIND_INFO;
69 return false;
70 }
71
GetPrel31Addr(uint32_t offset,uint32_t * addr)72 bool ElfInterfaceArm::GetPrel31Addr(uint32_t offset, uint32_t* addr) {
73 uint32_t data;
74 if (!memory_->Read32(offset, &data)) {
75 last_error_.code = ERROR_MEMORY_INVALID;
76 last_error_.address = offset;
77 return false;
78 }
79
80 // Sign extend the value if necessary.
81 int32_t value = (static_cast<int32_t>(data) << 1) >> 1;
82 *addr = offset + value;
83 return true;
84 }
85
86 #if !defined(PT_ARM_EXIDX)
87 #define PT_ARM_EXIDX 0x70000001
88 #endif
89
HandleUnknownType(uint32_t type,uint64_t ph_offset,uint64_t ph_filesz)90 void ElfInterfaceArm::HandleUnknownType(uint32_t type, uint64_t ph_offset, uint64_t ph_filesz) {
91 if (type != PT_ARM_EXIDX) {
92 return;
93 }
94
95 // The offset already takes into account the load bias.
96 start_offset_ = ph_offset;
97
98 // Always use filesz instead of memsz. In most cases they are the same,
99 // but some shared libraries wind up setting one correctly and not the other.
100 total_entries_ = ph_filesz / 8;
101 }
102
Step(uint64_t pc,Regs * regs,Memory * process_memory,bool * finished,bool * is_signal_frame)103 bool ElfInterfaceArm::Step(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished,
104 bool* is_signal_frame) {
105 // Dwarf unwind information is precise about whether a pc is covered or not,
106 // but arm unwind information only has ranges of pc. In order to avoid
107 // incorrectly doing a bad unwind using arm unwind information for a
108 // different function, always try and unwind with the dwarf information first.
109 return ElfInterface32::Step(pc, regs, process_memory, finished, is_signal_frame) ||
110 StepExidx(pc, regs, process_memory, finished);
111 }
112
StepExidx(uint64_t pc,Regs * regs,Memory * process_memory,bool * finished)113 bool ElfInterfaceArm::StepExidx(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished) {
114 // Adjust the load bias to get the real relative pc.
115 if (pc < load_bias_) {
116 last_error_.code = ERROR_UNWIND_INFO;
117 return false;
118 }
119 pc -= load_bias_;
120
121 RegsArm* regs_arm = reinterpret_cast<RegsArm*>(regs);
122 uint64_t entry_offset;
123 if (!FindEntry(pc, &entry_offset)) {
124 return false;
125 }
126
127 ArmExidx arm(regs_arm, memory_, process_memory);
128 arm.set_cfa(regs_arm->sp());
129 bool return_value = false;
130 if (arm.ExtractEntryData(entry_offset) && arm.Eval()) {
131 // If the pc was not set, then use the LR registers for the PC.
132 if (!arm.pc_set()) {
133 (*regs_arm)[ARM_REG_PC] = (*regs_arm)[ARM_REG_LR];
134 }
135 (*regs_arm)[ARM_REG_SP] = arm.cfa();
136 return_value = true;
137
138 // If the pc was set to zero, consider this the final frame.
139 *finished = (regs_arm->pc() == 0) ? true : false;
140 }
141
142 if (arm.status() == ARM_STATUS_NO_UNWIND) {
143 *finished = true;
144 return true;
145 }
146
147 if (!return_value) {
148 switch (arm.status()) {
149 case ARM_STATUS_NONE:
150 case ARM_STATUS_NO_UNWIND:
151 case ARM_STATUS_FINISH:
152 last_error_.code = ERROR_NONE;
153 break;
154
155 case ARM_STATUS_RESERVED:
156 case ARM_STATUS_SPARE:
157 case ARM_STATUS_TRUNCATED:
158 case ARM_STATUS_MALFORMED:
159 case ARM_STATUS_INVALID_ALIGNMENT:
160 case ARM_STATUS_INVALID_PERSONALITY:
161 last_error_.code = ERROR_UNWIND_INFO;
162 break;
163
164 case ARM_STATUS_READ_FAILED:
165 last_error_.code = ERROR_MEMORY_INVALID;
166 last_error_.address = arm.status_address();
167 break;
168 }
169 }
170 return return_value;
171 }
172
GetFunctionName(uint64_t addr,SharedString * name,uint64_t * offset)173 bool ElfInterfaceArm::GetFunctionName(uint64_t addr, SharedString* name, uint64_t* offset) {
174 // For ARM, thumb function symbols have bit 0 set, but the address passed
175 // in here might not have this bit set and result in a failure to find
176 // the thumb function names. Adjust the address and offset to account
177 // for this possible case.
178 if (ElfInterface32::GetFunctionName(addr | 1, name, offset)) {
179 *offset &= ~1;
180 return true;
181 }
182 return false;
183 }
184
185 } // namespace unwindstack
186