1 /*
2  * Copyright (C) 2017 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 <stdint.h>
18 
19 #include <ios>
20 #include <vector>
21 
22 #include <gtest/gtest.h>
23 
24 #include <unwindstack/DwarfMemory.h>
25 
26 #include "MemoryFake.h"
27 
28 namespace unwindstack {
29 
30 class DwarfMemoryTest : public ::testing::Test {
31  protected:
SetUp()32   void SetUp() override {
33     memory_.Clear();
34     dwarf_mem_.reset(new DwarfMemory(&memory_));
35   }
36 
37   template <typename AddressType>
38   void GetEncodedSizeTest(uint8_t value, size_t expected);
39   template <typename AddressType>
40   void ReadEncodedValue_omit();
41   template <typename AddressType>
42   void ReadEncodedValue_leb128();
43   template <typename AddressType>
44   void ReadEncodedValue_data1();
45   template <typename AddressType>
46   void ReadEncodedValue_data2();
47   template <typename AddressType>
48   void ReadEncodedValue_data4();
49   template <typename AddressType>
50   void ReadEncodedValue_data8();
51   template <typename AddressType>
52   void ReadEncodedValue_non_zero_adjust();
53   template <typename AddressType>
54   void ReadEncodedValue_overflow();
55   template <typename AddressType>
56   void ReadEncodedValue_high_bit_set();
57 
58   MemoryFake memory_;
59   std::unique_ptr<DwarfMemory> dwarf_mem_;
60 };
61 
TEST_F(DwarfMemoryTest,ReadBytes)62 TEST_F(DwarfMemoryTest, ReadBytes) {
63   memory_.SetMemory(0, std::vector<uint8_t>{0x10, 0x18, 0xff, 0xfe});
64 
65   uint8_t byte;
66   ASSERT_TRUE(dwarf_mem_->ReadBytes(&byte, 1));
67   ASSERT_EQ(0x10U, byte);
68   ASSERT_TRUE(dwarf_mem_->ReadBytes(&byte, 1));
69   ASSERT_EQ(0x18U, byte);
70   ASSERT_TRUE(dwarf_mem_->ReadBytes(&byte, 1));
71   ASSERT_EQ(0xffU, byte);
72   ASSERT_TRUE(dwarf_mem_->ReadBytes(&byte, 1));
73   ASSERT_EQ(0xfeU, byte);
74   ASSERT_EQ(4U, dwarf_mem_->cur_offset());
75 
76   dwarf_mem_->set_cur_offset(2);
77   ASSERT_TRUE(dwarf_mem_->ReadBytes(&byte, 1));
78   ASSERT_EQ(0xffU, byte);
79   ASSERT_EQ(3U, dwarf_mem_->cur_offset());
80 }
81 
TEST_F(DwarfMemoryTest,ReadSigned_check)82 TEST_F(DwarfMemoryTest, ReadSigned_check) {
83   uint64_t value;
84 
85   // Signed 8 byte reads.
86   memory_.SetData8(0, static_cast<uint8_t>(-10));
87   memory_.SetData8(1, 200);
88   ASSERT_TRUE(dwarf_mem_->ReadSigned<int8_t>(&value));
89   ASSERT_EQ(static_cast<int8_t>(-10), static_cast<int8_t>(value));
90   ASSERT_TRUE(dwarf_mem_->ReadSigned<int8_t>(&value));
91   ASSERT_EQ(static_cast<int8_t>(200), static_cast<int8_t>(value));
92 
93   // Signed 16 byte reads.
94   memory_.SetData16(0x10, static_cast<uint16_t>(-1000));
95   memory_.SetData16(0x12, 50100);
96   dwarf_mem_->set_cur_offset(0x10);
97   ASSERT_TRUE(dwarf_mem_->ReadSigned<int16_t>(&value));
98   ASSERT_EQ(static_cast<int16_t>(-1000), static_cast<int16_t>(value));
99   ASSERT_TRUE(dwarf_mem_->ReadSigned<int16_t>(&value));
100   ASSERT_EQ(static_cast<int16_t>(50100), static_cast<int16_t>(value));
101 
102   // Signed 32 byte reads.
103   memory_.SetData32(0x100, static_cast<uint32_t>(-1000000000));
104   memory_.SetData32(0x104, 3000000000);
105   dwarf_mem_->set_cur_offset(0x100);
106   ASSERT_TRUE(dwarf_mem_->ReadSigned<int32_t>(&value));
107   ASSERT_EQ(static_cast<int32_t>(-1000000000), static_cast<int32_t>(value));
108   ASSERT_TRUE(dwarf_mem_->ReadSigned<int32_t>(&value));
109   ASSERT_EQ(static_cast<int32_t>(3000000000), static_cast<int32_t>(value));
110 
111   // Signed 64 byte reads.
112   memory_.SetData64(0x200, static_cast<uint64_t>(-2000000000000LL));
113   memory_.SetData64(0x208, 5000000000000LL);
114   dwarf_mem_->set_cur_offset(0x200);
115   ASSERT_TRUE(dwarf_mem_->ReadSigned<int64_t>(&value));
116   ASSERT_EQ(static_cast<int64_t>(-2000000000000), static_cast<int64_t>(value));
117   ASSERT_TRUE(dwarf_mem_->ReadSigned<int64_t>(&value));
118   ASSERT_EQ(static_cast<int64_t>(5000000000000), static_cast<int64_t>(value));
119 }
120 
TEST_F(DwarfMemoryTest,ReadULEB128)121 TEST_F(DwarfMemoryTest, ReadULEB128) {
122   memory_.SetMemory(0, std::vector<uint8_t>{0x01, 0x80, 0x24, 0xff, 0xc3, 0xff, 0x7f});
123 
124   uint64_t value;
125   ASSERT_TRUE(dwarf_mem_->ReadULEB128(&value));
126   ASSERT_EQ(1U, dwarf_mem_->cur_offset());
127   ASSERT_EQ(1U, value);
128 
129   ASSERT_TRUE(dwarf_mem_->ReadULEB128(&value));
130   ASSERT_EQ(3U, dwarf_mem_->cur_offset());
131   ASSERT_EQ(0x1200U, value);
132 
133   ASSERT_TRUE(dwarf_mem_->ReadULEB128(&value));
134   ASSERT_EQ(7U, dwarf_mem_->cur_offset());
135   ASSERT_EQ(0xfffe1ffU, value);
136 }
137 
TEST_F(DwarfMemoryTest,ReadSLEB128)138 TEST_F(DwarfMemoryTest, ReadSLEB128) {
139   memory_.SetMemory(0, std::vector<uint8_t>{0x06, 0x40, 0x82, 0x34, 0x89, 0x64, 0xf9, 0xc3, 0x8f,
140                                             0x2f, 0xbf, 0xc3, 0xf7, 0x5f});
141 
142   int64_t value;
143   ASSERT_TRUE(dwarf_mem_->ReadSLEB128(&value));
144   ASSERT_EQ(1U, dwarf_mem_->cur_offset());
145   ASSERT_EQ(6U, value);
146 
147   ASSERT_TRUE(dwarf_mem_->ReadSLEB128(&value));
148   ASSERT_EQ(2U, dwarf_mem_->cur_offset());
149   ASSERT_EQ(0xffffffffffffffc0ULL, static_cast<uint64_t>(value));
150 
151   ASSERT_TRUE(dwarf_mem_->ReadSLEB128(&value));
152   ASSERT_EQ(4U, dwarf_mem_->cur_offset());
153   ASSERT_EQ(0x1a02U, value);
154 
155   ASSERT_TRUE(dwarf_mem_->ReadSLEB128(&value));
156   ASSERT_EQ(6U, dwarf_mem_->cur_offset());
157   ASSERT_EQ(0xfffffffffffff209ULL, static_cast<uint64_t>(value));
158 
159   ASSERT_TRUE(dwarf_mem_->ReadSLEB128(&value));
160   ASSERT_EQ(10U, dwarf_mem_->cur_offset());
161   ASSERT_EQ(0x5e3e1f9U, value);
162 
163   ASSERT_TRUE(dwarf_mem_->ReadSLEB128(&value));
164   ASSERT_EQ(14U, dwarf_mem_->cur_offset());
165   ASSERT_EQ(0xfffffffffbfde1bfULL, static_cast<uint64_t>(value));
166 }
167 
168 template <typename AddressType>
GetEncodedSizeTest(uint8_t value,size_t expected)169 void DwarfMemoryTest::GetEncodedSizeTest(uint8_t value, size_t expected) {
170   for (size_t i = 0; i < 16; i++) {
171     uint8_t encoding = (i << 4) | value;
172     ASSERT_EQ(expected, dwarf_mem_->GetEncodedSize<AddressType>(encoding))
173         << "encoding 0x" << std::hex << static_cast<uint32_t>(encoding) << " test value 0x"
174         << static_cast<size_t>(value);
175   }
176 }
177 
TEST_F(DwarfMemoryTest,GetEncodedSize_absptr_uint32_t)178 TEST_F(DwarfMemoryTest, GetEncodedSize_absptr_uint32_t) {
179   GetEncodedSizeTest<uint32_t>(0, sizeof(uint32_t));
180 }
181 
TEST_F(DwarfMemoryTest,GetEncodedSize_absptr_uint64_t)182 TEST_F(DwarfMemoryTest, GetEncodedSize_absptr_uint64_t) {
183   GetEncodedSizeTest<uint64_t>(0, sizeof(uint64_t));
184 }
185 
TEST_F(DwarfMemoryTest,GetEncodedSize_data1)186 TEST_F(DwarfMemoryTest, GetEncodedSize_data1) {
187   // udata1
188   GetEncodedSizeTest<uint32_t>(0x0d, 1);
189   GetEncodedSizeTest<uint64_t>(0x0d, 1);
190 
191   // sdata1
192   GetEncodedSizeTest<uint32_t>(0x0e, 1);
193   GetEncodedSizeTest<uint64_t>(0x0e, 1);
194 }
195 
TEST_F(DwarfMemoryTest,GetEncodedSize_data2)196 TEST_F(DwarfMemoryTest, GetEncodedSize_data2) {
197   // udata2
198   GetEncodedSizeTest<uint32_t>(0x02, 2);
199   GetEncodedSizeTest<uint64_t>(0x02, 2);
200 
201   // sdata2
202   GetEncodedSizeTest<uint32_t>(0x0a, 2);
203   GetEncodedSizeTest<uint64_t>(0x0a, 2);
204 }
205 
TEST_F(DwarfMemoryTest,GetEncodedSize_data4)206 TEST_F(DwarfMemoryTest, GetEncodedSize_data4) {
207   // udata4
208   GetEncodedSizeTest<uint32_t>(0x03, 4);
209   GetEncodedSizeTest<uint64_t>(0x03, 4);
210 
211   // sdata4
212   GetEncodedSizeTest<uint32_t>(0x0b, 4);
213   GetEncodedSizeTest<uint64_t>(0x0b, 4);
214 }
215 
TEST_F(DwarfMemoryTest,GetEncodedSize_data8)216 TEST_F(DwarfMemoryTest, GetEncodedSize_data8) {
217   // udata8
218   GetEncodedSizeTest<uint32_t>(0x04, 8);
219   GetEncodedSizeTest<uint64_t>(0x04, 8);
220 
221   // sdata8
222   GetEncodedSizeTest<uint32_t>(0x0c, 8);
223   GetEncodedSizeTest<uint64_t>(0x0c, 8);
224 }
225 
TEST_F(DwarfMemoryTest,GetEncodedSize_unknown)226 TEST_F(DwarfMemoryTest, GetEncodedSize_unknown) {
227   GetEncodedSizeTest<uint32_t>(0x01, 0);
228   GetEncodedSizeTest<uint64_t>(0x01, 0);
229 
230   GetEncodedSizeTest<uint32_t>(0x09, 0);
231   GetEncodedSizeTest<uint64_t>(0x09, 0);
232 
233   GetEncodedSizeTest<uint32_t>(0x0f, 0);
234   GetEncodedSizeTest<uint64_t>(0x0f, 0);
235 }
236 
237 template <typename AddressType>
ReadEncodedValue_omit()238 void DwarfMemoryTest::ReadEncodedValue_omit() {
239   uint64_t value = 123;
240   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0xff, &value));
241   ASSERT_EQ(0U, value);
242 }
243 
TEST_F(DwarfMemoryTest,ReadEncodedValue_omit_uint32_t)244 TEST_F(DwarfMemoryTest, ReadEncodedValue_omit_uint32_t) {
245   ReadEncodedValue_omit<uint32_t>();
246 }
247 
TEST_F(DwarfMemoryTest,ReadEncodedValue_omit_uint64_t)248 TEST_F(DwarfMemoryTest, ReadEncodedValue_omit_uint64_t) {
249   ReadEncodedValue_omit<uint64_t>();
250 }
251 
TEST_F(DwarfMemoryTest,ReadEncodedValue_absptr_uint32_t)252 TEST_F(DwarfMemoryTest, ReadEncodedValue_absptr_uint32_t) {
253   uint64_t value = 100;
254   ASSERT_FALSE(dwarf_mem_->ReadEncodedValue<uint32_t>(0x00, &value));
255 
256   memory_.SetData32(0, 0x12345678);
257 
258   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<uint32_t>(0x00, &value));
259   ASSERT_EQ(4U, dwarf_mem_->cur_offset());
260   ASSERT_EQ(0x12345678U, value);
261 }
262 
TEST_F(DwarfMemoryTest,ReadEncodedValue_absptr_uint64_t)263 TEST_F(DwarfMemoryTest, ReadEncodedValue_absptr_uint64_t) {
264   uint64_t value = 100;
265   ASSERT_FALSE(dwarf_mem_->ReadEncodedValue<uint64_t>(0x00, &value));
266 
267   memory_.SetData64(0, 0x12345678f1f2f3f4ULL);
268 
269   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<uint64_t>(0x00, &value));
270   ASSERT_EQ(8U, dwarf_mem_->cur_offset());
271   ASSERT_EQ(0x12345678f1f2f3f4ULL, value);
272 }
273 
TEST_F(DwarfMemoryTest,ReadEncodedValue_aligned_uint32_t)274 TEST_F(DwarfMemoryTest, ReadEncodedValue_aligned_uint32_t) {
275   uint64_t value = 100;
276   dwarf_mem_->set_cur_offset(1);
277   ASSERT_FALSE(dwarf_mem_->ReadEncodedValue<uint32_t>(0x50, &value));
278 
279   memory_.SetData32(4, 0x12345678);
280 
281   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<uint32_t>(0x50, &value));
282   ASSERT_EQ(8U, dwarf_mem_->cur_offset());
283   ASSERT_EQ(0x12345678U, value);
284 }
285 
TEST_F(DwarfMemoryTest,ReadEncodedValue_aligned_uint64_t)286 TEST_F(DwarfMemoryTest, ReadEncodedValue_aligned_uint64_t) {
287   uint64_t value = 100;
288   dwarf_mem_->set_cur_offset(1);
289   ASSERT_FALSE(dwarf_mem_->ReadEncodedValue<uint64_t>(0x50, &value));
290 
291   memory_.SetData64(8, 0x12345678f1f2f3f4ULL);
292 
293   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<uint64_t>(0x50, &value));
294   ASSERT_EQ(16U, dwarf_mem_->cur_offset());
295   ASSERT_EQ(0x12345678f1f2f3f4ULL, value);
296 }
297 
298 template <typename AddressType>
ReadEncodedValue_leb128()299 void DwarfMemoryTest::ReadEncodedValue_leb128() {
300   memory_.SetMemory(0, std::vector<uint8_t>{0x80, 0x42});
301 
302   uint64_t value = 100;
303   // uleb128
304   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x01, &value));
305   ASSERT_EQ(0x2100U, value);
306 
307   dwarf_mem_->set_cur_offset(0);
308   // sleb128
309   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x09, &value));
310   ASSERT_EQ(0xffffffffffffe100ULL, value);
311 }
312 
TEST_F(DwarfMemoryTest,ReadEncodedValue_leb128_uint32_t)313 TEST_F(DwarfMemoryTest, ReadEncodedValue_leb128_uint32_t) {
314   ReadEncodedValue_leb128<uint32_t>();
315 }
316 
TEST_F(DwarfMemoryTest,ReadEncodedValue_leb128_uint64_t)317 TEST_F(DwarfMemoryTest, ReadEncodedValue_leb128_uint64_t) {
318   ReadEncodedValue_leb128<uint64_t>();
319 }
320 
321 template <typename AddressType>
ReadEncodedValue_data1()322 void DwarfMemoryTest::ReadEncodedValue_data1() {
323   memory_.SetData8(0, 0xe0);
324 
325   uint64_t value = 0;
326   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x0d, &value));
327   ASSERT_EQ(0xe0U, value);
328 
329   dwarf_mem_->set_cur_offset(0);
330   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x0e, &value));
331   ASSERT_EQ(0xffffffffffffffe0ULL, value);
332 }
333 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data1_uint32_t)334 TEST_F(DwarfMemoryTest, ReadEncodedValue_data1_uint32_t) {
335   ReadEncodedValue_data1<uint32_t>();
336 }
337 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data1_uint64_t)338 TEST_F(DwarfMemoryTest, ReadEncodedValue_data1_uint64_t) {
339   ReadEncodedValue_data1<uint64_t>();
340 }
341 
342 template <typename AddressType>
ReadEncodedValue_data2()343 void DwarfMemoryTest::ReadEncodedValue_data2() {
344   memory_.SetData16(0, 0xe000);
345 
346   uint64_t value = 0;
347   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x02, &value));
348   ASSERT_EQ(0xe000U, value);
349 
350   dwarf_mem_->set_cur_offset(0);
351   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x0a, &value));
352   ASSERT_EQ(0xffffffffffffe000ULL, value);
353 }
354 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data2_uint32_t)355 TEST_F(DwarfMemoryTest, ReadEncodedValue_data2_uint32_t) {
356   ReadEncodedValue_data2<uint32_t>();
357 }
358 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data2_uint64_t)359 TEST_F(DwarfMemoryTest, ReadEncodedValue_data2_uint64_t) {
360   ReadEncodedValue_data2<uint64_t>();
361 }
362 
363 template <typename AddressType>
ReadEncodedValue_data4()364 void DwarfMemoryTest::ReadEncodedValue_data4() {
365   memory_.SetData32(0, 0xe0000000);
366 
367   uint64_t value = 0;
368   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x03, &value));
369   ASSERT_EQ(0xe0000000U, value);
370 
371   dwarf_mem_->set_cur_offset(0);
372   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x0b, &value));
373   ASSERT_EQ(0xffffffffe0000000ULL, value);
374 }
375 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data4_uint32_t)376 TEST_F(DwarfMemoryTest, ReadEncodedValue_data4_uint32_t) {
377   ReadEncodedValue_data4<uint32_t>();
378 }
379 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data4_uint64_t)380 TEST_F(DwarfMemoryTest, ReadEncodedValue_data4_uint64_t) {
381   ReadEncodedValue_data4<uint64_t>();
382 }
383 
384 template <typename AddressType>
ReadEncodedValue_data8()385 void DwarfMemoryTest::ReadEncodedValue_data8() {
386   memory_.SetData64(0, 0xe000000000000000ULL);
387 
388   uint64_t value = 0;
389   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x04, &value));
390   ASSERT_EQ(0xe000000000000000ULL, value);
391 
392   dwarf_mem_->set_cur_offset(0);
393   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x0c, &value));
394   ASSERT_EQ(0xe000000000000000ULL, value);
395 }
396 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data8_uint32_t)397 TEST_F(DwarfMemoryTest, ReadEncodedValue_data8_uint32_t) {
398   ReadEncodedValue_data8<uint32_t>();
399 }
400 
TEST_F(DwarfMemoryTest,ReadEncodedValue_data8_uint64_t)401 TEST_F(DwarfMemoryTest, ReadEncodedValue_data8_uint64_t) {
402   ReadEncodedValue_data8<uint64_t>();
403 }
404 
405 template <typename AddressType>
ReadEncodedValue_non_zero_adjust()406 void DwarfMemoryTest::ReadEncodedValue_non_zero_adjust() {
407   memory_.SetData64(0, 0xe000000000000000ULL);
408 
409   uint64_t value = 0;
410   dwarf_mem_->set_pc_offset(0x2000);
411   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0x14, &value));
412   ASSERT_EQ(0xe000000000002000ULL, value);
413 }
414 
TEST_F(DwarfMemoryTest,ReadEncodedValue_non_zero_adjust_uint32_t)415 TEST_F(DwarfMemoryTest, ReadEncodedValue_non_zero_adjust_uint32_t) {
416   ReadEncodedValue_non_zero_adjust<uint32_t>();
417 }
418 
TEST_F(DwarfMemoryTest,ReadEncodedValue_non_zero_adjust_uint64_t)419 TEST_F(DwarfMemoryTest, ReadEncodedValue_non_zero_adjust_uint64_t) {
420   ReadEncodedValue_non_zero_adjust<uint64_t>();
421 }
422 
423 template <typename AddressType>
ReadEncodedValue_overflow()424 void DwarfMemoryTest::ReadEncodedValue_overflow() {
425   memory_.SetData64(0, 0);
426 
427   uint64_t value = 0;
428   dwarf_mem_->set_cur_offset(UINT64_MAX);
429   ASSERT_FALSE(dwarf_mem_->ReadEncodedValue<AddressType>(0x50, &value));
430 }
431 
TEST_F(DwarfMemoryTest,ReadEncodedValue_overflow_uint32_t)432 TEST_F(DwarfMemoryTest, ReadEncodedValue_overflow_uint32_t) {
433   ReadEncodedValue_overflow<uint32_t>();
434 }
435 
TEST_F(DwarfMemoryTest,ReadEncodedValue_overflow_uint64_t)436 TEST_F(DwarfMemoryTest, ReadEncodedValue_overflow_uint64_t) {
437   ReadEncodedValue_overflow<uint64_t>();
438 }
439 
440 template <typename AddressType>
ReadEncodedValue_high_bit_set()441 void DwarfMemoryTest::ReadEncodedValue_high_bit_set() {
442   uint64_t value;
443   memory_.SetData32(0, 0x15234);
444   ASSERT_FALSE(dwarf_mem_->ReadEncodedValue<AddressType>(0xc3, &value));
445 
446   dwarf_mem_->set_func_offset(0x60000);
447   dwarf_mem_->set_cur_offset(0);
448   ASSERT_TRUE(dwarf_mem_->ReadEncodedValue<AddressType>(0xc3, &value));
449   ASSERT_EQ(0x75234U, value);
450 }
451 
TEST_F(DwarfMemoryTest,ReadEncodedValue_high_bit_set_uint32_t)452 TEST_F(DwarfMemoryTest, ReadEncodedValue_high_bit_set_uint32_t) {
453   ReadEncodedValue_high_bit_set<uint32_t>();
454 }
455 
TEST_F(DwarfMemoryTest,ReadEncodedValue_high_bit_set_uint64_t)456 TEST_F(DwarfMemoryTest, ReadEncodedValue_high_bit_set_uint64_t) {
457   ReadEncodedValue_high_bit_set<uint64_t>();
458 }
459 
TEST_F(DwarfMemoryTest,AdjustEncodedValue_absptr)460 TEST_F(DwarfMemoryTest, AdjustEncodedValue_absptr) {
461   uint64_t value = 0x1234;
462   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x00, &value));
463   ASSERT_EQ(0x1234U, value);
464 }
465 
TEST_F(DwarfMemoryTest,AdjustEncodedValue_pcrel)466 TEST_F(DwarfMemoryTest, AdjustEncodedValue_pcrel) {
467   uint64_t value = 0x1234;
468   ASSERT_FALSE(dwarf_mem_->AdjustEncodedValue(0x10, &value));
469 
470   dwarf_mem_->set_pc_offset(0x2000);
471   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x10, &value));
472   ASSERT_EQ(0x3234U, value);
473 
474   dwarf_mem_->set_pc_offset(static_cast<uint64_t>(-4));
475   value = 0x1234;
476   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x10, &value));
477   ASSERT_EQ(0x1230U, value);
478 }
479 
TEST_F(DwarfMemoryTest,AdjustEncodedValue_textrel)480 TEST_F(DwarfMemoryTest, AdjustEncodedValue_textrel) {
481   uint64_t value = 0x8234;
482   ASSERT_FALSE(dwarf_mem_->AdjustEncodedValue(0x20, &value));
483 
484   dwarf_mem_->set_text_offset(0x1000);
485   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x20, &value));
486   ASSERT_EQ(0x9234U, value);
487 
488   dwarf_mem_->set_text_offset(static_cast<uint64_t>(-16));
489   value = 0x8234;
490   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x20, &value));
491   ASSERT_EQ(0x8224U, value);
492 }
493 
TEST_F(DwarfMemoryTest,AdjustEncodedValue_datarel)494 TEST_F(DwarfMemoryTest, AdjustEncodedValue_datarel) {
495   uint64_t value = 0xb234;
496   ASSERT_FALSE(dwarf_mem_->AdjustEncodedValue(0x30, &value));
497 
498   dwarf_mem_->set_data_offset(0x1200);
499   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x30, &value));
500   ASSERT_EQ(0xc434U, value);
501 
502   dwarf_mem_->set_data_offset(static_cast<uint64_t>(-256));
503   value = 0xb234;
504   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x30, &value));
505   ASSERT_EQ(0xb134U, value);
506 }
507 
TEST_F(DwarfMemoryTest,AdjustEncodedValue_funcrel)508 TEST_F(DwarfMemoryTest, AdjustEncodedValue_funcrel) {
509   uint64_t value = 0x15234;
510   ASSERT_FALSE(dwarf_mem_->AdjustEncodedValue(0x40, &value));
511 
512   dwarf_mem_->set_func_offset(0x60000);
513   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x40, &value));
514   ASSERT_EQ(0x75234U, value);
515 
516   dwarf_mem_->set_func_offset(static_cast<uint64_t>(-4096));
517   value = 0x15234;
518   ASSERT_TRUE(dwarf_mem_->AdjustEncodedValue(0x40, &value));
519   ASSERT_EQ(0x14234U, value);
520 }
521 
522 }  // namespace unwindstack
523