• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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(uint64_t * load_bias)29 bool ElfInterfaceArm::Init(uint64_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)103 bool ElfInterfaceArm::Step(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished) {
104   // Dwarf unwind information is precise about whether a pc is covered or not,
105   // but arm unwind information only has ranges of pc. In order to avoid
106   // incorrectly doing a bad unwind using arm unwind information for a
107   // different function, always try and unwind with the dwarf information first.
108   return ElfInterface32::Step(pc, regs, process_memory, finished) ||
109          StepExidx(pc, regs, process_memory, finished);
110 }
111 
StepExidx(uint64_t pc,Regs * regs,Memory * process_memory,bool * finished)112 bool ElfInterfaceArm::StepExidx(uint64_t pc, Regs* regs, Memory* process_memory, bool* finished) {
113   // Adjust the load bias to get the real relative pc.
114   if (pc < load_bias_) {
115     last_error_.code = ERROR_UNWIND_INFO;
116     return false;
117   }
118   pc -= load_bias_;
119 
120   RegsArm* regs_arm = reinterpret_cast<RegsArm*>(regs);
121   uint64_t entry_offset;
122   if (!FindEntry(pc, &entry_offset)) {
123     return false;
124   }
125 
126   ArmExidx arm(regs_arm, memory_, process_memory);
127   arm.set_cfa(regs_arm->sp());
128   bool return_value = false;
129   if (arm.ExtractEntryData(entry_offset) && arm.Eval()) {
130     // If the pc was not set, then use the LR registers for the PC.
131     if (!arm.pc_set()) {
132       (*regs_arm)[ARM_REG_PC] = (*regs_arm)[ARM_REG_LR];
133     }
134     (*regs_arm)[ARM_REG_SP] = arm.cfa();
135     return_value = true;
136 
137     // If the pc was set to zero, consider this the final frame.
138     *finished = (regs_arm->pc() == 0) ? true : false;
139   }
140 
141   if (arm.status() == ARM_STATUS_NO_UNWIND) {
142     *finished = true;
143     return true;
144   }
145 
146   if (!return_value) {
147     switch (arm.status()) {
148       case ARM_STATUS_NONE:
149       case ARM_STATUS_NO_UNWIND:
150       case ARM_STATUS_FINISH:
151         last_error_.code = ERROR_NONE;
152         break;
153 
154       case ARM_STATUS_RESERVED:
155       case ARM_STATUS_SPARE:
156       case ARM_STATUS_TRUNCATED:
157       case ARM_STATUS_MALFORMED:
158       case ARM_STATUS_INVALID_ALIGNMENT:
159       case ARM_STATUS_INVALID_PERSONALITY:
160         last_error_.code = ERROR_UNWIND_INFO;
161         break;
162 
163       case ARM_STATUS_READ_FAILED:
164         last_error_.code = ERROR_MEMORY_INVALID;
165         last_error_.address = arm.status_address();
166         break;
167     }
168   }
169   return return_value;
170 }
171 
GetFunctionName(uint64_t addr,std::string * name,uint64_t * offset)172 bool ElfInterfaceArm::GetFunctionName(uint64_t addr, std::string* name, uint64_t* offset) {
173   // For ARM, thumb function symbols have bit 0 set, but the address passed
174   // in here might not have this bit set and result in a failure to find
175   // the thumb function names. Adjust the address and offset to account
176   // for this possible case.
177   if (ElfInterface32::GetFunctionName(addr | 1, name, offset)) {
178     *offset &= ~1;
179     return true;
180   }
181   return false;
182 }
183 
184 }  // namespace unwindstack
185