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 19 #include <gtest/gtest.h> 20 21 #include <vector> 22 23 #include <unwindstack/Regs.h> 24 25 #include "ElfInterfaceArm.h" 26 #include "Machine.h" 27 28 #include "MemoryFake.h" 29 30 namespace unwindstack { 31 32 class ElfInterfaceArmTest : public ::testing::Test { 33 protected: 34 void SetUp() override { 35 memory_.Clear(); 36 process_memory_.Clear(); 37 } 38 39 MemoryFake memory_; 40 MemoryFake process_memory_; 41 }; 42 43 TEST_F(ElfInterfaceArmTest, GetPrel32Addr) { 44 ElfInterfaceArm interface(&memory_); 45 memory_.SetData32(0x1000, 0x230000); 46 47 uint32_t value; 48 ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value)); 49 ASSERT_EQ(0x231000U, value); 50 51 memory_.SetData32(0x1000, 0x80001000); 52 ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value)); 53 ASSERT_EQ(0x2000U, value); 54 55 memory_.SetData32(0x1000, 0x70001000); 56 ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value)); 57 ASSERT_EQ(0xf0002000U, value); 58 } 59 60 TEST_F(ElfInterfaceArmTest, FindEntry_start_zero) { 61 ElfInterfaceArm interface(&memory_); 62 interface.set_start_offset(0); 63 interface.set_total_entries(10); 64 65 uint64_t entry_offset; 66 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset)); 67 } 68 69 TEST_F(ElfInterfaceArmTest, FindEntry_no_entries) { 70 ElfInterfaceArm interface(&memory_); 71 interface.set_start_offset(0x100); 72 interface.set_total_entries(0); 73 74 uint64_t entry_offset; 75 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset)); 76 } 77 78 TEST_F(ElfInterfaceArmTest, FindEntry_no_valid_memory) { 79 ElfInterfaceArm interface(&memory_); 80 interface.set_start_offset(0x100); 81 interface.set_total_entries(2); 82 83 uint64_t entry_offset; 84 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset)); 85 } 86 87 TEST_F(ElfInterfaceArmTest, FindEntry_ip_before_first) { 88 ElfInterfaceArm interface(&memory_); 89 interface.set_start_offset(0x1000); 90 interface.set_total_entries(1); 91 memory_.SetData32(0x1000, 0x6000); 92 93 uint64_t entry_offset; 94 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset)); 95 } 96 97 TEST_F(ElfInterfaceArmTest, FindEntry_single_entry_negative_value) { 98 ElfInterfaceArm interface(&memory_); 99 interface.set_start_offset(0x8000); 100 interface.set_total_entries(1); 101 memory_.SetData32(0x8000, 0x7fffff00); 102 103 uint64_t entry_offset; 104 ASSERT_TRUE(interface.FindEntry(0x7ff0, &entry_offset)); 105 ASSERT_EQ(0x8000U, entry_offset); 106 } 107 108 TEST_F(ElfInterfaceArmTest, FindEntry_two_entries) { 109 ElfInterfaceArm interface(&memory_); 110 interface.set_start_offset(0x1000); 111 interface.set_total_entries(2); 112 memory_.SetData32(0x1000, 0x6000); 113 memory_.SetData32(0x1008, 0x7000); 114 115 uint64_t entry_offset; 116 ASSERT_TRUE(interface.FindEntry(0x7000, &entry_offset)); 117 ASSERT_EQ(0x1000U, entry_offset); 118 } 119 120 121 TEST_F(ElfInterfaceArmTest, FindEntry_last_check_single_entry) { 122 ElfInterfaceArm interface(&memory_); 123 interface.set_start_offset(0x1000); 124 interface.set_total_entries(1); 125 memory_.SetData32(0x1000, 0x6000); 126 127 uint64_t entry_offset; 128 ASSERT_TRUE(interface.FindEntry(0x7000, &entry_offset)); 129 ASSERT_EQ(0x1000U, entry_offset); 130 131 // To guarantee that we are using the cache on the second run, 132 // set the memory to a different value. 133 memory_.SetData32(0x1000, 0x8000); 134 ASSERT_TRUE(interface.FindEntry(0x7004, &entry_offset)); 135 ASSERT_EQ(0x1000U, entry_offset); 136 } 137 138 TEST_F(ElfInterfaceArmTest, FindEntry_last_check_multiple_entries) { 139 ElfInterfaceArm interface(&memory_); 140 interface.set_start_offset(0x1000); 141 interface.set_total_entries(2); 142 memory_.SetData32(0x1000, 0x6000); 143 memory_.SetData32(0x1008, 0x8000); 144 145 uint64_t entry_offset; 146 ASSERT_TRUE(interface.FindEntry(0x9008, &entry_offset)); 147 ASSERT_EQ(0x1008U, entry_offset); 148 149 // To guarantee that we are using the cache on the second run, 150 // set the memory to a different value. 151 memory_.SetData32(0x1000, 0x16000); 152 memory_.SetData32(0x1008, 0x18000); 153 ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset)); 154 ASSERT_EQ(0x1008U, entry_offset); 155 } 156 157 TEST_F(ElfInterfaceArmTest, FindEntry_multiple_entries_even) { 158 ElfInterfaceArm interface(&memory_); 159 interface.set_start_offset(0x1000); 160 interface.set_total_entries(4); 161 memory_.SetData32(0x1000, 0x6000); 162 memory_.SetData32(0x1008, 0x7000); 163 memory_.SetData32(0x1010, 0x8000); 164 memory_.SetData32(0x1018, 0x9000); 165 166 uint64_t entry_offset; 167 ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset)); 168 ASSERT_EQ(0x1010U, entry_offset); 169 170 // To guarantee that we are using the cache on the second run, 171 // set the memory to a different value. 172 memory_.SetData32(0x1000, 0x16000); 173 memory_.SetData32(0x1008, 0x17000); 174 memory_.SetData32(0x1010, 0x18000); 175 memory_.SetData32(0x1018, 0x19000); 176 ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset)); 177 ASSERT_EQ(0x1010U, entry_offset); 178 } 179 180 TEST_F(ElfInterfaceArmTest, FindEntry_multiple_entries_odd) { 181 ElfInterfaceArm interface(&memory_); 182 interface.set_start_offset(0x1000); 183 interface.set_total_entries(5); 184 memory_.SetData32(0x1000, 0x5000); 185 memory_.SetData32(0x1008, 0x6000); 186 memory_.SetData32(0x1010, 0x7000); 187 memory_.SetData32(0x1018, 0x8000); 188 memory_.SetData32(0x1020, 0x9000); 189 190 uint64_t entry_offset; 191 ASSERT_TRUE(interface.FindEntry(0x8100, &entry_offset)); 192 ASSERT_EQ(0x1010U, entry_offset); 193 194 // To guarantee that we are using the cache on the second run, 195 // set the memory to a different value. 196 memory_.SetData32(0x1000, 0x15000); 197 memory_.SetData32(0x1008, 0x16000); 198 memory_.SetData32(0x1010, 0x17000); 199 memory_.SetData32(0x1018, 0x18000); 200 memory_.SetData32(0x1020, 0x19000); 201 ASSERT_TRUE(interface.FindEntry(0x8100, &entry_offset)); 202 ASSERT_EQ(0x1010U, entry_offset); 203 } 204 205 TEST_F(ElfInterfaceArmTest, iterate) { 206 ElfInterfaceArm interface(&memory_); 207 interface.set_start_offset(0x1000); 208 interface.set_total_entries(5); 209 memory_.SetData32(0x1000, 0x5000); 210 memory_.SetData32(0x1008, 0x6000); 211 memory_.SetData32(0x1010, 0x7000); 212 memory_.SetData32(0x1018, 0x8000); 213 memory_.SetData32(0x1020, 0x9000); 214 215 std::vector<uint32_t> entries; 216 for (auto addr : interface) { 217 entries.push_back(addr); 218 } 219 ASSERT_EQ(5U, entries.size()); 220 ASSERT_EQ(0x6000U, entries[0]); 221 ASSERT_EQ(0x7008U, entries[1]); 222 ASSERT_EQ(0x8010U, entries[2]); 223 ASSERT_EQ(0x9018U, entries[3]); 224 ASSERT_EQ(0xa020U, entries[4]); 225 226 // Make sure the iterate cached the entries. 227 memory_.SetData32(0x1000, 0x11000); 228 memory_.SetData32(0x1008, 0x12000); 229 memory_.SetData32(0x1010, 0x13000); 230 memory_.SetData32(0x1018, 0x14000); 231 memory_.SetData32(0x1020, 0x15000); 232 233 entries.clear(); 234 for (auto addr : interface) { 235 entries.push_back(addr); 236 } 237 ASSERT_EQ(5U, entries.size()); 238 ASSERT_EQ(0x6000U, entries[0]); 239 ASSERT_EQ(0x7008U, entries[1]); 240 ASSERT_EQ(0x8010U, entries[2]); 241 ASSERT_EQ(0x9018U, entries[3]); 242 ASSERT_EQ(0xa020U, entries[4]); 243 } 244 245 TEST_F(ElfInterfaceArmTest, FindEntry_load_bias) { 246 ElfInterfaceArm interface(&memory_); 247 interface.set_start_offset(0x1000); 248 interface.set_total_entries(2); 249 memory_.SetData32(0x1000, 0x6000); 250 memory_.SetData32(0x1008, 0x8000); 251 252 uint64_t entry_offset; 253 interface.set_load_bias(0x2000); 254 ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset)); 255 ASSERT_FALSE(interface.FindEntry(0x8000, &entry_offset)); 256 ASSERT_FALSE(interface.FindEntry(0x8fff, &entry_offset)); 257 ASSERT_TRUE(interface.FindEntry(0x9000, &entry_offset)); 258 ASSERT_EQ(0x1000U, entry_offset); 259 ASSERT_TRUE(interface.FindEntry(0xb007, &entry_offset)); 260 ASSERT_EQ(0x1000U, entry_offset); 261 ASSERT_TRUE(interface.FindEntry(0xb008, &entry_offset)); 262 ASSERT_EQ(0x1008U, entry_offset); 263 } 264 265 TEST_F(ElfInterfaceArmTest, HandleType_not_arm_exidx) { 266 ElfInterfaceArm interface(&memory_); 267 268 ASSERT_FALSE(interface.HandleType(0x1000, PT_NULL)); 269 ASSERT_FALSE(interface.HandleType(0x1000, PT_LOAD)); 270 ASSERT_FALSE(interface.HandleType(0x1000, PT_DYNAMIC)); 271 ASSERT_FALSE(interface.HandleType(0x1000, PT_INTERP)); 272 ASSERT_FALSE(interface.HandleType(0x1000, PT_NOTE)); 273 ASSERT_FALSE(interface.HandleType(0x1000, PT_SHLIB)); 274 ASSERT_FALSE(interface.HandleType(0x1000, PT_PHDR)); 275 ASSERT_FALSE(interface.HandleType(0x1000, PT_TLS)); 276 ASSERT_FALSE(interface.HandleType(0x1000, PT_LOOS)); 277 ASSERT_FALSE(interface.HandleType(0x1000, PT_HIOS)); 278 ASSERT_FALSE(interface.HandleType(0x1000, PT_LOPROC)); 279 ASSERT_FALSE(interface.HandleType(0x1000, PT_HIPROC)); 280 ASSERT_FALSE(interface.HandleType(0x1000, PT_GNU_EH_FRAME)); 281 ASSERT_FALSE(interface.HandleType(0x1000, PT_GNU_STACK)); 282 } 283 284 TEST_F(ElfInterfaceArmTest, HandleType_arm_exidx) { 285 ElfInterfaceArm interface(&memory_); 286 287 Elf32_Phdr phdr; 288 interface.set_start_offset(0x1000); 289 interface.set_total_entries(100); 290 phdr.p_vaddr = 0x2000; 291 phdr.p_memsz = 0xa00; 292 293 // Verify that if reads fail, we don't set the values but still get true. 294 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001)); 295 ASSERT_EQ(0x1000U, interface.start_offset()); 296 ASSERT_EQ(100U, interface.total_entries()); 297 298 // Verify that if the second read fails, we still don't set the values. 299 memory_.SetData32( 300 0x1000 + reinterpret_cast<uint64_t>(&phdr.p_vaddr) - reinterpret_cast<uint64_t>(&phdr), 301 phdr.p_vaddr); 302 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001)); 303 ASSERT_EQ(0x1000U, interface.start_offset()); 304 ASSERT_EQ(100U, interface.total_entries()); 305 306 // Everything is correct and present. 307 memory_.SetData32( 308 0x1000 + reinterpret_cast<uint64_t>(&phdr.p_memsz) - reinterpret_cast<uint64_t>(&phdr), 309 phdr.p_memsz); 310 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001)); 311 ASSERT_EQ(0x2000U, interface.start_offset()); 312 ASSERT_EQ(320U, interface.total_entries()); 313 314 // Non-zero load bias. 315 interface.set_load_bias(0x1000); 316 ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001)); 317 ASSERT_EQ(0x1000U, interface.start_offset()); 318 ASSERT_EQ(320U, interface.total_entries()); 319 } 320 321 TEST_F(ElfInterfaceArmTest, StepExidx) { 322 ElfInterfaceArm interface(&memory_); 323 324 // FindEntry fails. 325 ASSERT_FALSE(interface.StepExidx(0x7000, nullptr, nullptr)); 326 327 // ExtractEntry should fail. 328 interface.set_start_offset(0x1000); 329 interface.set_total_entries(2); 330 memory_.SetData32(0x1000, 0x6000); 331 memory_.SetData32(0x1008, 0x8000); 332 333 RegsArm regs; 334 regs[ARM_REG_SP] = 0x1000; 335 regs[ARM_REG_LR] = 0x20000; 336 regs.set_sp(regs[ARM_REG_SP]); 337 regs.set_pc(0x1234); 338 ASSERT_FALSE(interface.StepExidx(0x7000, ®s, &process_memory_)); 339 340 // Eval should fail. 341 memory_.SetData32(0x1004, 0x81000000); 342 ASSERT_FALSE(interface.StepExidx(0x7000, ®s, &process_memory_)); 343 344 // Everything should pass. 345 memory_.SetData32(0x1004, 0x80b0b0b0); 346 ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_)); 347 ASSERT_EQ(0x1000U, regs.sp()); 348 ASSERT_EQ(0x1000U, regs[ARM_REG_SP]); 349 ASSERT_EQ(0x20000U, regs.pc()); 350 ASSERT_EQ(0x20000U, regs[ARM_REG_PC]); 351 } 352 353 TEST_F(ElfInterfaceArmTest, StepExidx_pc_set) { 354 ElfInterfaceArm interface(&memory_); 355 356 interface.set_start_offset(0x1000); 357 interface.set_total_entries(2); 358 memory_.SetData32(0x1000, 0x6000); 359 memory_.SetData32(0x1004, 0x808800b0); 360 memory_.SetData32(0x1008, 0x8000); 361 process_memory_.SetData32(0x10000, 0x10); 362 363 RegsArm regs; 364 regs[ARM_REG_SP] = 0x10000; 365 regs[ARM_REG_LR] = 0x20000; 366 regs.set_sp(regs[ARM_REG_SP]); 367 regs.set_pc(0x1234); 368 369 // Everything should pass. 370 ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_)); 371 ASSERT_EQ(0x10004U, regs.sp()); 372 ASSERT_EQ(0x10004U, regs[ARM_REG_SP]); 373 ASSERT_EQ(0x10U, regs.pc()); 374 ASSERT_EQ(0x10U, regs[ARM_REG_PC]); 375 } 376 377 } // namespace unwindstack 378
