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 <fcntl.h>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include <unistd.h>
22
23 #include <memory>
24 #include <string>
25
26 #include <gmock/gmock.h>
27 #include <gtest/gtest.h>
28
29 #include <unwindstack/Elf.h>
30 #include <unwindstack/MapInfo.h>
31 #include <unwindstack/RegsArm.h>
32 #include <unwindstack/SharedString.h>
33
34 #include "ElfFake.h"
35 #include "ElfTestUtils.h"
36 #include "LogFake.h"
37 #include "utils/MemoryFake.h"
38
39 namespace unwindstack {
40
41 class ElfTest : public ::testing::Test {
42 protected:
SetUp()43 void SetUp() override {
44 fake_memory_ = new MemoryFake;
45 elf_memory_.reset(fake_memory_);
46 }
47
InitElf32(uint32_t machine_type)48 void InitElf32(uint32_t machine_type) {
49 Elf32_Ehdr ehdr;
50 TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, machine_type);
51
52 ehdr.e_phoff = 0x100;
53 ehdr.e_ehsize = sizeof(ehdr);
54 ehdr.e_phentsize = sizeof(Elf32_Phdr);
55 ehdr.e_phnum = 1;
56 ehdr.e_shentsize = sizeof(Elf32_Shdr);
57 if (machine_type == EM_ARM) {
58 ehdr.e_flags = 0x5000200;
59 ehdr.e_phnum = 2;
60 }
61 fake_memory_->SetMemory(0, &ehdr, sizeof(ehdr));
62
63 Elf32_Phdr phdr;
64 memset(&phdr, 0, sizeof(phdr));
65 phdr.p_type = PT_LOAD;
66 phdr.p_filesz = 0x10000;
67 phdr.p_memsz = 0x10000;
68 phdr.p_flags = PF_R | PF_X;
69 phdr.p_align = 0x1000;
70 fake_memory_->SetMemory(0x100, &phdr, sizeof(phdr));
71
72 if (machine_type == EM_ARM) {
73 memset(&phdr, 0, sizeof(phdr));
74 phdr.p_type = PT_ARM_EXIDX;
75 phdr.p_offset = 0x30000;
76 phdr.p_vaddr = 0x30000;
77 phdr.p_paddr = 0x30000;
78 phdr.p_filesz = 16;
79 phdr.p_memsz = 16;
80 phdr.p_flags = PF_R;
81 phdr.p_align = 0x4;
82 fake_memory_->SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
83 }
84 }
85
InitElf64(uint32_t machine_type)86 void InitElf64(uint32_t machine_type) {
87 Elf64_Ehdr ehdr;
88 TestInitEhdr<Elf64_Ehdr>(&ehdr, ELFCLASS64, machine_type);
89
90 ehdr.e_phoff = 0x100;
91 ehdr.e_flags = 0x5000200;
92 ehdr.e_ehsize = sizeof(ehdr);
93 ehdr.e_phentsize = sizeof(Elf64_Phdr);
94 ehdr.e_phnum = 1;
95 ehdr.e_shentsize = sizeof(Elf64_Shdr);
96 fake_memory_->SetMemory(0, &ehdr, sizeof(ehdr));
97
98 Elf64_Phdr phdr;
99 memset(&phdr, 0, sizeof(phdr));
100 phdr.p_type = PT_LOAD;
101 phdr.p_filesz = 0x10000;
102 phdr.p_memsz = 0x10000;
103 phdr.p_flags = PF_R | PF_X;
104 phdr.p_align = 0x1000;
105 fake_memory_->SetMemory(0x100, &phdr, sizeof(phdr));
106 }
107
108 void VerifyStepIfSignalHandler(uint64_t load_bias);
109
110 MemoryFake* fake_memory_;
111 std::shared_ptr<Memory> elf_memory_;
112 };
113
TEST_F(ElfTest,invalid_memory)114 TEST_F(ElfTest, invalid_memory) {
115 Elf elf(elf_memory_);
116
117 ASSERT_FALSE(elf.Init());
118 ASSERT_FALSE(elf.valid());
119 }
120
TEST_F(ElfTest,elf_invalid)121 TEST_F(ElfTest, elf_invalid) {
122 Elf elf(elf_memory_);
123
124 InitElf32(EM_386);
125
126 // Corrupt the ELF signature.
127 fake_memory_->SetData32(0, 0x7f000000);
128
129 ASSERT_FALSE(elf.Init());
130 ASSERT_FALSE(elf.valid());
131 ASSERT_TRUE(elf.interface() == nullptr);
132
133 ASSERT_EQ("", elf.GetSoname());
134
135 SharedString name;
136 uint64_t func_offset;
137 ASSERT_FALSE(elf.GetFunctionName(0, &name, &func_offset));
138
139 ASSERT_FALSE(elf.StepIfSignalHandler(0, nullptr, nullptr));
140 EXPECT_EQ(ERROR_INVALID_ELF, elf.GetLastErrorCode());
141
142 bool finished;
143 bool is_signal_frame;
144 ASSERT_FALSE(elf.Step(0, nullptr, nullptr, &finished, &is_signal_frame));
145 EXPECT_EQ(ERROR_INVALID_ELF, elf.GetLastErrorCode());
146 }
147
TEST_F(ElfTest,elf_invalid_check_error_values)148 TEST_F(ElfTest, elf_invalid_check_error_values) {
149 ElfFake elf(elf_memory_);
150 elf.FakeSetValid(false);
151
152 EXPECT_EQ(ERROR_INVALID_ELF, elf.GetLastErrorCode());
153 EXPECT_EQ(0U, elf.GetLastErrorAddress());
154
155 ErrorData error = {};
156 elf.GetLastError(&error);
157 EXPECT_EQ(ERROR_INVALID_ELF, error.code);
158 EXPECT_EQ(0U, error.address);
159
160 error.code = ERROR_MEMORY_INVALID;
161 error.address = 0x100;
162 elf.GetLastError(&error);
163 EXPECT_EQ(ERROR_INVALID_ELF, error.code);
164 EXPECT_EQ(0U, error.address);
165 }
166
TEST_F(ElfTest,elf32_invalid_machine)167 TEST_F(ElfTest, elf32_invalid_machine) {
168 Elf elf(elf_memory_);
169
170 InitElf32(EM_PPC);
171
172 ResetLogs();
173 ASSERT_FALSE(elf.Init());
174
175 ASSERT_EQ("", GetFakeLogBuf());
176 ASSERT_EQ("", GetFakeLogPrint());
177 }
178
TEST_F(ElfTest,elf64_invalid_machine)179 TEST_F(ElfTest, elf64_invalid_machine) {
180 Elf elf(elf_memory_);
181
182 InitElf64(EM_PPC64);
183
184 ResetLogs();
185 ASSERT_FALSE(elf.Init());
186
187 ASSERT_EQ("", GetFakeLogBuf());
188 ASSERT_EQ("", GetFakeLogPrint());
189 }
190
TEST_F(ElfTest,elf_arm)191 TEST_F(ElfTest, elf_arm) {
192 Elf elf(elf_memory_);
193
194 InitElf32(EM_ARM);
195
196 ASSERT_TRUE(elf.Init());
197 ASSERT_TRUE(elf.valid());
198 ASSERT_EQ(static_cast<uint32_t>(EM_ARM), elf.machine_type());
199 ASSERT_EQ(ELFCLASS32, elf.class_type());
200 ASSERT_TRUE(elf.interface() != nullptr);
201 }
202
TEST_F(ElfTest,elf_x86)203 TEST_F(ElfTest, elf_x86) {
204 Elf elf(elf_memory_);
205
206 InitElf32(EM_386);
207
208 ASSERT_TRUE(elf.Init());
209 ASSERT_TRUE(elf.valid());
210 ASSERT_EQ(static_cast<uint32_t>(EM_386), elf.machine_type());
211 ASSERT_EQ(ELFCLASS32, elf.class_type());
212 ASSERT_TRUE(elf.interface() != nullptr);
213 }
214
TEST_F(ElfTest,elf_arm64)215 TEST_F(ElfTest, elf_arm64) {
216 Elf elf(elf_memory_);
217
218 InitElf64(EM_AARCH64);
219
220 ASSERT_TRUE(elf.Init());
221 ASSERT_TRUE(elf.valid());
222 ASSERT_EQ(static_cast<uint32_t>(EM_AARCH64), elf.machine_type());
223 ASSERT_EQ(ELFCLASS64, elf.class_type());
224 ASSERT_TRUE(elf.interface() != nullptr);
225 }
226
TEST_F(ElfTest,elf_riscv64)227 TEST_F(ElfTest, elf_riscv64) {
228 Elf elf(elf_memory_);
229
230 InitElf64(EM_RISCV);
231
232 ASSERT_TRUE(elf.Init());
233 ASSERT_TRUE(elf.valid());
234 ASSERT_EQ(static_cast<uint32_t>(EM_RISCV), elf.machine_type());
235 ASSERT_EQ(ELFCLASS64, elf.class_type());
236 ASSERT_TRUE(elf.interface() != nullptr);
237 }
238
TEST_F(ElfTest,elf_x86_64)239 TEST_F(ElfTest, elf_x86_64) {
240 Elf elf(elf_memory_);
241
242 InitElf64(EM_X86_64);
243
244 ASSERT_TRUE(elf.Init());
245 ASSERT_TRUE(elf.valid());
246 ASSERT_EQ(static_cast<uint32_t>(EM_X86_64), elf.machine_type());
247 ASSERT_EQ(ELFCLASS64, elf.class_type());
248 ASSERT_TRUE(elf.interface() != nullptr);
249 }
250
TEST_F(ElfTest,gnu_debugdata_init32)251 TEST_F(ElfTest, gnu_debugdata_init32) {
252 TestInitGnuDebugdata<Elf32_Ehdr, Elf32_Shdr>(ELFCLASS32, EM_ARM, true,
253 [&](uint64_t offset, const void* ptr, size_t size) {
254 fake_memory_->SetMemory(offset, ptr, size);
255 });
256
257 Elf elf(elf_memory_);
258 ASSERT_TRUE(elf.Init());
259 ASSERT_TRUE(elf.interface() != nullptr);
260 ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
261 EXPECT_EQ(0x1acU, elf.interface()->gnu_debugdata_offset());
262 EXPECT_EQ(0x8cU, elf.interface()->gnu_debugdata_size());
263 }
264
TEST_F(ElfTest,gnu_debugdata_init64)265 TEST_F(ElfTest, gnu_debugdata_init64) {
266 TestInitGnuDebugdata<Elf64_Ehdr, Elf64_Shdr>(ELFCLASS64, EM_AARCH64, true,
267 [&](uint64_t offset, const void* ptr, size_t size) {
268 fake_memory_->SetMemory(offset, ptr, size);
269 });
270
271 Elf elf(elf_memory_);
272 ASSERT_TRUE(elf.Init());
273 ASSERT_TRUE(elf.interface() != nullptr);
274 ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
275 EXPECT_EQ(0x200U, elf.interface()->gnu_debugdata_offset());
276 EXPECT_EQ(0x90U, elf.interface()->gnu_debugdata_size());
277 }
278
TEST_F(ElfTest,rel_pc)279 TEST_F(ElfTest, rel_pc) {
280 ElfFake elf(elf_memory_);
281
282 ElfInterfaceFake* interface = new ElfInterfaceFake(elf_memory_);
283 elf.FakeSetInterface(interface);
284
285 elf.FakeSetValid(true);
286 auto map_info = MapInfo::Create(0x1000, 0x2000, 0, 0, "");
287
288 ASSERT_EQ(0x101U, elf.GetRelPc(0x1101, map_info.get()));
289
290 elf.FakeSetValid(false);
291 ASSERT_EQ(0x101U, elf.GetRelPc(0x1101, map_info.get()));
292 }
293
VerifyStepIfSignalHandler(uint64_t load_bias)294 void ElfTest::VerifyStepIfSignalHandler(uint64_t load_bias) {
295 ElfFake elf(elf_memory_);
296
297 RegsArm regs;
298 regs[13] = 0x50000;
299 regs[15] = 0x8000;
300
301 ElfInterfaceFake* interface = new ElfInterfaceFake(elf_memory_);
302 elf.FakeSetInterface(interface);
303 elf.FakeSetLoadBias(load_bias);
304
305 fake_memory_->SetData32(0x3000, 0xdf0027ad);
306 MemoryFake process_memory;
307 process_memory.SetData32(0x50000, 0);
308 for (size_t i = 0; i < 16; i++) {
309 process_memory.SetData32(0x500a0 + i * sizeof(uint32_t), i);
310 }
311
312 elf.FakeSetValid(true);
313 ASSERT_TRUE(elf.StepIfSignalHandler(0x3000 + load_bias, ®s, &process_memory));
314 EXPECT_EQ(ERROR_NONE, elf.GetLastErrorCode());
315 EXPECT_EQ(15U, regs.pc());
316 EXPECT_EQ(13U, regs.sp());
317 }
318
TEST_F(ElfTest,step_in_signal_map)319 TEST_F(ElfTest, step_in_signal_map) {
320 VerifyStepIfSignalHandler(0);
321 }
322
TEST_F(ElfTest,step_in_signal_map_non_zero_load_bias)323 TEST_F(ElfTest, step_in_signal_map_non_zero_load_bias) {
324 VerifyStepIfSignalHandler(0x1000);
325 }
326
327 class ElfInterfaceMock : public ElfInterface {
328 public:
ElfInterfaceMock(std::shared_ptr<Memory> & memory)329 ElfInterfaceMock(std::shared_ptr<Memory>& memory) : ElfInterface(memory) {}
330 virtual ~ElfInterfaceMock() = default;
331
Init(int64_t *)332 bool Init(int64_t*) override { return false; }
InitHeaders()333 void InitHeaders() override {}
GetSoname()334 std::string GetSoname() override { return ""; }
GetFunctionName(uint64_t,SharedString *,uint64_t *)335 bool GetFunctionName(uint64_t, SharedString*, uint64_t*) override { return false; }
GetBuildID()336 std::string GetBuildID() override { return ""; }
337
338 MOCK_METHOD(bool, Step, (uint64_t, Regs*, Memory*, bool*, bool*), (override));
339 MOCK_METHOD(bool, GetGlobalVariable, (const std::string&, uint64_t*), (override));
340 MOCK_METHOD(bool, IsValidPc, (uint64_t), (override));
341
MockSetDataOffset(uint64_t offset)342 void MockSetDataOffset(uint64_t offset) { data_offset_ = offset; }
MockSetDataVaddrStart(uint64_t vaddr)343 void MockSetDataVaddrStart(uint64_t vaddr) { data_vaddr_start_ = vaddr; }
MockSetDataVaddrEnd(uint64_t vaddr)344 void MockSetDataVaddrEnd(uint64_t vaddr) { data_vaddr_end_ = vaddr; }
345
MockSetDynamicOffset(uint64_t offset)346 void MockSetDynamicOffset(uint64_t offset) { dynamic_offset_ = offset; }
MockSetDynamicVaddrStart(uint64_t vaddr)347 void MockSetDynamicVaddrStart(uint64_t vaddr) { dynamic_vaddr_start_ = vaddr; }
MockSetDynamicVaddrEnd(uint64_t vaddr)348 void MockSetDynamicVaddrEnd(uint64_t vaddr) { dynamic_vaddr_end_ = vaddr; }
349 };
350
TEST_F(ElfTest,step_in_interface)351 TEST_F(ElfTest, step_in_interface) {
352 ElfFake elf(elf_memory_);
353 elf.FakeSetValid(true);
354
355 RegsArm regs;
356
357 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
358 elf.FakeSetInterface(interface);
359 MemoryFake process_memory;
360
361 bool finished;
362 bool is_signal_frame;
363 EXPECT_CALL(*interface, Step(0x1000, ®s, &process_memory, &finished, &is_signal_frame))
364 .WillOnce(::testing::Return(true));
365
366 ASSERT_TRUE(elf.Step(0x1000, ®s, &process_memory, &finished, &is_signal_frame));
367 }
368
TEST_F(ElfTest,get_global_invalid_elf)369 TEST_F(ElfTest, get_global_invalid_elf) {
370 ElfFake elf(elf_memory_);
371 elf.FakeSetValid(false);
372
373 std::string global("something");
374 uint64_t offset;
375 ASSERT_FALSE(elf.GetGlobalVariableOffset(global, &offset));
376 }
377
TEST_F(ElfTest,get_global_valid_not_in_interface)378 TEST_F(ElfTest, get_global_valid_not_in_interface) {
379 ElfFake elf(elf_memory_);
380 elf.FakeSetValid(true);
381
382 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
383 elf.FakeSetInterface(interface);
384
385 std::string global("something");
386 EXPECT_CALL(*interface, GetGlobalVariable(global, ::testing::_))
387 .WillOnce(::testing::Return(false));
388
389 uint64_t offset;
390 ASSERT_FALSE(elf.GetGlobalVariableOffset(global, &offset));
391 }
392
TEST_F(ElfTest,get_global_vaddr_in_no_sections)393 TEST_F(ElfTest, get_global_vaddr_in_no_sections) {
394 ElfFake elf(elf_memory_);
395 elf.FakeSetValid(true);
396
397 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
398 elf.FakeSetInterface(interface);
399
400 std::string global("something");
401 EXPECT_CALL(*interface, GetGlobalVariable(global, ::testing::_))
402 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x300), ::testing::Return(true)));
403
404 uint64_t offset;
405 ASSERT_FALSE(elf.GetGlobalVariableOffset(global, &offset));
406 }
407
TEST_F(ElfTest,get_global_vaddr_in_data_section)408 TEST_F(ElfTest, get_global_vaddr_in_data_section) {
409 ElfFake elf(elf_memory_);
410 elf.FakeSetValid(true);
411
412 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
413 elf.FakeSetInterface(interface);
414 interface->MockSetDataVaddrStart(0x500);
415 interface->MockSetDataVaddrEnd(0x600);
416 interface->MockSetDataOffset(0xa000);
417
418 std::string global("something");
419 EXPECT_CALL(*interface, GetGlobalVariable(global, ::testing::_))
420 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x580), ::testing::Return(true)));
421
422 uint64_t offset;
423 ASSERT_TRUE(elf.GetGlobalVariableOffset(global, &offset));
424 EXPECT_EQ(0xa080U, offset);
425 }
426
TEST_F(ElfTest,get_global_vaddr_in_dynamic_section)427 TEST_F(ElfTest, get_global_vaddr_in_dynamic_section) {
428 ElfFake elf(elf_memory_);
429 elf.FakeSetValid(true);
430
431 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
432 elf.FakeSetInterface(interface);
433 interface->MockSetDataVaddrStart(0x500);
434 interface->MockSetDataVaddrEnd(0x600);
435 interface->MockSetDataOffset(0xa000);
436
437 interface->MockSetDynamicVaddrStart(0x800);
438 interface->MockSetDynamicVaddrEnd(0x900);
439 interface->MockSetDynamicOffset(0xc000);
440
441 std::string global("something");
442 EXPECT_CALL(*interface, GetGlobalVariable(global, ::testing::_))
443 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x880), ::testing::Return(true)));
444
445 uint64_t offset;
446 ASSERT_TRUE(elf.GetGlobalVariableOffset(global, &offset));
447 EXPECT_EQ(0xc080U, offset);
448 }
449
TEST_F(ElfTest,get_global_vaddr_with_tagged_pointer)450 TEST_F(ElfTest, get_global_vaddr_with_tagged_pointer) {
451 ElfFake elf(elf_memory_);
452 elf.FakeSetValid(true);
453 elf.FakeSetArch(ARCH_ARM64);
454
455 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
456 elf.FakeSetInterface(interface);
457 interface->MockSetDataVaddrStart(0x500);
458 interface->MockSetDataVaddrEnd(0x600);
459 interface->MockSetDataOffset(0xa000);
460
461 std::string global("something");
462 EXPECT_CALL(*interface, GetGlobalVariable(global, ::testing::_))
463 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x8800000000000580),
464 ::testing::Return(true)));
465
466 uint64_t offset;
467 ASSERT_TRUE(elf.GetGlobalVariableOffset(global, &offset));
468 EXPECT_EQ(0xa080U, offset);
469 }
470
TEST_F(ElfTest,get_global_vaddr_without_tagged_pointer)471 TEST_F(ElfTest, get_global_vaddr_without_tagged_pointer) {
472 ElfFake elf(elf_memory_);
473 elf.FakeSetValid(true);
474 elf.FakeSetArch(ARCH_X86_64);
475
476 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
477 elf.FakeSetInterface(interface);
478 interface->MockSetDataVaddrStart(0x8800000000000500);
479 interface->MockSetDataVaddrEnd(0x8800000000000600);
480 interface->MockSetDataOffset(0x880000000000a000);
481
482 std::string global("something");
483 EXPECT_CALL(*interface, GetGlobalVariable(global, ::testing::_))
484 .WillOnce(::testing::DoAll(::testing::SetArgPointee<1>(0x8800000000000580),
485 ::testing::Return(true)));
486
487 uint64_t offset;
488 ASSERT_TRUE(elf.GetGlobalVariableOffset(global, &offset));
489 EXPECT_EQ(0x880000000000a080U, offset);
490 }
491
TEST_F(ElfTest,is_valid_pc_elf_invalid)492 TEST_F(ElfTest, is_valid_pc_elf_invalid) {
493 ElfFake elf(elf_memory_);
494 elf.FakeSetValid(false);
495
496 EXPECT_FALSE(elf.IsValidPc(0x100));
497 EXPECT_FALSE(elf.IsValidPc(0x200));
498 }
499
TEST_F(ElfTest,is_valid_pc_interface)500 TEST_F(ElfTest, is_valid_pc_interface) {
501 ElfFake elf(elf_memory_);
502 elf.FakeSetValid(true);
503
504 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
505 elf.FakeSetInterface(interface);
506
507 EXPECT_CALL(*interface, IsValidPc(0x1500)).WillOnce(::testing::Return(true));
508
509 EXPECT_TRUE(elf.IsValidPc(0x1500));
510 }
511
TEST_F(ElfTest,is_valid_pc_from_gnu_debugdata)512 TEST_F(ElfTest, is_valid_pc_from_gnu_debugdata) {
513 ElfFake elf(elf_memory_);
514 elf.FakeSetValid(true);
515
516 ElfInterfaceMock* interface = new ElfInterfaceMock(elf_memory_);
517 elf.FakeSetInterface(interface);
518 ElfInterfaceMock* gnu_interface = new ElfInterfaceMock(elf_memory_);
519 elf.FakeSetGnuDebugdataInterface(gnu_interface);
520
521 EXPECT_CALL(*interface, IsValidPc(0x1500)).WillOnce(::testing::Return(false));
522 EXPECT_CALL(*gnu_interface, IsValidPc(0x1500)).WillOnce(::testing::Return(true));
523
524 EXPECT_TRUE(elf.IsValidPc(0x1500));
525 }
526
TEST_F(ElfTest,error_code_valid)527 TEST_F(ElfTest, error_code_valid) {
528 ElfFake elf(elf_memory_);
529 elf.FakeSetValid(true);
530 ElfInterfaceFake* interface = new ElfInterfaceFake(elf_memory_);
531 elf.FakeSetInterface(interface);
532 interface->FakeSetErrorCode(ERROR_MEMORY_INVALID);
533 interface->FakeSetErrorAddress(0x1000);
534
535 ErrorData error{ERROR_NONE, 0};
536 elf.GetLastError(&error);
537 EXPECT_EQ(ERROR_MEMORY_INVALID, error.code);
538 EXPECT_EQ(0x1000U, error.address);
539 EXPECT_EQ(ERROR_MEMORY_INVALID, elf.GetLastErrorCode());
540 EXPECT_EQ(0x1000U, elf.GetLastErrorAddress());
541 }
542
TEST(ElfBuildIdTest,get_printable_build_id_empty)543 TEST(ElfBuildIdTest, get_printable_build_id_empty) {
544 std::string empty;
545 ASSERT_EQ("", Elf::GetPrintableBuildID(empty));
546 }
547
TEST(ElfBuildIdTest,get_printable_build_id_check)548 TEST(ElfBuildIdTest, get_printable_build_id_check) {
549 std::string empty = {'\xff', '\x45', '\x40', '\x0f'};
550 ASSERT_EQ("ff45400f", Elf::GetPrintableBuildID(empty));
551 }
552
553 } // namespace unwindstack
554