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
HandleUnknownType(uint32_t type,uint64_t ph_offset,uint64_t ph_filesz)86 void ElfInterfaceArm::HandleUnknownType(uint32_t type, uint64_t ph_offset, uint64_t ph_filesz) {
87 if (type != PT_ARM_EXIDX) {
88 return;
89 }
90
91 // The offset already takes into account the load bias.
92 start_offset_ = ph_offset;
93
94 // Always use filesz instead of memsz. In most cases they are the same,
95 // but some shared libraries wind up setting one correctly and not the other.
96 total_entries_ = ph_filesz / 8;
97 }
98
Step(uint64_t pc,Regs * regs,Memory * process_memory,bool * finished,bool * is_signal_frame)99 bool ElfInterfaceArm::Step(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished,
100 bool* is_signal_frame) {
101 // Dwarf unwind information is precise about whether a pc is covered or not,
102 // but arm unwind information only has ranges of pc. In order to avoid
103 // incorrectly doing a bad unwind using arm unwind information for a
104 // different function, always try and unwind with the dwarf information first.
105 return ElfInterface32::Step(pc, regs, process_memory, finished, is_signal_frame) ||
106 StepExidx(pc, regs, process_memory, finished);
107 }
108
StepExidx(uint64_t pc,Regs * regs,Memory * process_memory,bool * finished)109 bool ElfInterfaceArm::StepExidx(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished) {
110 // Adjust the load bias to get the real relative pc.
111 if (pc < load_bias_) {
112 last_error_.code = ERROR_UNWIND_INFO;
113 return false;
114 }
115 pc -= load_bias_;
116
117 RegsArm* regs_arm = reinterpret_cast<RegsArm*>(regs);
118 uint64_t entry_offset;
119 if (!FindEntry(pc, &entry_offset)) {
120 return false;
121 }
122
123 ArmExidx arm(regs_arm, memory_.get(), process_memory);
124 arm.set_cfa(regs_arm->sp());
125 bool return_value = false;
126 if (arm.ExtractEntryData(entry_offset) && arm.Eval()) {
127 // If the pc was not set, then use the LR registers for the PC.
128 if (!arm.pc_set()) {
129 (*regs_arm)[ARM_REG_PC] = (*regs_arm)[ARM_REG_LR];
130 }
131 (*regs_arm)[ARM_REG_SP] = arm.cfa();
132 return_value = true;
133
134 // If the pc was set to zero, consider this the final frame.
135 *finished = (regs_arm->pc() == 0) ? true : false;
136 }
137
138 if (arm.status() == ARM_STATUS_NO_UNWIND) {
139 *finished = true;
140 return true;
141 }
142
143 if (!return_value) {
144 switch (arm.status()) {
145 case ARM_STATUS_NONE:
146 case ARM_STATUS_NO_UNWIND:
147 case ARM_STATUS_FINISH:
148 last_error_.code = ERROR_NONE;
149 break;
150
151 case ARM_STATUS_RESERVED:
152 case ARM_STATUS_SPARE:
153 case ARM_STATUS_TRUNCATED:
154 case ARM_STATUS_MALFORMED:
155 case ARM_STATUS_INVALID_ALIGNMENT:
156 case ARM_STATUS_INVALID_PERSONALITY:
157 last_error_.code = ERROR_UNWIND_INFO;
158 break;
159
160 case ARM_STATUS_READ_FAILED:
161 last_error_.code = ERROR_MEMORY_INVALID;
162 last_error_.address = arm.status_address();
163 break;
164 }
165 }
166 return return_value;
167 }
168
GetFunctionName(uint64_t addr,SharedString * name,uint64_t * offset)169 bool ElfInterfaceArm::GetFunctionName(uint64_t addr, SharedString* name, uint64_t* offset) {
170 // For ARM, thumb function symbols have bit 0 set, but the address passed
171 // in here might not have this bit set and result in a failure to find
172 // the thumb function names. Adjust the address and offset to account
173 // for this possible case.
174 if (ElfInterface32::GetFunctionName(addr | 1, name, offset)) {
175 *offset &= ~1;
176 return true;
177 }
178 return false;
179 }
180
181 } // namespace unwindstack
182