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 <memory>
20 
21 #include <gtest/gtest.h>
22 
23 #include <unwindstack/ElfInterface.h>
24 
25 #include "DwarfEncoding.h"
26 #include "ElfInterfaceArm.h"
27 
28 #include "ElfFake.h"
29 #include "MemoryFake.h"
30 
31 #if !defined(PT_ARM_EXIDX)
32 #define PT_ARM_EXIDX 0x70000001
33 #endif
34 
35 #if !defined(EM_AARCH64)
36 #define EM_AARCH64 183
37 #endif
38 
39 namespace unwindstack {
40 
41 class ElfInterfaceTest : public ::testing::Test {
42  protected:
SetUp()43   void SetUp() override {
44     memory_.Clear();
45   }
46 
SetStringMemory(uint64_t offset,const char * string)47   void SetStringMemory(uint64_t offset, const char* string) {
48     memory_.SetMemory(offset, string, strlen(string) + 1);
49   }
50 
51   template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
52   void SinglePtLoad();
53 
54   template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
55   void MultipleExecutablePtLoads();
56 
57   template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
58   void MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr();
59 
60   template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
61   void NonExecutablePtLoads();
62 
63   template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
64   void ManyPhdrs();
65 
66   enum SonameTestEnum : uint8_t {
67     SONAME_NORMAL,
68     SONAME_DTNULL_AFTER,
69     SONAME_DTSIZE_SMALL,
70     SONAME_MISSING_MAP,
71   };
72 
73   template <typename Ehdr, typename Phdr, typename Shdr, typename Dyn>
74   void SonameInit(SonameTestEnum test_type = SONAME_NORMAL);
75 
76   template <typename ElfInterfaceType>
77   void Soname();
78 
79   template <typename ElfInterfaceType>
80   void SonameAfterDtNull();
81 
82   template <typename ElfInterfaceType>
83   void SonameSize();
84 
85   template <typename ElfInterfaceType>
86   void SonameMissingMap();
87 
88   template <typename ElfType>
89   void InitHeadersEhFrameTest();
90 
91   template <typename ElfType>
92   void InitHeadersDebugFrame();
93 
94   template <typename ElfType>
95   void InitHeadersEhFrameFail();
96 
97   template <typename ElfType>
98   void InitHeadersDebugFrameFail();
99 
100   template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
101   void InitSectionHeadersMalformed();
102 
103   template <typename Ehdr, typename Shdr, typename Sym, typename ElfInterfaceType>
104   void InitSectionHeaders(uint64_t entry_size);
105 
106   template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
107   void InitSectionHeadersOffsets();
108 
109   template <typename Sym>
110   void InitSym(uint64_t offset, uint32_t value, uint32_t size, uint32_t name_offset,
111                uint64_t sym_offset, const char* name);
112 
113   MemoryFake memory_;
114 };
115 
116 template <typename Sym>
InitSym(uint64_t offset,uint32_t value,uint32_t size,uint32_t name_offset,uint64_t sym_offset,const char * name)117 void ElfInterfaceTest::InitSym(uint64_t offset, uint32_t value, uint32_t size, uint32_t name_offset,
118                                uint64_t sym_offset, const char* name) {
119   Sym sym;
120   memset(&sym, 0, sizeof(sym));
121   sym.st_info = STT_FUNC;
122   sym.st_value = value;
123   sym.st_size = size;
124   sym.st_name = name_offset;
125   sym.st_shndx = SHN_COMMON;
126 
127   memory_.SetMemory(offset, &sym, sizeof(sym));
128   memory_.SetMemory(sym_offset + name_offset, name, strlen(name) + 1);
129 }
130 
131 template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
SinglePtLoad()132 void ElfInterfaceTest::SinglePtLoad() {
133   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
134 
135   Ehdr ehdr;
136   memset(&ehdr, 0, sizeof(ehdr));
137   ehdr.e_phoff = 0x100;
138   ehdr.e_phnum = 1;
139   ehdr.e_phentsize = sizeof(Phdr);
140   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
141 
142   Phdr phdr;
143   memset(&phdr, 0, sizeof(phdr));
144   phdr.p_type = PT_LOAD;
145   phdr.p_vaddr = 0x2000;
146   phdr.p_memsz = 0x10000;
147   phdr.p_flags = PF_R | PF_X;
148   phdr.p_align = 0x1000;
149   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
150 
151   uint64_t load_bias = 0;
152   ASSERT_TRUE(elf->Init(&load_bias));
153   EXPECT_EQ(0x2000U, load_bias);
154 
155   const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
156   ASSERT_EQ(1U, pt_loads.size());
157   LoadInfo load_data = pt_loads.at(0);
158   ASSERT_EQ(0U, load_data.offset);
159   ASSERT_EQ(0x2000U, load_data.table_offset);
160   ASSERT_EQ(0x10000U, load_data.table_size);
161 }
162 
TEST_F(ElfInterfaceTest,elf32_single_pt_load)163 TEST_F(ElfInterfaceTest, elf32_single_pt_load) {
164   SinglePtLoad<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
165 }
166 
TEST_F(ElfInterfaceTest,elf64_single_pt_load)167 TEST_F(ElfInterfaceTest, elf64_single_pt_load) {
168   SinglePtLoad<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
169 }
170 
171 template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
MultipleExecutablePtLoads()172 void ElfInterfaceTest::MultipleExecutablePtLoads() {
173   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
174 
175   Ehdr ehdr;
176   memset(&ehdr, 0, sizeof(ehdr));
177   ehdr.e_phoff = 0x100;
178   ehdr.e_phnum = 3;
179   ehdr.e_phentsize = sizeof(Phdr);
180   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
181 
182   Phdr phdr;
183   memset(&phdr, 0, sizeof(phdr));
184   phdr.p_type = PT_LOAD;
185   phdr.p_vaddr = 0x2000;
186   phdr.p_memsz = 0x10000;
187   phdr.p_flags = PF_R | PF_X;
188   phdr.p_align = 0x1000;
189   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
190 
191   memset(&phdr, 0, sizeof(phdr));
192   phdr.p_type = PT_LOAD;
193   phdr.p_offset = 0x1000;
194   phdr.p_vaddr = 0x2001;
195   phdr.p_memsz = 0x10001;
196   phdr.p_flags = PF_R | PF_X;
197   phdr.p_align = 0x1001;
198   memory_.SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
199 
200   memset(&phdr, 0, sizeof(phdr));
201   phdr.p_type = PT_LOAD;
202   phdr.p_offset = 0x2000;
203   phdr.p_vaddr = 0x2002;
204   phdr.p_memsz = 0x10002;
205   phdr.p_flags = PF_R | PF_X;
206   phdr.p_align = 0x1002;
207   memory_.SetMemory(0x100 + 2 * sizeof(phdr), &phdr, sizeof(phdr));
208 
209   uint64_t load_bias = 0;
210   ASSERT_TRUE(elf->Init(&load_bias));
211   EXPECT_EQ(0x2000U, load_bias);
212 
213   const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
214   ASSERT_EQ(3U, pt_loads.size());
215 
216   LoadInfo load_data = pt_loads.at(0);
217   ASSERT_EQ(0U, load_data.offset);
218   ASSERT_EQ(0x2000U, load_data.table_offset);
219   ASSERT_EQ(0x10000U, load_data.table_size);
220 
221   load_data = pt_loads.at(0x1000);
222   ASSERT_EQ(0x1000U, load_data.offset);
223   ASSERT_EQ(0x2001U, load_data.table_offset);
224   ASSERT_EQ(0x10001U, load_data.table_size);
225 
226   load_data = pt_loads.at(0x2000);
227   ASSERT_EQ(0x2000U, load_data.offset);
228   ASSERT_EQ(0x2002U, load_data.table_offset);
229   ASSERT_EQ(0x10002U, load_data.table_size);
230 }
231 
TEST_F(ElfInterfaceTest,elf32_multiple_executable_pt_loads)232 TEST_F(ElfInterfaceTest, elf32_multiple_executable_pt_loads) {
233   MultipleExecutablePtLoads<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
234 }
235 
TEST_F(ElfInterfaceTest,elf64_multiple_executable_pt_loads)236 TEST_F(ElfInterfaceTest, elf64_multiple_executable_pt_loads) {
237   MultipleExecutablePtLoads<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
238 }
239 
240 template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr()241 void ElfInterfaceTest::MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr() {
242   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
243 
244   Ehdr ehdr;
245   memset(&ehdr, 0, sizeof(ehdr));
246   ehdr.e_phoff = 0x100;
247   ehdr.e_phnum = 3;
248   ehdr.e_phentsize = sizeof(Phdr) + 100;
249   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
250 
251   Phdr phdr;
252   memset(&phdr, 0, sizeof(phdr));
253   phdr.p_type = PT_LOAD;
254   phdr.p_vaddr = 0x2000;
255   phdr.p_memsz = 0x10000;
256   phdr.p_flags = PF_R | PF_X;
257   phdr.p_align = 0x1000;
258   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
259 
260   memset(&phdr, 0, sizeof(phdr));
261   phdr.p_type = PT_LOAD;
262   phdr.p_offset = 0x1000;
263   phdr.p_vaddr = 0x2001;
264   phdr.p_memsz = 0x10001;
265   phdr.p_flags = PF_R | PF_X;
266   phdr.p_align = 0x1001;
267   memory_.SetMemory(0x100 + sizeof(phdr) + 100, &phdr, sizeof(phdr));
268 
269   memset(&phdr, 0, sizeof(phdr));
270   phdr.p_type = PT_LOAD;
271   phdr.p_offset = 0x2000;
272   phdr.p_vaddr = 0x2002;
273   phdr.p_memsz = 0x10002;
274   phdr.p_flags = PF_R | PF_X;
275   phdr.p_align = 0x1002;
276   memory_.SetMemory(0x100 + 2 * (sizeof(phdr) + 100), &phdr, sizeof(phdr));
277 
278   uint64_t load_bias = 0;
279   ASSERT_TRUE(elf->Init(&load_bias));
280   EXPECT_EQ(0x2000U, load_bias);
281 
282   const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
283   ASSERT_EQ(3U, pt_loads.size());
284 
285   LoadInfo load_data = pt_loads.at(0);
286   ASSERT_EQ(0U, load_data.offset);
287   ASSERT_EQ(0x2000U, load_data.table_offset);
288   ASSERT_EQ(0x10000U, load_data.table_size);
289 
290   load_data = pt_loads.at(0x1000);
291   ASSERT_EQ(0x1000U, load_data.offset);
292   ASSERT_EQ(0x2001U, load_data.table_offset);
293   ASSERT_EQ(0x10001U, load_data.table_size);
294 
295   load_data = pt_loads.at(0x2000);
296   ASSERT_EQ(0x2000U, load_data.offset);
297   ASSERT_EQ(0x2002U, load_data.table_offset);
298   ASSERT_EQ(0x10002U, load_data.table_size);
299 }
300 
TEST_F(ElfInterfaceTest,elf32_multiple_executable_pt_loads_increments_not_size_of_phdr)301 TEST_F(ElfInterfaceTest, elf32_multiple_executable_pt_loads_increments_not_size_of_phdr) {
302   MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn,
303                                                    ElfInterface32>();
304 }
305 
TEST_F(ElfInterfaceTest,elf64_multiple_executable_pt_loads_increments_not_size_of_phdr)306 TEST_F(ElfInterfaceTest, elf64_multiple_executable_pt_loads_increments_not_size_of_phdr) {
307   MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn,
308                                                    ElfInterface64>();
309 }
310 
311 template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
NonExecutablePtLoads()312 void ElfInterfaceTest::NonExecutablePtLoads() {
313   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
314 
315   Ehdr ehdr;
316   memset(&ehdr, 0, sizeof(ehdr));
317   ehdr.e_phoff = 0x100;
318   ehdr.e_phnum = 3;
319   ehdr.e_phentsize = sizeof(Phdr);
320   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
321 
322   Phdr phdr;
323   memset(&phdr, 0, sizeof(phdr));
324   phdr.p_type = PT_LOAD;
325   phdr.p_vaddr = 0x2000;
326   phdr.p_memsz = 0x10000;
327   phdr.p_flags = PF_R;
328   phdr.p_align = 0x1000;
329   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
330 
331   memset(&phdr, 0, sizeof(phdr));
332   phdr.p_type = PT_LOAD;
333   phdr.p_offset = 0x1000;
334   phdr.p_vaddr = 0x2001;
335   phdr.p_memsz = 0x10001;
336   phdr.p_flags = PF_R | PF_X;
337   phdr.p_align = 0x1001;
338   memory_.SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
339 
340   memset(&phdr, 0, sizeof(phdr));
341   phdr.p_type = PT_LOAD;
342   phdr.p_offset = 0x2000;
343   phdr.p_vaddr = 0x2002;
344   phdr.p_memsz = 0x10002;
345   phdr.p_flags = PF_R;
346   phdr.p_align = 0x1002;
347   memory_.SetMemory(0x100 + 2 * sizeof(phdr), &phdr, sizeof(phdr));
348 
349   uint64_t load_bias = 0;
350   ASSERT_TRUE(elf->Init(&load_bias));
351   EXPECT_EQ(0U, load_bias);
352 
353   const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
354   ASSERT_EQ(1U, pt_loads.size());
355 
356   LoadInfo load_data = pt_loads.at(0x1000);
357   ASSERT_EQ(0x1000U, load_data.offset);
358   ASSERT_EQ(0x2001U, load_data.table_offset);
359   ASSERT_EQ(0x10001U, load_data.table_size);
360 }
361 
TEST_F(ElfInterfaceTest,elf32_non_executable_pt_loads)362 TEST_F(ElfInterfaceTest, elf32_non_executable_pt_loads) {
363   NonExecutablePtLoads<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
364 }
365 
TEST_F(ElfInterfaceTest,elf64_non_executable_pt_loads)366 TEST_F(ElfInterfaceTest, elf64_non_executable_pt_loads) {
367   NonExecutablePtLoads<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
368 }
369 
370 template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
ManyPhdrs()371 void ElfInterfaceTest::ManyPhdrs() {
372   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
373 
374   Ehdr ehdr;
375   memset(&ehdr, 0, sizeof(ehdr));
376   ehdr.e_phoff = 0x100;
377   ehdr.e_phnum = 7;
378   ehdr.e_phentsize = sizeof(Phdr);
379   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
380 
381   Phdr phdr;
382   uint64_t phdr_offset = 0x100;
383 
384   memset(&phdr, 0, sizeof(phdr));
385   phdr.p_type = PT_LOAD;
386   phdr.p_vaddr = 0x2000;
387   phdr.p_memsz = 0x10000;
388   phdr.p_flags = PF_R | PF_X;
389   phdr.p_align = 0x1000;
390   memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
391   phdr_offset += sizeof(phdr);
392 
393   memset(&phdr, 0, sizeof(phdr));
394   phdr.p_type = PT_GNU_EH_FRAME;
395   memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
396   phdr_offset += sizeof(phdr);
397 
398   memset(&phdr, 0, sizeof(phdr));
399   phdr.p_type = PT_DYNAMIC;
400   memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
401   phdr_offset += sizeof(phdr);
402 
403   memset(&phdr, 0, sizeof(phdr));
404   phdr.p_type = PT_INTERP;
405   memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
406   phdr_offset += sizeof(phdr);
407 
408   memset(&phdr, 0, sizeof(phdr));
409   phdr.p_type = PT_NOTE;
410   memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
411   phdr_offset += sizeof(phdr);
412 
413   memset(&phdr, 0, sizeof(phdr));
414   phdr.p_type = PT_SHLIB;
415   memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
416   phdr_offset += sizeof(phdr);
417 
418   memset(&phdr, 0, sizeof(phdr));
419   phdr.p_type = PT_GNU_EH_FRAME;
420   memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
421   phdr_offset += sizeof(phdr);
422 
423   uint64_t load_bias = 0;
424   ASSERT_TRUE(elf->Init(&load_bias));
425   EXPECT_EQ(0x2000U, load_bias);
426 
427   const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
428   ASSERT_EQ(1U, pt_loads.size());
429 
430   LoadInfo load_data = pt_loads.at(0);
431   ASSERT_EQ(0U, load_data.offset);
432   ASSERT_EQ(0x2000U, load_data.table_offset);
433   ASSERT_EQ(0x10000U, load_data.table_size);
434 }
435 
TEST_F(ElfInterfaceTest,elf32_many_phdrs)436 TEST_F(ElfInterfaceTest, elf32_many_phdrs) {
437   ElfInterfaceTest::ManyPhdrs<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
438 }
439 
TEST_F(ElfInterfaceTest,elf64_many_phdrs)440 TEST_F(ElfInterfaceTest, elf64_many_phdrs) {
441   ElfInterfaceTest::ManyPhdrs<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
442 }
443 
TEST_F(ElfInterfaceTest,elf32_arm)444 TEST_F(ElfInterfaceTest, elf32_arm) {
445   ElfInterfaceArm elf_arm(&memory_);
446 
447   Elf32_Ehdr ehdr;
448   memset(&ehdr, 0, sizeof(ehdr));
449   ehdr.e_phoff = 0x100;
450   ehdr.e_phnum = 1;
451   ehdr.e_phentsize = sizeof(Elf32_Phdr);
452   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
453 
454   Elf32_Phdr phdr;
455   memset(&phdr, 0, sizeof(phdr));
456   phdr.p_type = PT_ARM_EXIDX;
457   phdr.p_vaddr = 0x2000;
458   phdr.p_memsz = 16;
459   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
460 
461   // Add arm exidx entries.
462   memory_.SetData32(0x2000, 0x1000);
463   memory_.SetData32(0x2008, 0x1000);
464 
465   uint64_t load_bias = 0;
466   ASSERT_TRUE(elf_arm.Init(&load_bias));
467   EXPECT_EQ(0U, load_bias);
468 
469   std::vector<uint32_t> entries;
470   for (auto addr : elf_arm) {
471     entries.push_back(addr);
472   }
473   ASSERT_EQ(2U, entries.size());
474   ASSERT_EQ(0x3000U, entries[0]);
475   ASSERT_EQ(0x3008U, entries[1]);
476 
477   ASSERT_EQ(0x2000U, elf_arm.start_offset());
478   ASSERT_EQ(2U, elf_arm.total_entries());
479 }
480 
481 template <typename Ehdr, typename Phdr, typename Shdr, typename Dyn>
SonameInit(SonameTestEnum test_type)482 void ElfInterfaceTest::SonameInit(SonameTestEnum test_type) {
483   Ehdr ehdr;
484   memset(&ehdr, 0, sizeof(ehdr));
485   ehdr.e_shoff = 0x200;
486   ehdr.e_shnum = 2;
487   ehdr.e_shentsize = sizeof(Shdr);
488   ehdr.e_phoff = 0x100;
489   ehdr.e_phnum = 1;
490   ehdr.e_phentsize = sizeof(Phdr);
491   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
492 
493   Shdr shdr;
494   memset(&shdr, 0, sizeof(shdr));
495   shdr.sh_type = SHT_STRTAB;
496   if (test_type == SONAME_MISSING_MAP) {
497     shdr.sh_addr = 0x20100;
498   } else {
499     shdr.sh_addr = 0x10100;
500   }
501   shdr.sh_offset = 0x10000;
502   memory_.SetMemory(0x200 + sizeof(shdr), &shdr, sizeof(shdr));
503 
504   Phdr phdr;
505   memset(&phdr, 0, sizeof(phdr));
506   phdr.p_type = PT_DYNAMIC;
507   phdr.p_offset = 0x2000;
508   phdr.p_memsz = sizeof(Dyn) * 3;
509   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
510 
511   uint64_t offset = 0x2000;
512   Dyn dyn;
513 
514   dyn.d_tag = DT_STRTAB;
515   dyn.d_un.d_ptr = 0x10100;
516   memory_.SetMemory(offset, &dyn, sizeof(dyn));
517   offset += sizeof(dyn);
518 
519   dyn.d_tag = DT_STRSZ;
520   if (test_type == SONAME_DTSIZE_SMALL) {
521     dyn.d_un.d_val = 0x10;
522   } else {
523     dyn.d_un.d_val = 0x1000;
524   }
525   memory_.SetMemory(offset, &dyn, sizeof(dyn));
526   offset += sizeof(dyn);
527 
528   if (test_type == SONAME_DTNULL_AFTER) {
529     dyn.d_tag = DT_NULL;
530     memory_.SetMemory(offset, &dyn, sizeof(dyn));
531     offset += sizeof(dyn);
532   }
533 
534   dyn.d_tag = DT_SONAME;
535   dyn.d_un.d_val = 0x10;
536   memory_.SetMemory(offset, &dyn, sizeof(dyn));
537   offset += sizeof(dyn);
538 
539   dyn.d_tag = DT_NULL;
540   memory_.SetMemory(offset, &dyn, sizeof(dyn));
541 
542   SetStringMemory(0x10010, "fake_soname.so");
543 }
544 
545 template <typename ElfInterfaceType>
Soname()546 void ElfInterfaceTest::Soname() {
547   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
548 
549   uint64_t load_bias = 0;
550   ASSERT_TRUE(elf->Init(&load_bias));
551   EXPECT_EQ(0U, load_bias);
552 
553   std::string name;
554   ASSERT_TRUE(elf->GetSoname(&name));
555   ASSERT_STREQ("fake_soname.so", name.c_str());
556 }
557 
TEST_F(ElfInterfaceTest,elf32_soname)558 TEST_F(ElfInterfaceTest, elf32_soname) {
559   SonameInit<Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr, Elf32_Dyn>();
560   Soname<ElfInterface32>();
561 }
562 
TEST_F(ElfInterfaceTest,elf64_soname)563 TEST_F(ElfInterfaceTest, elf64_soname) {
564   SonameInit<Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr, Elf64_Dyn>();
565   Soname<ElfInterface64>();
566 }
567 
568 template <typename ElfInterfaceType>
SonameAfterDtNull()569 void ElfInterfaceTest::SonameAfterDtNull() {
570   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
571 
572   uint64_t load_bias = 0;
573   ASSERT_TRUE(elf->Init(&load_bias));
574   EXPECT_EQ(0U, load_bias);
575 
576   std::string name;
577   ASSERT_FALSE(elf->GetSoname(&name));
578 }
579 
TEST_F(ElfInterfaceTest,elf32_soname_after_dt_null)580 TEST_F(ElfInterfaceTest, elf32_soname_after_dt_null) {
581   SonameInit<Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr, Elf32_Dyn>(SONAME_DTNULL_AFTER);
582   SonameAfterDtNull<ElfInterface32>();
583 }
584 
TEST_F(ElfInterfaceTest,elf64_soname_after_dt_null)585 TEST_F(ElfInterfaceTest, elf64_soname_after_dt_null) {
586   SonameInit<Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr, Elf64_Dyn>(SONAME_DTNULL_AFTER);
587   SonameAfterDtNull<ElfInterface64>();
588 }
589 
590 template <typename ElfInterfaceType>
SonameSize()591 void ElfInterfaceTest::SonameSize() {
592   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
593 
594   uint64_t load_bias = 0;
595   ASSERT_TRUE(elf->Init(&load_bias));
596   EXPECT_EQ(0U, load_bias);
597 
598   std::string name;
599   ASSERT_FALSE(elf->GetSoname(&name));
600 }
601 
TEST_F(ElfInterfaceTest,elf32_soname_size)602 TEST_F(ElfInterfaceTest, elf32_soname_size) {
603   SonameInit<Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr, Elf32_Dyn>(SONAME_DTSIZE_SMALL);
604   SonameSize<ElfInterface32>();
605 }
606 
TEST_F(ElfInterfaceTest,elf64_soname_size)607 TEST_F(ElfInterfaceTest, elf64_soname_size) {
608   SonameInit<Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr, Elf64_Dyn>(SONAME_DTSIZE_SMALL);
609   SonameSize<ElfInterface64>();
610 }
611 
612 // Verify that there is no map from STRTAB in the dynamic section to a
613 // STRTAB entry in the section headers.
614 template <typename ElfInterfaceType>
SonameMissingMap()615 void ElfInterfaceTest::SonameMissingMap() {
616   std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
617 
618   uint64_t load_bias = 0;
619   ASSERT_TRUE(elf->Init(&load_bias));
620   EXPECT_EQ(0U, load_bias);
621 
622   std::string name;
623   ASSERT_FALSE(elf->GetSoname(&name));
624 }
625 
TEST_F(ElfInterfaceTest,elf32_soname_missing_map)626 TEST_F(ElfInterfaceTest, elf32_soname_missing_map) {
627   SonameInit<Elf32_Ehdr, Elf32_Phdr, Elf32_Shdr, Elf32_Dyn>(SONAME_MISSING_MAP);
628   SonameMissingMap<ElfInterface32>();
629 }
630 
TEST_F(ElfInterfaceTest,elf64_soname_missing_map)631 TEST_F(ElfInterfaceTest, elf64_soname_missing_map) {
632   SonameInit<Elf64_Ehdr, Elf64_Phdr, Elf64_Shdr, Elf64_Dyn>(SONAME_MISSING_MAP);
633   SonameMissingMap<ElfInterface64>();
634 }
635 
636 template <typename ElfType>
InitHeadersEhFrameTest()637 void ElfInterfaceTest::InitHeadersEhFrameTest() {
638   ElfType elf(&memory_);
639 
640   elf.FakeSetEhFrameOffset(0x10000);
641   elf.FakeSetEhFrameSize(0);
642   elf.FakeSetDebugFrameOffset(0);
643   elf.FakeSetDebugFrameSize(0);
644 
645   memory_.SetMemory(0x10000,
646                     std::vector<uint8_t>{0x1, DW_EH_PE_udata2, DW_EH_PE_udata2, DW_EH_PE_udata2});
647   memory_.SetData32(0x10004, 0x500);
648   memory_.SetData32(0x10008, 250);
649 
650   elf.InitHeaders();
651 
652   EXPECT_FALSE(elf.eh_frame() == nullptr);
653   EXPECT_TRUE(elf.debug_frame() == nullptr);
654 }
655 
TEST_F(ElfInterfaceTest,init_headers_eh_frame32)656 TEST_F(ElfInterfaceTest, init_headers_eh_frame32) {
657   InitHeadersEhFrameTest<ElfInterface32Fake>();
658 }
659 
TEST_F(ElfInterfaceTest,init_headers_eh_frame64)660 TEST_F(ElfInterfaceTest, init_headers_eh_frame64) {
661   InitHeadersEhFrameTest<ElfInterface64Fake>();
662 }
663 
664 template <typename ElfType>
InitHeadersDebugFrame()665 void ElfInterfaceTest::InitHeadersDebugFrame() {
666   ElfType elf(&memory_);
667 
668   elf.FakeSetEhFrameOffset(0);
669   elf.FakeSetEhFrameSize(0);
670   elf.FakeSetDebugFrameOffset(0x5000);
671   elf.FakeSetDebugFrameSize(0x200);
672 
673   memory_.SetData32(0x5000, 0xfc);
674   memory_.SetData32(0x5004, 0xffffffff);
675   memory_.SetData8(0x5008, 1);
676   memory_.SetData8(0x5009, '\0');
677 
678   memory_.SetData32(0x5100, 0xfc);
679   memory_.SetData32(0x5104, 0);
680   memory_.SetData32(0x5108, 0x1500);
681   memory_.SetData32(0x510c, 0x200);
682 
683   elf.InitHeaders();
684 
685   EXPECT_TRUE(elf.eh_frame() == nullptr);
686   EXPECT_FALSE(elf.debug_frame() == nullptr);
687 }
688 
TEST_F(ElfInterfaceTest,init_headers_debug_frame32)689 TEST_F(ElfInterfaceTest, init_headers_debug_frame32) {
690   InitHeadersDebugFrame<ElfInterface32Fake>();
691 }
692 
TEST_F(ElfInterfaceTest,init_headers_debug_frame64)693 TEST_F(ElfInterfaceTest, init_headers_debug_frame64) {
694   InitHeadersDebugFrame<ElfInterface64Fake>();
695 }
696 
697 template <typename ElfType>
InitHeadersEhFrameFail()698 void ElfInterfaceTest::InitHeadersEhFrameFail() {
699   ElfType elf(&memory_);
700 
701   elf.FakeSetEhFrameOffset(0x1000);
702   elf.FakeSetEhFrameSize(0x100);
703   elf.FakeSetDebugFrameOffset(0);
704   elf.FakeSetDebugFrameSize(0);
705 
706   elf.InitHeaders();
707 
708   EXPECT_TRUE(elf.eh_frame() == nullptr);
709   EXPECT_EQ(0U, elf.eh_frame_offset());
710   EXPECT_EQ(static_cast<uint64_t>(-1), elf.eh_frame_size());
711   EXPECT_TRUE(elf.debug_frame() == nullptr);
712 }
713 
TEST_F(ElfInterfaceTest,init_headers_eh_frame32_fail)714 TEST_F(ElfInterfaceTest, init_headers_eh_frame32_fail) {
715   InitHeadersEhFrameFail<ElfInterface32Fake>();
716 }
717 
TEST_F(ElfInterfaceTest,init_headers_eh_frame64_fail)718 TEST_F(ElfInterfaceTest, init_headers_eh_frame64_fail) {
719   InitHeadersEhFrameFail<ElfInterface64Fake>();
720 }
721 
722 template <typename ElfType>
InitHeadersDebugFrameFail()723 void ElfInterfaceTest::InitHeadersDebugFrameFail() {
724   ElfType elf(&memory_);
725 
726   elf.FakeSetEhFrameOffset(0);
727   elf.FakeSetEhFrameSize(0);
728   elf.FakeSetDebugFrameOffset(0x1000);
729   elf.FakeSetDebugFrameSize(0x100);
730 
731   elf.InitHeaders();
732 
733   EXPECT_TRUE(elf.eh_frame() == nullptr);
734   EXPECT_TRUE(elf.debug_frame() == nullptr);
735   EXPECT_EQ(0U, elf.debug_frame_offset());
736   EXPECT_EQ(static_cast<uint64_t>(-1), elf.debug_frame_size());
737 }
738 
TEST_F(ElfInterfaceTest,init_headers_debug_frame32_fail)739 TEST_F(ElfInterfaceTest, init_headers_debug_frame32_fail) {
740   InitHeadersDebugFrameFail<ElfInterface32Fake>();
741 }
742 
TEST_F(ElfInterfaceTest,init_headers_debug_frame64_fail)743 TEST_F(ElfInterfaceTest, init_headers_debug_frame64_fail) {
744   InitHeadersDebugFrameFail<ElfInterface64Fake>();
745 }
746 
747 template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
InitSectionHeadersMalformed()748 void ElfInterfaceTest::InitSectionHeadersMalformed() {
749   std::unique_ptr<ElfInterfaceType> elf(new ElfInterfaceType(&memory_));
750 
751   Ehdr ehdr;
752   memset(&ehdr, 0, sizeof(ehdr));
753   ehdr.e_shoff = 0x1000;
754   ehdr.e_shnum = 10;
755   ehdr.e_shentsize = sizeof(Shdr);
756   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
757 
758   uint64_t load_bias = 0;
759   ASSERT_TRUE(elf->Init(&load_bias));
760   EXPECT_EQ(0U, load_bias);
761 }
762 
TEST_F(ElfInterfaceTest,init_section_headers_malformed32)763 TEST_F(ElfInterfaceTest, init_section_headers_malformed32) {
764   InitSectionHeadersMalformed<Elf32_Ehdr, Elf32_Shdr, ElfInterface32>();
765 }
766 
TEST_F(ElfInterfaceTest,init_section_headers_malformed64)767 TEST_F(ElfInterfaceTest, init_section_headers_malformed64) {
768   InitSectionHeadersMalformed<Elf64_Ehdr, Elf64_Shdr, ElfInterface64>();
769 }
770 
771 template <typename Ehdr, typename Shdr, typename Sym, typename ElfInterfaceType>
InitSectionHeaders(uint64_t entry_size)772 void ElfInterfaceTest::InitSectionHeaders(uint64_t entry_size) {
773   std::unique_ptr<ElfInterfaceType> elf(new ElfInterfaceType(&memory_));
774 
775   uint64_t offset = 0x1000;
776 
777   Ehdr ehdr;
778   memset(&ehdr, 0, sizeof(ehdr));
779   ehdr.e_shoff = offset;
780   ehdr.e_shnum = 10;
781   ehdr.e_shentsize = entry_size;
782   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
783 
784   offset += ehdr.e_shentsize;
785 
786   Shdr shdr;
787   memset(&shdr, 0, sizeof(shdr));
788   shdr.sh_type = SHT_SYMTAB;
789   shdr.sh_link = 4;
790   shdr.sh_addr = 0x5000;
791   shdr.sh_offset = 0x5000;
792   shdr.sh_entsize = sizeof(Sym);
793   shdr.sh_size = shdr.sh_entsize * 10;
794   memory_.SetMemory(offset, &shdr, sizeof(shdr));
795   offset += ehdr.e_shentsize;
796 
797   memset(&shdr, 0, sizeof(shdr));
798   shdr.sh_type = SHT_DYNSYM;
799   shdr.sh_link = 4;
800   shdr.sh_addr = 0x6000;
801   shdr.sh_offset = 0x6000;
802   shdr.sh_entsize = sizeof(Sym);
803   shdr.sh_size = shdr.sh_entsize * 10;
804   memory_.SetMemory(offset, &shdr, sizeof(shdr));
805   offset += ehdr.e_shentsize;
806 
807   memset(&shdr, 0, sizeof(shdr));
808   shdr.sh_type = SHT_PROGBITS;
809   shdr.sh_name = 0xa000;
810   memory_.SetMemory(offset, &shdr, sizeof(shdr));
811   offset += ehdr.e_shentsize;
812 
813   // The string data for the entries.
814   memset(&shdr, 0, sizeof(shdr));
815   shdr.sh_type = SHT_STRTAB;
816   shdr.sh_name = 0x20000;
817   shdr.sh_offset = 0xf000;
818   shdr.sh_size = 0x1000;
819   memory_.SetMemory(offset, &shdr, sizeof(shdr));
820   offset += ehdr.e_shentsize;
821 
822   InitSym<Sym>(0x5000, 0x90000, 0x1000, 0x100, 0xf000, "function_one");
823   InitSym<Sym>(0x6000, 0xd0000, 0x1000, 0x300, 0xf000, "function_two");
824 
825   uint64_t load_bias = 0;
826   ASSERT_TRUE(elf->Init(&load_bias));
827   EXPECT_EQ(0U, load_bias);
828   EXPECT_EQ(0U, elf->debug_frame_offset());
829   EXPECT_EQ(0U, elf->debug_frame_size());
830   EXPECT_EQ(0U, elf->gnu_debugdata_offset());
831   EXPECT_EQ(0U, elf->gnu_debugdata_size());
832 
833   // Look in the first symbol table.
834   std::string name;
835   uint64_t name_offset;
836   ASSERT_TRUE(elf->GetFunctionName(0x90010, 0, &name, &name_offset));
837   EXPECT_EQ("function_one", name);
838   EXPECT_EQ(16U, name_offset);
839   ASSERT_TRUE(elf->GetFunctionName(0xd0020, 0, &name, &name_offset));
840   EXPECT_EQ("function_two", name);
841   EXPECT_EQ(32U, name_offset);
842 }
843 
TEST_F(ElfInterfaceTest,init_section_headers32)844 TEST_F(ElfInterfaceTest, init_section_headers32) {
845   InitSectionHeaders<Elf32_Ehdr, Elf32_Shdr, Elf32_Sym, ElfInterface32>(sizeof(Elf32_Shdr));
846 }
847 
TEST_F(ElfInterfaceTest,init_section_headers64)848 TEST_F(ElfInterfaceTest, init_section_headers64) {
849   InitSectionHeaders<Elf64_Ehdr, Elf64_Shdr, Elf64_Sym, ElfInterface64>(sizeof(Elf64_Shdr));
850 }
851 
TEST_F(ElfInterfaceTest,init_section_headers_non_std_entry_size32)852 TEST_F(ElfInterfaceTest, init_section_headers_non_std_entry_size32) {
853   InitSectionHeaders<Elf32_Ehdr, Elf32_Shdr, Elf32_Sym, ElfInterface32>(0x100);
854 }
855 
TEST_F(ElfInterfaceTest,init_section_headers_non_std_entry_size64)856 TEST_F(ElfInterfaceTest, init_section_headers_non_std_entry_size64) {
857   InitSectionHeaders<Elf64_Ehdr, Elf64_Shdr, Elf64_Sym, ElfInterface64>(0x100);
858 }
859 
860 template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
InitSectionHeadersOffsets()861 void ElfInterfaceTest::InitSectionHeadersOffsets() {
862   std::unique_ptr<ElfInterfaceType> elf(new ElfInterfaceType(&memory_));
863 
864   uint64_t offset = 0x2000;
865 
866   Ehdr ehdr;
867   memset(&ehdr, 0, sizeof(ehdr));
868   ehdr.e_shoff = offset;
869   ehdr.e_shnum = 10;
870   ehdr.e_shentsize = sizeof(Shdr);
871   ehdr.e_shstrndx = 2;
872   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
873 
874   offset += ehdr.e_shentsize;
875 
876   Shdr shdr;
877   memset(&shdr, 0, sizeof(shdr));
878   shdr.sh_type = SHT_PROGBITS;
879   shdr.sh_link = 2;
880   shdr.sh_name = 0x200;
881   shdr.sh_addr = 0x5000;
882   shdr.sh_offset = 0x5000;
883   shdr.sh_entsize = 0x100;
884   shdr.sh_size = 0x800;
885   memory_.SetMemory(offset, &shdr, sizeof(shdr));
886   offset += ehdr.e_shentsize;
887 
888   // The string data for section header names.
889   memset(&shdr, 0, sizeof(shdr));
890   shdr.sh_type = SHT_STRTAB;
891   shdr.sh_name = 0x20000;
892   shdr.sh_offset = 0xf000;
893   shdr.sh_size = 0x1000;
894   memory_.SetMemory(offset, &shdr, sizeof(shdr));
895   offset += ehdr.e_shentsize;
896 
897   memset(&shdr, 0, sizeof(shdr));
898   shdr.sh_type = SHT_PROGBITS;
899   shdr.sh_link = 2;
900   shdr.sh_name = 0x100;
901   shdr.sh_addr = 0x6000;
902   shdr.sh_offset = 0x6000;
903   shdr.sh_entsize = 0x100;
904   shdr.sh_size = 0x500;
905   memory_.SetMemory(offset, &shdr, sizeof(shdr));
906   offset += ehdr.e_shentsize;
907 
908   memset(&shdr, 0, sizeof(shdr));
909   shdr.sh_type = SHT_PROGBITS;
910   shdr.sh_link = 2;
911   shdr.sh_name = 0x300;
912   shdr.sh_addr = 0x7000;
913   shdr.sh_offset = 0x7000;
914   shdr.sh_entsize = 0x100;
915   shdr.sh_size = 0x800;
916   memory_.SetMemory(offset, &shdr, sizeof(shdr));
917   offset += ehdr.e_shentsize;
918 
919   memset(&shdr, 0, sizeof(shdr));
920   shdr.sh_type = SHT_PROGBITS;
921   shdr.sh_link = 2;
922   shdr.sh_name = 0x400;
923   shdr.sh_addr = 0x6000;
924   shdr.sh_offset = 0xa000;
925   shdr.sh_entsize = 0x100;
926   shdr.sh_size = 0xf00;
927   memory_.SetMemory(offset, &shdr, sizeof(shdr));
928   offset += ehdr.e_shentsize;
929 
930   memory_.SetMemory(0xf100, ".debug_frame", sizeof(".debug_frame"));
931   memory_.SetMemory(0xf200, ".gnu_debugdata", sizeof(".gnu_debugdata"));
932   memory_.SetMemory(0xf300, ".eh_frame", sizeof(".eh_frame"));
933   memory_.SetMemory(0xf400, ".eh_frame_hdr", sizeof(".eh_frame_hdr"));
934 
935   uint64_t load_bias = 0;
936   ASSERT_TRUE(elf->Init(&load_bias));
937   EXPECT_EQ(0U, load_bias);
938   EXPECT_EQ(0x6000U, elf->debug_frame_offset());
939   EXPECT_EQ(0x500U, elf->debug_frame_size());
940   EXPECT_EQ(0x5000U, elf->gnu_debugdata_offset());
941   EXPECT_EQ(0x800U, elf->gnu_debugdata_size());
942   EXPECT_EQ(0x7000U, elf->eh_frame_offset());
943   EXPECT_EQ(0x800U, elf->eh_frame_size());
944   EXPECT_EQ(0xa000U, elf->eh_frame_hdr_offset());
945   EXPECT_EQ(0xf00U, elf->eh_frame_hdr_size());
946 }
947 
TEST_F(ElfInterfaceTest,init_section_headers_offsets32)948 TEST_F(ElfInterfaceTest, init_section_headers_offsets32) {
949   InitSectionHeadersOffsets<Elf32_Ehdr, Elf32_Shdr, ElfInterface32>();
950 }
951 
TEST_F(ElfInterfaceTest,init_section_headers_offsets64)952 TEST_F(ElfInterfaceTest, init_section_headers_offsets64) {
953   InitSectionHeadersOffsets<Elf64_Ehdr, Elf64_Shdr, ElfInterface64>();
954 }
955 
TEST_F(ElfInterfaceTest,is_valid_pc_from_pt_load)956 TEST_F(ElfInterfaceTest, is_valid_pc_from_pt_load) {
957   std::unique_ptr<ElfInterface> elf(new ElfInterface32(&memory_));
958 
959   Elf32_Ehdr ehdr;
960   memset(&ehdr, 0, sizeof(ehdr));
961   ehdr.e_phoff = 0x100;
962   ehdr.e_phnum = 1;
963   ehdr.e_phentsize = sizeof(Elf32_Phdr);
964   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
965 
966   Elf32_Phdr phdr;
967   memset(&phdr, 0, sizeof(phdr));
968   phdr.p_type = PT_LOAD;
969   phdr.p_vaddr = 0;
970   phdr.p_memsz = 0x10000;
971   phdr.p_flags = PF_R | PF_X;
972   phdr.p_align = 0x1000;
973   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
974 
975   uint64_t load_bias = 0;
976   ASSERT_TRUE(elf->Init(&load_bias));
977   EXPECT_EQ(0U, load_bias);
978   EXPECT_TRUE(elf->IsValidPc(0));
979   EXPECT_TRUE(elf->IsValidPc(0x5000));
980   EXPECT_TRUE(elf->IsValidPc(0xffff));
981   EXPECT_FALSE(elf->IsValidPc(0x10000));
982 }
983 
TEST_F(ElfInterfaceTest,is_valid_pc_from_pt_load_non_zero_load_bias)984 TEST_F(ElfInterfaceTest, is_valid_pc_from_pt_load_non_zero_load_bias) {
985   std::unique_ptr<ElfInterface> elf(new ElfInterface32(&memory_));
986 
987   Elf32_Ehdr ehdr;
988   memset(&ehdr, 0, sizeof(ehdr));
989   ehdr.e_phoff = 0x100;
990   ehdr.e_phnum = 1;
991   ehdr.e_phentsize = sizeof(Elf32_Phdr);
992   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
993 
994   Elf32_Phdr phdr;
995   memset(&phdr, 0, sizeof(phdr));
996   phdr.p_type = PT_LOAD;
997   phdr.p_vaddr = 0x2000;
998   phdr.p_memsz = 0x10000;
999   phdr.p_flags = PF_R | PF_X;
1000   phdr.p_align = 0x1000;
1001   memory_.SetMemory(0x100, &phdr, sizeof(phdr));
1002 
1003   uint64_t load_bias = 0;
1004   ASSERT_TRUE(elf->Init(&load_bias));
1005   EXPECT_EQ(0x2000U, load_bias);
1006   EXPECT_FALSE(elf->IsValidPc(0));
1007   EXPECT_FALSE(elf->IsValidPc(0x1000));
1008   EXPECT_FALSE(elf->IsValidPc(0x1fff));
1009   EXPECT_TRUE(elf->IsValidPc(0x2000));
1010   EXPECT_TRUE(elf->IsValidPc(0x5000));
1011   EXPECT_TRUE(elf->IsValidPc(0x11fff));
1012   EXPECT_FALSE(elf->IsValidPc(0x12000));
1013 }
1014 
TEST_F(ElfInterfaceTest,is_valid_pc_from_debug_frame)1015 TEST_F(ElfInterfaceTest, is_valid_pc_from_debug_frame) {
1016   std::unique_ptr<ElfInterface> elf(new ElfInterface32(&memory_));
1017 
1018   uint64_t sh_offset = 0x100;
1019 
1020   Elf32_Ehdr ehdr;
1021   memset(&ehdr, 0, sizeof(ehdr));
1022   ehdr.e_shstrndx = 1;
1023   ehdr.e_shoff = sh_offset;
1024   ehdr.e_shentsize = sizeof(Elf32_Shdr);
1025   ehdr.e_shnum = 3;
1026   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
1027 
1028   Elf32_Shdr shdr;
1029   memset(&shdr, 0, sizeof(shdr));
1030   shdr.sh_type = SHT_NULL;
1031   memory_.SetMemory(sh_offset, &shdr, sizeof(shdr));
1032 
1033   sh_offset += sizeof(shdr);
1034   memset(&shdr, 0, sizeof(shdr));
1035   shdr.sh_type = SHT_STRTAB;
1036   shdr.sh_name = 1;
1037   shdr.sh_offset = 0x500;
1038   shdr.sh_size = 0x100;
1039   memory_.SetMemory(sh_offset, &shdr, sizeof(shdr));
1040   memory_.SetMemory(0x500, ".debug_frame");
1041 
1042   sh_offset += sizeof(shdr);
1043   memset(&shdr, 0, sizeof(shdr));
1044   shdr.sh_type = SHT_PROGBITS;
1045   shdr.sh_name = 0;
1046   shdr.sh_addr = 0x600;
1047   shdr.sh_offset = 0x600;
1048   shdr.sh_size = 0x200;
1049   memory_.SetMemory(sh_offset, &shdr, sizeof(shdr));
1050 
1051   // CIE 32.
1052   memory_.SetData32(0x600, 0xfc);
1053   memory_.SetData32(0x604, 0xffffffff);
1054   memory_.SetData8(0x608, 1);
1055   memory_.SetData8(0x609, '\0');
1056   memory_.SetData8(0x60a, 0x4);
1057   memory_.SetData8(0x60b, 0x4);
1058   memory_.SetData8(0x60c, 0x1);
1059 
1060   // FDE 32.
1061   memory_.SetData32(0x700, 0xfc);
1062   memory_.SetData32(0x704, 0);
1063   memory_.SetData32(0x708, 0x2100);
1064   memory_.SetData32(0x70c, 0x200);
1065 
1066   uint64_t load_bias = 0;
1067   ASSERT_TRUE(elf->Init(&load_bias));
1068   elf->InitHeaders();
1069   EXPECT_EQ(0U, load_bias);
1070   EXPECT_FALSE(elf->IsValidPc(0));
1071   EXPECT_FALSE(elf->IsValidPc(0x20ff));
1072   EXPECT_TRUE(elf->IsValidPc(0x2100));
1073   EXPECT_TRUE(elf->IsValidPc(0x2200));
1074   EXPECT_TRUE(elf->IsValidPc(0x22ff));
1075   EXPECT_FALSE(elf->IsValidPc(0x2300));
1076 }
1077 
TEST_F(ElfInterfaceTest,is_valid_pc_from_eh_frame)1078 TEST_F(ElfInterfaceTest, is_valid_pc_from_eh_frame) {
1079   std::unique_ptr<ElfInterface> elf(new ElfInterface32(&memory_));
1080 
1081   uint64_t sh_offset = 0x100;
1082 
1083   Elf32_Ehdr ehdr;
1084   memset(&ehdr, 0, sizeof(ehdr));
1085   ehdr.e_shstrndx = 1;
1086   ehdr.e_shoff = sh_offset;
1087   ehdr.e_shentsize = sizeof(Elf32_Shdr);
1088   ehdr.e_shnum = 3;
1089   memory_.SetMemory(0, &ehdr, sizeof(ehdr));
1090 
1091   Elf32_Shdr shdr;
1092   memset(&shdr, 0, sizeof(shdr));
1093   shdr.sh_type = SHT_NULL;
1094   memory_.SetMemory(sh_offset, &shdr, sizeof(shdr));
1095 
1096   sh_offset += sizeof(shdr);
1097   memset(&shdr, 0, sizeof(shdr));
1098   shdr.sh_type = SHT_STRTAB;
1099   shdr.sh_name = 1;
1100   shdr.sh_offset = 0x500;
1101   shdr.sh_size = 0x100;
1102   memory_.SetMemory(sh_offset, &shdr, sizeof(shdr));
1103   memory_.SetMemory(0x500, ".eh_frame");
1104 
1105   sh_offset += sizeof(shdr);
1106   memset(&shdr, 0, sizeof(shdr));
1107   shdr.sh_type = SHT_PROGBITS;
1108   shdr.sh_name = 0;
1109   shdr.sh_addr = 0x600;
1110   shdr.sh_offset = 0x600;
1111   shdr.sh_size = 0x200;
1112   memory_.SetMemory(sh_offset, &shdr, sizeof(shdr));
1113 
1114   // CIE 32.
1115   memory_.SetData32(0x600, 0xfc);
1116   memory_.SetData32(0x604, 0);
1117   memory_.SetData8(0x608, 1);
1118   memory_.SetData8(0x609, '\0');
1119   memory_.SetData8(0x60a, 0x4);
1120   memory_.SetData8(0x60b, 0x4);
1121   memory_.SetData8(0x60c, 0x1);
1122 
1123   // FDE 32.
1124   memory_.SetData32(0x700, 0xfc);
1125   memory_.SetData32(0x704, 0x104);
1126   memory_.SetData32(0x708, 0x20f8);
1127   memory_.SetData32(0x70c, 0x200);
1128 
1129   uint64_t load_bias = 0;
1130   ASSERT_TRUE(elf->Init(&load_bias));
1131   elf->InitHeaders();
1132   EXPECT_EQ(0U, load_bias);
1133   EXPECT_FALSE(elf->IsValidPc(0));
1134   EXPECT_FALSE(elf->IsValidPc(0x27ff));
1135   EXPECT_TRUE(elf->IsValidPc(0x2800));
1136   EXPECT_TRUE(elf->IsValidPc(0x2900));
1137   EXPECT_TRUE(elf->IsValidPc(0x29ff));
1138   EXPECT_FALSE(elf->IsValidPc(0x2a00));
1139 }
1140 
1141 }  // namespace unwindstack
1142