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