blob: c432d6d4fc66ecf8bd435b082cdb0507ddfb4a22 [file] [log] [blame]
Christopher Ferris3958f802017-02-01 15:44:40 -08001/*
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>
Christopher Ferrisbae69f12017-06-28 14:51:54 -070018#include <fcntl.h>
19#include <sys/stat.h>
20#include <sys/types.h>
21#include <unistd.h>
Christopher Ferris3958f802017-02-01 15:44:40 -080022
Christopher Ferrise69f4702017-10-19 16:08:58 -070023#include <gmock/gmock.h>
Christopher Ferris3958f802017-02-01 15:44:40 -080024#include <gtest/gtest.h>
25
Christopher Ferrisd226a512017-07-14 10:37:19 -070026#include <unwindstack/Elf.h>
27#include <unwindstack/MapInfo.h>
Christopher Ferrisd06001d2017-11-30 18:56:01 -080028#include <unwindstack/RegsArm.h>
Christopher Ferris3958f802017-02-01 15:44:40 -080029
Christopher Ferrise69f4702017-10-19 16:08:58 -070030#include "ElfFake.h"
Christopher Ferris570b76f2017-06-30 17:18:16 -070031#include "ElfTestUtils.h"
Christopher Ferrisa0196652017-07-18 16:09:20 -070032#include "LogFake.h"
Christopher Ferris3958f802017-02-01 15:44:40 -080033#include "MemoryFake.h"
34
35#if !defined(PT_ARM_EXIDX)
36#define PT_ARM_EXIDX 0x70000001
37#endif
38
Christopher Ferrisd226a512017-07-14 10:37:19 -070039namespace unwindstack {
40
Christopher Ferris3958f802017-02-01 15:44:40 -080041class ElfTest : public ::testing::Test {
42 protected:
43 void SetUp() override {
44 memory_ = new MemoryFake;
45 }
46
Christopher Ferris570b76f2017-06-30 17:18:16 -070047 void InitElf32(uint32_t machine_type) {
Christopher Ferris3958f802017-02-01 15:44:40 -080048 Elf32_Ehdr ehdr;
Christopher Ferris570b76f2017-06-30 17:18:16 -070049 TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, machine_type);
Christopher Ferris3958f802017-02-01 15:44:40 -080050
Christopher Ferris3958f802017-02-01 15:44:40 -080051 ehdr.e_phoff = 0x100;
Christopher Ferris3958f802017-02-01 15:44:40 -080052 ehdr.e_ehsize = sizeof(ehdr);
53 ehdr.e_phentsize = sizeof(Elf32_Phdr);
54 ehdr.e_phnum = 1;
55 ehdr.e_shentsize = sizeof(Elf32_Shdr);
Christopher Ferris570b76f2017-06-30 17:18:16 -070056 if (machine_type == EM_ARM) {
Christopher Ferris3958f802017-02-01 15:44:40 -080057 ehdr.e_flags = 0x5000200;
58 ehdr.e_phnum = 2;
59 }
60 memory_->SetMemory(0, &ehdr, sizeof(ehdr));
61
62 Elf32_Phdr phdr;
63 memset(&phdr, 0, sizeof(phdr));
64 phdr.p_type = PT_LOAD;
Christopher Ferris3958f802017-02-01 15:44:40 -080065 phdr.p_filesz = 0x10000;
66 phdr.p_memsz = 0x10000;
67 phdr.p_flags = PF_R | PF_X;
68 phdr.p_align = 0x1000;
69 memory_->SetMemory(0x100, &phdr, sizeof(phdr));
70
Christopher Ferris570b76f2017-06-30 17:18:16 -070071 if (machine_type == EM_ARM) {
Christopher Ferris3958f802017-02-01 15:44:40 -080072 memset(&phdr, 0, sizeof(phdr));
73 phdr.p_type = PT_ARM_EXIDX;
74 phdr.p_offset = 0x30000;
75 phdr.p_vaddr = 0x30000;
76 phdr.p_paddr = 0x30000;
77 phdr.p_filesz = 16;
78 phdr.p_memsz = 16;
79 phdr.p_flags = PF_R;
80 phdr.p_align = 0x4;
81 memory_->SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
82 }
83 }
84
Christopher Ferris570b76f2017-06-30 17:18:16 -070085 void InitElf64(uint32_t machine_type) {
Christopher Ferris3958f802017-02-01 15:44:40 -080086 Elf64_Ehdr ehdr;
Christopher Ferris570b76f2017-06-30 17:18:16 -070087 TestInitEhdr<Elf64_Ehdr>(&ehdr, ELFCLASS64, machine_type);
Christopher Ferris3958f802017-02-01 15:44:40 -080088
Christopher Ferris3958f802017-02-01 15:44:40 -080089 ehdr.e_phoff = 0x100;
Christopher Ferris3958f802017-02-01 15:44:40 -080090 ehdr.e_flags = 0x5000200;
91 ehdr.e_ehsize = sizeof(ehdr);
92 ehdr.e_phentsize = sizeof(Elf64_Phdr);
93 ehdr.e_phnum = 1;
94 ehdr.e_shentsize = sizeof(Elf64_Shdr);
Christopher Ferris3958f802017-02-01 15:44:40 -080095 memory_->SetMemory(0, &ehdr, sizeof(ehdr));
96
97 Elf64_Phdr phdr;
98 memset(&phdr, 0, sizeof(phdr));
99 phdr.p_type = PT_LOAD;
Christopher Ferris3958f802017-02-01 15:44:40 -0800100 phdr.p_filesz = 0x10000;
101 phdr.p_memsz = 0x10000;
102 phdr.p_flags = PF_R | PF_X;
103 phdr.p_align = 0x1000;
104 memory_->SetMemory(0x100, &phdr, sizeof(phdr));
105 }
106
107 MemoryFake* memory_;
108};
109
110TEST_F(ElfTest, invalid_memory) {
111 Elf elf(memory_);
112
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700113 ASSERT_FALSE(elf.Init());
Christopher Ferris3958f802017-02-01 15:44:40 -0800114 ASSERT_FALSE(elf.valid());
115}
116
117TEST_F(ElfTest, elf_invalid) {
118 Elf elf(memory_);
119
120 InitElf32(EM_386);
121
122 // Corrupt the ELF signature.
123 memory_->SetData32(0, 0x7f000000);
124
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700125 ASSERT_FALSE(elf.Init());
Christopher Ferris3958f802017-02-01 15:44:40 -0800126 ASSERT_FALSE(elf.valid());
127 ASSERT_TRUE(elf.interface() == nullptr);
128
Christopher Ferris02a6c442019-03-11 14:43:33 -0700129 ASSERT_EQ("", elf.GetSoname());
Christopher Ferris3958f802017-02-01 15:44:40 -0800130
Christopher Ferris02a6c442019-03-11 14:43:33 -0700131 std::string name;
Christopher Ferris3958f802017-02-01 15:44:40 -0800132 uint64_t func_offset;
133 ASSERT_FALSE(elf.GetFunctionName(0, &name, &func_offset));
134
Christopher Ferrisd11ed862019-04-11 19:45:35 -0700135 ASSERT_FALSE(elf.StepIfSignalHandler(0, nullptr, nullptr));
136 EXPECT_EQ(ERROR_INVALID_ELF, elf.GetLastErrorCode());
137
Christopher Ferrisb9de87f2017-09-20 13:37:24 -0700138 bool finished;
Christopher Ferrisd11ed862019-04-11 19:45:35 -0700139 ASSERT_FALSE(elf.Step(0, nullptr, nullptr, &finished));
140 EXPECT_EQ(ERROR_INVALID_ELF, elf.GetLastErrorCode());
Christopher Ferris3958f802017-02-01 15:44:40 -0800141}
142
Christopher Ferrisa0196652017-07-18 16:09:20 -0700143TEST_F(ElfTest, elf32_invalid_machine) {
144 Elf elf(memory_);
145
146 InitElf32(EM_PPC);
147
148 ResetLogs();
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700149 ASSERT_FALSE(elf.Init());
Christopher Ferrisa0196652017-07-18 16:09:20 -0700150
151 ASSERT_EQ("", GetFakeLogBuf());
Douglas Leung61b1a1a2017-11-08 10:53:53 +0100152 ASSERT_EQ("4 unwind 32 bit elf that is neither arm nor x86 nor mips: e_machine = 20\n\n",
Christopher Ferrisa0196652017-07-18 16:09:20 -0700153 GetFakeLogPrint());
154}
155
156TEST_F(ElfTest, elf64_invalid_machine) {
157 Elf elf(memory_);
158
159 InitElf64(EM_PPC64);
160
161 ResetLogs();
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700162 ASSERT_FALSE(elf.Init());
Christopher Ferrisa0196652017-07-18 16:09:20 -0700163
164 ASSERT_EQ("", GetFakeLogBuf());
Douglas Leung61b1a1a2017-11-08 10:53:53 +0100165 ASSERT_EQ("4 unwind 64 bit elf that is neither aarch64 nor x86_64 nor mips64: e_machine = 21\n\n",
Christopher Ferrisa0196652017-07-18 16:09:20 -0700166 GetFakeLogPrint());
167}
168
Christopher Ferris3958f802017-02-01 15:44:40 -0800169TEST_F(ElfTest, elf_arm) {
170 Elf elf(memory_);
171
172 InitElf32(EM_ARM);
173
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700174 ASSERT_TRUE(elf.Init());
Christopher Ferris3958f802017-02-01 15:44:40 -0800175 ASSERT_TRUE(elf.valid());
176 ASSERT_EQ(static_cast<uint32_t>(EM_ARM), elf.machine_type());
177 ASSERT_EQ(ELFCLASS32, elf.class_type());
178 ASSERT_TRUE(elf.interface() != nullptr);
179}
180
Douglas Leung61b1a1a2017-11-08 10:53:53 +0100181TEST_F(ElfTest, elf_mips) {
182 Elf elf(memory_);
183
184 InitElf32(EM_MIPS);
185
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700186 ASSERT_TRUE(elf.Init());
Douglas Leung61b1a1a2017-11-08 10:53:53 +0100187 ASSERT_TRUE(elf.valid());
188 ASSERT_EQ(static_cast<uint32_t>(EM_MIPS), elf.machine_type());
189 ASSERT_EQ(ELFCLASS32, elf.class_type());
190 ASSERT_TRUE(elf.interface() != nullptr);
191}
192
Christopher Ferris3958f802017-02-01 15:44:40 -0800193TEST_F(ElfTest, elf_x86) {
194 Elf elf(memory_);
195
196 InitElf32(EM_386);
197
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700198 ASSERT_TRUE(elf.Init());
Christopher Ferris3958f802017-02-01 15:44:40 -0800199 ASSERT_TRUE(elf.valid());
200 ASSERT_EQ(static_cast<uint32_t>(EM_386), elf.machine_type());
201 ASSERT_EQ(ELFCLASS32, elf.class_type());
202 ASSERT_TRUE(elf.interface() != nullptr);
203}
204
205TEST_F(ElfTest, elf_arm64) {
206 Elf elf(memory_);
207
208 InitElf64(EM_AARCH64);
209
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700210 ASSERT_TRUE(elf.Init());
Christopher Ferris3958f802017-02-01 15:44:40 -0800211 ASSERT_TRUE(elf.valid());
212 ASSERT_EQ(static_cast<uint32_t>(EM_AARCH64), elf.machine_type());
213 ASSERT_EQ(ELFCLASS64, elf.class_type());
214 ASSERT_TRUE(elf.interface() != nullptr);
215}
216
217TEST_F(ElfTest, elf_x86_64) {
218 Elf elf(memory_);
219
220 InitElf64(EM_X86_64);
221
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700222 ASSERT_TRUE(elf.Init());
Christopher Ferris3958f802017-02-01 15:44:40 -0800223 ASSERT_TRUE(elf.valid());
224 ASSERT_EQ(static_cast<uint32_t>(EM_X86_64), elf.machine_type());
225 ASSERT_EQ(ELFCLASS64, elf.class_type());
226 ASSERT_TRUE(elf.interface() != nullptr);
227}
Christopher Ferrisbae69f12017-06-28 14:51:54 -0700228
Douglas Leung61b1a1a2017-11-08 10:53:53 +0100229TEST_F(ElfTest, elf_mips64) {
230 Elf elf(memory_);
231
232 InitElf64(EM_MIPS);
233
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700234 ASSERT_TRUE(elf.Init());
Douglas Leung61b1a1a2017-11-08 10:53:53 +0100235 ASSERT_TRUE(elf.valid());
236 ASSERT_EQ(static_cast<uint32_t>(EM_MIPS), elf.machine_type());
237 ASSERT_EQ(ELFCLASS64, elf.class_type());
238 ASSERT_TRUE(elf.interface() != nullptr);
239}
240
Christopher Ferris570b76f2017-06-30 17:18:16 -0700241TEST_F(ElfTest, gnu_debugdata_init32) {
242 TestInitGnuDebugdata<Elf32_Ehdr, Elf32_Shdr>(ELFCLASS32, EM_ARM, true,
243 [&](uint64_t offset, const void* ptr, size_t size) {
244 memory_->SetMemory(offset, ptr, size);
245 });
246
247 Elf elf(memory_);
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700248 ASSERT_TRUE(elf.Init());
Christopher Ferris570b76f2017-06-30 17:18:16 -0700249 ASSERT_TRUE(elf.interface() != nullptr);
Christopher Ferrise69f4702017-10-19 16:08:58 -0700250 ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
Christopher Ferris570b76f2017-06-30 17:18:16 -0700251 EXPECT_EQ(0x1acU, elf.interface()->gnu_debugdata_offset());
252 EXPECT_EQ(0x8cU, elf.interface()->gnu_debugdata_size());
Christopher Ferrisbae69f12017-06-28 14:51:54 -0700253}
254
Christopher Ferrisbae69f12017-06-28 14:51:54 -0700255TEST_F(ElfTest, gnu_debugdata_init64) {
Christopher Ferris570b76f2017-06-30 17:18:16 -0700256 TestInitGnuDebugdata<Elf64_Ehdr, Elf64_Shdr>(ELFCLASS64, EM_AARCH64, true,
257 [&](uint64_t offset, const void* ptr, size_t size) {
258 memory_->SetMemory(offset, ptr, size);
259 });
Christopher Ferrisbae69f12017-06-28 14:51:54 -0700260
Christopher Ferris570b76f2017-06-30 17:18:16 -0700261 Elf elf(memory_);
Christopher Ferrise8c4ecf2018-10-23 12:04:26 -0700262 ASSERT_TRUE(elf.Init());
Christopher Ferris570b76f2017-06-30 17:18:16 -0700263 ASSERT_TRUE(elf.interface() != nullptr);
Christopher Ferrise69f4702017-10-19 16:08:58 -0700264 ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
Christopher Ferris570b76f2017-06-30 17:18:16 -0700265 EXPECT_EQ(0x200U, elf.interface()->gnu_debugdata_offset());
266 EXPECT_EQ(0x90U, elf.interface()->gnu_debugdata_size());
Christopher Ferrisbae69f12017-06-28 14:51:54 -0700267}
Christopher Ferrisd226a512017-07-14 10:37:19 -0700268
Christopher Ferrisd226a512017-07-14 10:37:19 -0700269TEST_F(ElfTest, rel_pc) {
Christopher Ferrise69f4702017-10-19 16:08:58 -0700270 ElfFake elf(memory_);
Christopher Ferrisd226a512017-07-14 10:37:19 -0700271
Christopher Ferrise69f4702017-10-19 16:08:58 -0700272 ElfInterfaceFake* interface = new ElfInterfaceFake(memory_);
273 elf.FakeSetInterface(interface);
Christopher Ferrisd226a512017-07-14 10:37:19 -0700274
Christopher Ferrise69f4702017-10-19 16:08:58 -0700275 elf.FakeSetValid(true);
Christopher Ferrisa09c4a62018-12-13 16:08:50 -0800276 MapInfo map_info(nullptr, 0x1000, 0x2000, 0, 0, "");
Christopher Ferrisd226a512017-07-14 10:37:19 -0700277
278 ASSERT_EQ(0x101U, elf.GetRelPc(0x1101, &map_info));
279
Christopher Ferrise69f4702017-10-19 16:08:58 -0700280 elf.FakeSetValid(false);
Christopher Ferrisd226a512017-07-14 10:37:19 -0700281 ASSERT_EQ(0x101U, elf.GetRelPc(0x1101, &map_info));
282}
283
Christopher Ferrise69f4702017-10-19 16:08:58 -0700284TEST_F(ElfTest, step_in_signal_map) {
285 ElfFake elf(memory_);
286
287 RegsArm regs;
288 regs[13] = 0x50000;
289 regs[15] = 0x8000;
Christopher Ferrise69f4702017-10-19 16:08:58 -0700290
291 ElfInterfaceFake* interface = new ElfInterfaceFake(memory_);
292 elf.FakeSetInterface(interface);
293
294 memory_->SetData32(0x3000, 0xdf0027ad);
295 MemoryFake process_memory;
296 process_memory.SetData32(0x50000, 0);
297 for (size_t i = 0; i < 16; i++) {
298 process_memory.SetData32(0x500a0 + i * sizeof(uint32_t), i);
299 }
300
301 elf.FakeSetValid(true);
Christopher Ferrisd11ed862019-04-11 19:45:35 -0700302 ASSERT_TRUE(elf.StepIfSignalHandler(0x3000, &regs, &process_memory));
303 EXPECT_EQ(ERROR_NONE, elf.GetLastErrorCode());
Christopher Ferrise69f4702017-10-19 16:08:58 -0700304 EXPECT_EQ(15U, regs.pc());
305 EXPECT_EQ(13U, regs.sp());
306}
307
308class ElfInterfaceMock : public ElfInterface {
309 public:
310 ElfInterfaceMock(Memory* memory) : ElfInterface(memory) {}
311 virtual ~ElfInterfaceMock() = default;
312
313 bool Init(uint64_t*) override { return false; }
Christopher Ferris4cc36d22018-06-06 14:47:31 -0700314 void InitHeaders(uint64_t) override {}
Christopher Ferris02a6c442019-03-11 14:43:33 -0700315 std::string GetSoname() override { return ""; }
Christopher Ferris4cc36d22018-06-06 14:47:31 -0700316 bool GetFunctionName(uint64_t, std::string*, uint64_t*) override { return false; }
Christopher Ferrisbf373ed2019-01-16 17:23:39 -0800317 std::string GetBuildID() override { return ""; }
Christopher Ferris150db122017-12-20 18:49:01 -0800318
Christopher Ferris4cc36d22018-06-06 14:47:31 -0700319 MOCK_METHOD4(Step, bool(uint64_t, Regs*, Memory*, bool*));
Christopher Ferris150db122017-12-20 18:49:01 -0800320 MOCK_METHOD2(GetGlobalVariable, bool(const std::string&, uint64_t*));
321 MOCK_METHOD1(IsValidPc, bool(uint64_t));
322
323 void MockSetDynamicOffset(uint64_t offset) { dynamic_offset_ = offset; }
324 void MockSetDynamicVaddr(uint64_t vaddr) { dynamic_vaddr_ = vaddr; }
325 void MockSetDynamicSize(uint64_t size) { dynamic_size_ = size; }
Christopher Ferrise69f4702017-10-19 16:08:58 -0700326};
327
328TEST_F(ElfTest, step_in_interface) {
329 ElfFake elf(memory_);
330 elf.FakeSetValid(true);
Christopher Ferrise69f4702017-10-19 16:08:58 -0700331
332 RegsArm regs;
333
334 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
335 elf.FakeSetInterface(interface);
336 MemoryFake process_memory;
337
338 bool finished;
Christopher Ferris4cc36d22018-06-06 14:47:31 -0700339 EXPECT_CALL(*interface, Step(0x1000, &regs, &process_memory, &finished))
Christopher Ferrise69f4702017-10-19 16:08:58 -0700340 .WillOnce(::testing::Return(true));
341
Christopher Ferrisd11ed862019-04-11 19:45:35 -0700342 ASSERT_TRUE(elf.Step(0x1000, &regs, &process_memory, &finished));
Christopher Ferrise69f4702017-10-19 16:08:58 -0700343}
344
Christopher Ferris150db122017-12-20 18:49:01 -0800345TEST_F(ElfTest, get_global_invalid_elf) {
346 ElfFake elf(memory_);
347 elf.FakeSetValid(false);
348
349 std::string global("something");
350 uint64_t offset;
351 ASSERT_FALSE(elf.GetGlobalVariable(global, &offset));
352}
353
354TEST_F(ElfTest, get_global_valid_not_in_interface) {
355 ElfFake elf(memory_);
356 elf.FakeSetValid(true);
Christopher Ferris150db122017-12-20 18:49:01 -0800357
358 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
359 elf.FakeSetInterface(interface);
360
361 uint64_t offset;
362 std::string global("something");
363 EXPECT_CALL(*interface, GetGlobalVariable(global, &offset)).WillOnce(::testing::Return(false));
364
365 ASSERT_FALSE(elf.GetGlobalVariable(global, &offset));
366}
367
368TEST_F(ElfTest, get_global_valid_below_load_bias) {
369 ElfFake elf(memory_);
370 elf.FakeSetValid(true);
371 elf.FakeSetLoadBias(0x1000);
372
373 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
374 elf.FakeSetInterface(interface);
375
376 uint64_t offset;
377 std::string global("something");
378 EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
379 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x300), ::testing::Return(true)));
380
381 ASSERT_FALSE(elf.GetGlobalVariable(global, &offset));
382}
383
Christopher Ferris4cc36d22018-06-06 14:47:31 -0700384TEST_F(ElfTest, get_global_valid_dynamic_zero_non_zero_load_bias) {
385 ElfFake elf(memory_);
386 elf.FakeSetValid(true);
387 elf.FakeSetLoadBias(0x100);
388
389 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
390 elf.FakeSetInterface(interface);
391
392 uint64_t offset;
393 std::string global("something");
394 EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
395 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x300), ::testing::Return(true)));
396
397 ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
398 EXPECT_EQ(0x200U, offset);
399}
400
Christopher Ferris150db122017-12-20 18:49:01 -0800401TEST_F(ElfTest, get_global_valid_dynamic_zero) {
402 ElfFake elf(memory_);
403 elf.FakeSetValid(true);
Christopher Ferris150db122017-12-20 18:49:01 -0800404
405 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
406 elf.FakeSetInterface(interface);
407
408 ElfInterfaceMock* gnu_interface = new ElfInterfaceMock(memory_);
409 elf.FakeSetGnuDebugdataInterface(gnu_interface);
410
411 uint64_t offset;
412 std::string global("something");
413 EXPECT_CALL(*interface, GetGlobalVariable(global, &offset)).WillOnce(::testing::Return(false));
414
415 EXPECT_CALL(*gnu_interface, GetGlobalVariable(global, &offset))
416 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x500), ::testing::Return(true)));
417
418 ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
419 EXPECT_EQ(0x500U, offset);
420}
421
422TEST_F(ElfTest, get_global_valid_in_gnu_debugdata_dynamic_zero) {
423 ElfFake elf(memory_);
424 elf.FakeSetValid(true);
Christopher Ferris150db122017-12-20 18:49:01 -0800425
426 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
427 elf.FakeSetInterface(interface);
428
429 uint64_t offset;
430 std::string global("something");
431 EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
432 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x300), ::testing::Return(true)));
433
434 ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
435 EXPECT_EQ(0x300U, offset);
436}
437
Christopher Ferris150db122017-12-20 18:49:01 -0800438TEST_F(ElfTest, get_global_valid_dynamic_adjust_negative) {
439 ElfFake elf(memory_);
440 elf.FakeSetValid(true);
Christopher Ferris150db122017-12-20 18:49:01 -0800441
442 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
443 interface->MockSetDynamicOffset(0x400);
444 interface->MockSetDynamicVaddr(0x800);
445 interface->MockSetDynamicSize(0x100);
446 elf.FakeSetInterface(interface);
447
448 uint64_t offset;
449 std::string global("something");
450 EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
451 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x850), ::testing::Return(true)));
452
453 ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
454 EXPECT_EQ(0x450U, offset);
455}
456
457TEST_F(ElfTest, get_global_valid_dynamic_adjust_positive) {
458 ElfFake elf(memory_);
459 elf.FakeSetValid(true);
Christopher Ferris150db122017-12-20 18:49:01 -0800460
461 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
462 interface->MockSetDynamicOffset(0x1000);
463 interface->MockSetDynamicVaddr(0x800);
464 interface->MockSetDynamicSize(0x100);
465 elf.FakeSetInterface(interface);
466
467 uint64_t offset;
468 std::string global("something");
469 EXPECT_CALL(*interface, GetGlobalVariable(global, &offset))
470 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x850), ::testing::Return(true)));
471
472 ASSERT_TRUE(elf.GetGlobalVariable(global, &offset));
473 EXPECT_EQ(0x1050U, offset);
474}
475
476TEST_F(ElfTest, is_valid_pc_elf_invalid) {
477 ElfFake elf(memory_);
478 elf.FakeSetValid(false);
Christopher Ferris150db122017-12-20 18:49:01 -0800479
480 EXPECT_FALSE(elf.IsValidPc(0x100));
481 EXPECT_FALSE(elf.IsValidPc(0x200));
482}
483
484TEST_F(ElfTest, is_valid_pc_interface) {
485 ElfFake elf(memory_);
486 elf.FakeSetValid(true);
Christopher Ferris150db122017-12-20 18:49:01 -0800487
488 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
489 elf.FakeSetInterface(interface);
490
491 EXPECT_CALL(*interface, IsValidPc(0x1500)).WillOnce(::testing::Return(true));
492
493 EXPECT_TRUE(elf.IsValidPc(0x1500));
494}
495
Christopher Ferris150db122017-12-20 18:49:01 -0800496TEST_F(ElfTest, is_valid_pc_from_gnu_debugdata) {
497 ElfFake elf(memory_);
498 elf.FakeSetValid(true);
Christopher Ferris150db122017-12-20 18:49:01 -0800499
500 ElfInterfaceMock* interface = new ElfInterfaceMock(memory_);
501 elf.FakeSetInterface(interface);
502 ElfInterfaceMock* gnu_interface = new ElfInterfaceMock(memory_);
503 elf.FakeSetGnuDebugdataInterface(gnu_interface);
504
505 EXPECT_CALL(*interface, IsValidPc(0x1500)).WillOnce(::testing::Return(false));
506 EXPECT_CALL(*gnu_interface, IsValidPc(0x1500)).WillOnce(::testing::Return(true));
507
508 EXPECT_TRUE(elf.IsValidPc(0x1500));
509}
510
Christopher Ferris2fcf4cf2018-01-23 17:52:23 -0800511TEST_F(ElfTest, error_code_not_valid) {
512 ElfFake elf(memory_);
513 elf.FakeSetValid(false);
514
515 ErrorData error{ERROR_MEMORY_INVALID, 0x100};
516 elf.GetLastError(&error);
517 EXPECT_EQ(ERROR_MEMORY_INVALID, error.code);
518 EXPECT_EQ(0x100U, error.address);
519}
520
521TEST_F(ElfTest, error_code_valid) {
522 ElfFake elf(memory_);
523 elf.FakeSetValid(true);
524 ElfInterfaceFake* interface = new ElfInterfaceFake(memory_);
525 elf.FakeSetInterface(interface);
526 interface->FakeSetErrorCode(ERROR_MEMORY_INVALID);
527 interface->FakeSetErrorAddress(0x1000);
528
529 ErrorData error{ERROR_NONE, 0};
530 elf.GetLastError(&error);
531 EXPECT_EQ(ERROR_MEMORY_INVALID, error.code);
532 EXPECT_EQ(0x1000U, error.address);
533 EXPECT_EQ(ERROR_MEMORY_INVALID, elf.GetLastErrorCode());
534 EXPECT_EQ(0x1000U, elf.GetLastErrorAddress());
535}
536
Christopher Ferrisd226a512017-07-14 10:37:19 -0700537} // namespace unwindstack