1 // Copyright 2010 Google LLC
2 //
3 // Redistribution and use in source and binary forms, with or without
4 // modification, are permitted provided that the following conditions are
5 // met:
6 //
7 // * Redistributions of source code must retain the above copyright
8 // notice, this list of conditions and the following disclaimer.
9 // * Redistributions in binary form must reproduce the above
10 // copyright notice, this list of conditions and the following disclaimer
11 // in the documentation and/or other materials provided with the
12 // distribution.
13 // * Neither the name of Google LLC nor the names of its
14 // contributors may be used to endorse or promote products derived from
15 // this software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29 // Original author: Jim Blandy <[email protected]> <[email protected]>
30
31 // bytereader_unittest.cc: Unit tests for google_breakpad::ByteReader
32
33 #ifdef HAVE_CONFIG_H
34 #include <config.h> // Must come first
35 #endif
36
37 #include <stdint.h>
38
39 #include <string>
40
41 #include "breakpad_googletest_includes.h"
42 #include "common/dwarf/bytereader.h"
43 #include "common/dwarf/bytereader-inl.h"
44 #include "common/dwarf/cfi_assembler.h"
45 #include "common/using_std_string.h"
46
47 using google_breakpad::ByteReader;
48 using google_breakpad::DwarfPointerEncoding;
49 using google_breakpad::ENDIANNESS_BIG;
50 using google_breakpad::ENDIANNESS_LITTLE;
51 using google_breakpad::CFISection;
52 using google_breakpad::test_assembler::Label;
53 using google_breakpad::test_assembler::kBigEndian;
54 using google_breakpad::test_assembler::kLittleEndian;
55 using google_breakpad::test_assembler::Section;
56 using testing::Test;
57
58 struct ReaderFixture {
59 string contents;
60 size_t pointer_size;
61 };
62
63 class Reader: public ReaderFixture, public Test { };
64 class ReaderDeathTest: public ReaderFixture, public Test { };
65
TEST_F(Reader,SimpleConstructor)66 TEST_F(Reader, SimpleConstructor) {
67 ByteReader reader(ENDIANNESS_BIG);
68 reader.SetAddressSize(4);
69 CFISection section(kBigEndian, 4);
70 section
71 .D8(0xc0)
72 .D16(0xcf0d)
73 .D32(0x96fdd219)
74 .D64(0xbbf55fef0825f117ULL)
75 .ULEB128(0xa0927048ba8121afULL)
76 .LEB128(-0x4f337badf4483f83LL)
77 .D32(0xfec319c9);
78 ASSERT_TRUE(section.GetContents(&contents));
79 const uint8_t* data = reinterpret_cast<const uint8_t*>(contents.data());
80 EXPECT_EQ(0xc0U, reader.ReadOneByte(data));
81 EXPECT_EQ(0xcf0dU, reader.ReadTwoBytes(data + 1));
82 EXPECT_EQ(0x96fdd219U, reader.ReadFourBytes(data + 3));
83 EXPECT_EQ(0xbbf55fef0825f117ULL, reader.ReadEightBytes(data + 7));
84 size_t leb128_size;
85 EXPECT_EQ(0xa0927048ba8121afULL,
86 reader.ReadUnsignedLEB128(data + 15, &leb128_size));
87 EXPECT_EQ(10U, leb128_size);
88 EXPECT_EQ(-0x4f337badf4483f83LL,
89 reader.ReadSignedLEB128(data + 25, &leb128_size));
90 EXPECT_EQ(10U, leb128_size);
91 EXPECT_EQ(0xfec319c9, reader.ReadAddress(data + 35));
92 }
93
TEST_F(Reader,ValidEncodings)94 TEST_F(Reader, ValidEncodings) {
95 ByteReader reader(ENDIANNESS_LITTLE);
96 EXPECT_TRUE(reader.ValidEncoding(
97 DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr)));
98 EXPECT_TRUE(reader.ValidEncoding(
99 DwarfPointerEncoding(google_breakpad::DW_EH_PE_omit)));
100 EXPECT_TRUE(reader.ValidEncoding(
101 DwarfPointerEncoding(google_breakpad::DW_EH_PE_aligned)));
102 EXPECT_TRUE(reader.ValidEncoding(
103 DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128)));
104 EXPECT_TRUE(reader.ValidEncoding(
105 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2)));
106 EXPECT_TRUE(reader.ValidEncoding(
107 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4)));
108 EXPECT_TRUE(reader.ValidEncoding(
109 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8)));
110 EXPECT_TRUE(reader.ValidEncoding(
111 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128)));
112 EXPECT_TRUE(reader.ValidEncoding(
113 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2)));
114 EXPECT_TRUE(reader.ValidEncoding(
115 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4)));
116 EXPECT_TRUE(reader.ValidEncoding(
117 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8)));
118 EXPECT_TRUE(reader.ValidEncoding(
119 DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
120 google_breakpad::DW_EH_PE_pcrel)));
121 EXPECT_TRUE(reader.ValidEncoding(
122 DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
123 google_breakpad::DW_EH_PE_pcrel)));
124 EXPECT_TRUE(reader.ValidEncoding(
125 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
126 google_breakpad::DW_EH_PE_pcrel)));
127 EXPECT_TRUE(reader.ValidEncoding(
128 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
129 google_breakpad::DW_EH_PE_pcrel)));
130 EXPECT_TRUE(reader.ValidEncoding(
131 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
132 google_breakpad::DW_EH_PE_pcrel)));
133 EXPECT_TRUE(reader.ValidEncoding(
134 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
135 google_breakpad::DW_EH_PE_pcrel)));
136 EXPECT_TRUE(reader.ValidEncoding(
137 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
138 google_breakpad::DW_EH_PE_pcrel)));
139 EXPECT_TRUE(reader.ValidEncoding(
140 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
141 google_breakpad::DW_EH_PE_pcrel)));
142 EXPECT_TRUE(reader.ValidEncoding(
143 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
144 google_breakpad::DW_EH_PE_pcrel)));
145 EXPECT_TRUE(reader.ValidEncoding(
146 DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
147 google_breakpad::DW_EH_PE_textrel)));
148 EXPECT_TRUE(reader.ValidEncoding(
149 DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
150 google_breakpad::DW_EH_PE_textrel)));
151 EXPECT_TRUE(reader.ValidEncoding(
152 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
153 google_breakpad::DW_EH_PE_textrel)));
154 EXPECT_TRUE(reader.ValidEncoding(
155 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
156 google_breakpad::DW_EH_PE_textrel)));
157 EXPECT_TRUE(reader.ValidEncoding(
158 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
159 google_breakpad::DW_EH_PE_textrel)));
160 EXPECT_TRUE(reader.ValidEncoding(
161 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
162 google_breakpad::DW_EH_PE_textrel)));
163 EXPECT_TRUE(reader.ValidEncoding(
164 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
165 google_breakpad::DW_EH_PE_textrel)));
166 EXPECT_TRUE(reader.ValidEncoding(
167 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
168 google_breakpad::DW_EH_PE_textrel)));
169 EXPECT_TRUE(reader.ValidEncoding(
170 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
171 google_breakpad::DW_EH_PE_textrel)));
172 EXPECT_TRUE(reader.ValidEncoding(
173 DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
174 google_breakpad::DW_EH_PE_datarel)));
175 EXPECT_TRUE(reader.ValidEncoding(
176 DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
177 google_breakpad::DW_EH_PE_datarel)));
178 EXPECT_TRUE(reader.ValidEncoding(
179 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
180 google_breakpad::DW_EH_PE_datarel)));
181 EXPECT_TRUE(reader.ValidEncoding(
182 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
183 google_breakpad::DW_EH_PE_datarel)));
184 EXPECT_TRUE(reader.ValidEncoding(
185 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
186 google_breakpad::DW_EH_PE_datarel)));
187 EXPECT_TRUE(reader.ValidEncoding(
188 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
189 google_breakpad::DW_EH_PE_datarel)));
190 EXPECT_TRUE(reader.ValidEncoding(
191 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
192 google_breakpad::DW_EH_PE_datarel)));
193 EXPECT_TRUE(reader.ValidEncoding(
194 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
195 google_breakpad::DW_EH_PE_datarel)));
196 EXPECT_TRUE(reader.ValidEncoding(
197 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
198 google_breakpad::DW_EH_PE_datarel)));
199 EXPECT_TRUE(reader.ValidEncoding(
200 DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
201 google_breakpad::DW_EH_PE_funcrel)));
202 EXPECT_TRUE(reader.ValidEncoding(
203 DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
204 google_breakpad::DW_EH_PE_funcrel)));
205 EXPECT_TRUE(reader.ValidEncoding(
206 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
207 google_breakpad::DW_EH_PE_funcrel)));
208 EXPECT_TRUE(reader.ValidEncoding(
209 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
210 google_breakpad::DW_EH_PE_funcrel)));
211 EXPECT_TRUE(reader.ValidEncoding(
212 DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
213 google_breakpad::DW_EH_PE_funcrel)));
214 EXPECT_TRUE(reader.ValidEncoding(
215 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
216 google_breakpad::DW_EH_PE_funcrel)));
217 EXPECT_TRUE(reader.ValidEncoding(
218 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
219 google_breakpad::DW_EH_PE_funcrel)));
220 EXPECT_TRUE(reader.ValidEncoding(
221 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
222 google_breakpad::DW_EH_PE_funcrel)));
223 EXPECT_TRUE(reader.ValidEncoding(
224 DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
225 google_breakpad::DW_EH_PE_funcrel)));
226 EXPECT_TRUE(reader.ValidEncoding(
227 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
228 google_breakpad::DW_EH_PE_absptr |
229 google_breakpad::DW_EH_PE_pcrel)));
230 EXPECT_TRUE(reader.ValidEncoding(
231 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
232 google_breakpad::DW_EH_PE_uleb128 |
233 google_breakpad::DW_EH_PE_pcrel)));
234 EXPECT_TRUE(reader.ValidEncoding(
235 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
236 google_breakpad::DW_EH_PE_udata2 |
237 google_breakpad::DW_EH_PE_pcrel)));
238 EXPECT_TRUE(reader.ValidEncoding(
239 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
240 google_breakpad::DW_EH_PE_udata4 |
241 google_breakpad::DW_EH_PE_pcrel)));
242 EXPECT_TRUE(reader.ValidEncoding(
243 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
244 google_breakpad::DW_EH_PE_udata8 |
245 google_breakpad::DW_EH_PE_pcrel)));
246 EXPECT_TRUE(reader.ValidEncoding(
247 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
248 google_breakpad::DW_EH_PE_sleb128 |
249 google_breakpad::DW_EH_PE_pcrel)));
250 EXPECT_TRUE(reader.ValidEncoding(
251 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
252 google_breakpad::DW_EH_PE_sdata2 |
253 google_breakpad::DW_EH_PE_pcrel)));
254 EXPECT_TRUE(reader.ValidEncoding(
255 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
256 google_breakpad::DW_EH_PE_sdata4 |
257 google_breakpad::DW_EH_PE_pcrel)));
258 EXPECT_TRUE(reader.ValidEncoding(
259 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
260 google_breakpad::DW_EH_PE_sdata8 |
261 google_breakpad::DW_EH_PE_pcrel)));
262 EXPECT_TRUE(reader.ValidEncoding(
263 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
264 google_breakpad::DW_EH_PE_absptr |
265 google_breakpad::DW_EH_PE_textrel)));
266 EXPECT_TRUE(reader.ValidEncoding(
267 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
268 google_breakpad::DW_EH_PE_uleb128 |
269 google_breakpad::DW_EH_PE_textrel)));
270 EXPECT_TRUE(reader.ValidEncoding(
271 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
272 google_breakpad::DW_EH_PE_udata2 |
273 google_breakpad::DW_EH_PE_textrel)));
274 EXPECT_TRUE(reader.ValidEncoding(
275 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
276 google_breakpad::DW_EH_PE_udata4 |
277 google_breakpad::DW_EH_PE_textrel)));
278 EXPECT_TRUE(reader.ValidEncoding(
279 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
280 google_breakpad::DW_EH_PE_udata8 |
281 google_breakpad::DW_EH_PE_textrel)));
282 EXPECT_TRUE(reader.ValidEncoding(
283 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
284 google_breakpad::DW_EH_PE_sleb128 |
285 google_breakpad::DW_EH_PE_textrel)));
286 EXPECT_TRUE(reader.ValidEncoding(
287 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
288 google_breakpad::DW_EH_PE_sdata2 |
289 google_breakpad::DW_EH_PE_textrel)));
290 EXPECT_TRUE(reader.ValidEncoding(
291 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
292 google_breakpad::DW_EH_PE_sdata4 |
293 google_breakpad::DW_EH_PE_textrel)));
294 EXPECT_TRUE(reader.ValidEncoding(
295 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
296 google_breakpad::DW_EH_PE_sdata8 |
297 google_breakpad::DW_EH_PE_textrel)));
298 EXPECT_TRUE(reader.ValidEncoding(
299 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
300 google_breakpad::DW_EH_PE_absptr |
301 google_breakpad::DW_EH_PE_datarel)));
302 EXPECT_TRUE(reader.ValidEncoding(
303 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
304 google_breakpad::DW_EH_PE_uleb128 |
305 google_breakpad::DW_EH_PE_datarel)));
306 EXPECT_TRUE(reader.ValidEncoding(
307 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
308 google_breakpad::DW_EH_PE_udata2 |
309 google_breakpad::DW_EH_PE_datarel)));
310 EXPECT_TRUE(reader.ValidEncoding(
311 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
312 google_breakpad::DW_EH_PE_udata4 |
313 google_breakpad::DW_EH_PE_datarel)));
314 EXPECT_TRUE(reader.ValidEncoding(
315 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
316 google_breakpad::DW_EH_PE_udata8 |
317 google_breakpad::DW_EH_PE_datarel)));
318 EXPECT_TRUE(reader.ValidEncoding(
319 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
320 google_breakpad::DW_EH_PE_sleb128 |
321 google_breakpad::DW_EH_PE_datarel)));
322 EXPECT_TRUE(reader.ValidEncoding(
323 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
324 google_breakpad::DW_EH_PE_sdata2 |
325 google_breakpad::DW_EH_PE_datarel)));
326 EXPECT_TRUE(reader.ValidEncoding(
327 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
328 google_breakpad::DW_EH_PE_sdata4 |
329 google_breakpad::DW_EH_PE_datarel)));
330 EXPECT_TRUE(reader.ValidEncoding(
331 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
332 google_breakpad::DW_EH_PE_sdata8 |
333 google_breakpad::DW_EH_PE_datarel)));
334 EXPECT_TRUE(reader.ValidEncoding(
335 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
336 google_breakpad::DW_EH_PE_absptr |
337 google_breakpad::DW_EH_PE_funcrel)));
338 EXPECT_TRUE(reader.ValidEncoding(
339 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
340 google_breakpad::DW_EH_PE_uleb128 |
341 google_breakpad::DW_EH_PE_funcrel)));
342 EXPECT_TRUE(reader.ValidEncoding(
343 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
344 google_breakpad::DW_EH_PE_udata2 |
345 google_breakpad::DW_EH_PE_funcrel)));
346 EXPECT_TRUE(reader.ValidEncoding(
347 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
348 google_breakpad::DW_EH_PE_udata4 |
349 google_breakpad::DW_EH_PE_funcrel)));
350 EXPECT_TRUE(reader.ValidEncoding(
351 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
352 google_breakpad::DW_EH_PE_udata8 |
353 google_breakpad::DW_EH_PE_funcrel)));
354 EXPECT_TRUE(reader.ValidEncoding(
355 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
356 google_breakpad::DW_EH_PE_sleb128 |
357 google_breakpad::DW_EH_PE_funcrel)));
358 EXPECT_TRUE(reader.ValidEncoding(
359 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
360 google_breakpad::DW_EH_PE_sdata2 |
361 google_breakpad::DW_EH_PE_funcrel)));
362 EXPECT_TRUE(reader.ValidEncoding(
363 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
364 google_breakpad::DW_EH_PE_sdata4 |
365 google_breakpad::DW_EH_PE_funcrel)));
366 EXPECT_TRUE(reader.ValidEncoding(
367 DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
368 google_breakpad::DW_EH_PE_sdata8 |
369 google_breakpad::DW_EH_PE_funcrel)));
370
371 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x05)));
372 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x07)));
373 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0d)));
374 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x0f)));
375 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x51)));
376 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x60)));
377 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x70)));
378 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xf0)));
379 EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0xd0)));
380 }
381
TEST_F(ReaderDeathTest,DW_EH_PE_omit)382 TEST_F(ReaderDeathTest, DW_EH_PE_omit) {
383 static const uint8_t data[] = { 42 };
384 ByteReader reader(ENDIANNESS_BIG);
385 reader.SetAddressSize(4);
386 EXPECT_DEATH(reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_omit,
387 &pointer_size),
388 "encoding != DW_EH_PE_omit");
389 }
390
TEST_F(Reader,DW_EH_PE_absptr4)391 TEST_F(Reader, DW_EH_PE_absptr4) {
392 static const uint8_t data[] = { 0x27, 0x57, 0xea, 0x40 };
393 ByteReader reader(ENDIANNESS_LITTLE);
394 reader.SetAddressSize(4);
395 EXPECT_EQ(0x40ea5727U,
396 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_absptr,
397 &pointer_size));
398 EXPECT_EQ(4U, pointer_size);
399 }
400
TEST_F(Reader,DW_EH_PE_absptr8)401 TEST_F(Reader, DW_EH_PE_absptr8) {
402 static const uint8_t data[] = {
403 0x60, 0x27, 0x57, 0xea, 0x40, 0xc2, 0x98, 0x05, 0x01, 0x50
404 };
405 ByteReader reader(ENDIANNESS_LITTLE);
406 reader.SetAddressSize(8);
407 EXPECT_EQ(0x010598c240ea5727ULL,
408 reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_absptr,
409 &pointer_size));
410 EXPECT_EQ(8U, pointer_size);
411 }
412
TEST_F(Reader,DW_EH_PE_uleb128)413 TEST_F(Reader, DW_EH_PE_uleb128) {
414 static const uint8_t data[] = { 0x81, 0x84, 0x4c };
415 ByteReader reader(ENDIANNESS_LITTLE);
416 reader.SetAddressSize(4);
417 EXPECT_EQ(0x130201U,
418 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_uleb128,
419 &pointer_size));
420 EXPECT_EQ(3U, pointer_size);
421 }
422
TEST_F(Reader,DW_EH_PE_udata2)423 TEST_F(Reader, DW_EH_PE_udata2) {
424 static const uint8_t data[] = { 0xf4, 0x8d };
425 ByteReader reader(ENDIANNESS_BIG);
426 reader.SetAddressSize(4);
427 EXPECT_EQ(0xf48dU,
428 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_udata2,
429 &pointer_size));
430 EXPECT_EQ(2U, pointer_size);
431 }
432
TEST_F(Reader,DW_EH_PE_udata4)433 TEST_F(Reader, DW_EH_PE_udata4) {
434 static const uint8_t data[] = { 0xb2, 0x68, 0xa5, 0x62, 0x8f, 0x8b };
435 ByteReader reader(ENDIANNESS_BIG);
436 reader.SetAddressSize(8);
437 EXPECT_EQ(0xa5628f8b,
438 reader.ReadEncodedPointer(data + 2, google_breakpad::DW_EH_PE_udata4,
439 &pointer_size));
440 EXPECT_EQ(4U, pointer_size);
441 }
442
TEST_F(Reader,DW_EH_PE_udata8Addr8)443 TEST_F(Reader, DW_EH_PE_udata8Addr8) {
444 static const uint8_t data[] = {
445 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe
446 };
447 ByteReader reader(ENDIANNESS_LITTLE);
448 reader.SetAddressSize(8);
449 EXPECT_EQ(0x8fed199f69047304ULL,
450 reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_udata8,
451 &pointer_size));
452 EXPECT_EQ(8U, pointer_size);
453 }
454
TEST_F(Reader,DW_EH_PE_udata8Addr4)455 TEST_F(Reader, DW_EH_PE_udata8Addr4) {
456 static const uint8_t data[] = {
457 0x27, 0x04, 0x73, 0x04, 0x69, 0x9f, 0x19, 0xed, 0x8f, 0xfe
458 };
459 ByteReader reader(ENDIANNESS_LITTLE);
460 reader.SetAddressSize(4);
461 EXPECT_EQ(0x69047304ULL,
462 reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_udata8,
463 &pointer_size));
464 EXPECT_EQ(8U, pointer_size);
465 }
466
TEST_F(Reader,DW_EH_PE_sleb128)467 TEST_F(Reader, DW_EH_PE_sleb128) {
468 static const uint8_t data[] = { 0x42, 0xff, 0xfb, 0x73 };
469 ByteReader reader(ENDIANNESS_BIG);
470 reader.SetAddressSize(4);
471 EXPECT_EQ(-0x030201U & 0xffffffff,
472 reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_sleb128,
473 &pointer_size));
474 EXPECT_EQ(3U, pointer_size);
475 }
476
TEST_F(Reader,DW_EH_PE_sdata2)477 TEST_F(Reader, DW_EH_PE_sdata2) {
478 static const uint8_t data[] = { 0xb9, 0xbf };
479 ByteReader reader(ENDIANNESS_LITTLE);
480 reader.SetAddressSize(8);
481 EXPECT_EQ(0xffffffffffffbfb9ULL,
482 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_sdata2,
483 &pointer_size));
484 EXPECT_EQ(2U, pointer_size);
485 }
486
TEST_F(Reader,DW_EH_PE_sdata4)487 TEST_F(Reader, DW_EH_PE_sdata4) {
488 static const uint8_t data[] = { 0xa0, 0xca, 0xf2, 0xb8, 0xc2, 0xad };
489 ByteReader reader(ENDIANNESS_LITTLE);
490 reader.SetAddressSize(8);
491 EXPECT_EQ(0xffffffffadc2b8f2ULL,
492 reader.ReadEncodedPointer(data + 2, google_breakpad::DW_EH_PE_sdata4,
493 &pointer_size));
494 EXPECT_EQ(4U, pointer_size);
495 }
496
TEST_F(Reader,DW_EH_PE_sdata8)497 TEST_F(Reader, DW_EH_PE_sdata8) {
498 static const uint8_t data[] = {
499 0xf6, 0x66, 0x57, 0x79, 0xe0, 0x0c, 0x9b, 0x26, 0x87
500 };
501 ByteReader reader(ENDIANNESS_LITTLE);
502 reader.SetAddressSize(8);
503 EXPECT_EQ(0x87269b0ce0795766ULL,
504 reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_sdata8,
505 &pointer_size));
506 EXPECT_EQ(8U, pointer_size);
507 }
508
TEST_F(Reader,DW_EH_PE_pcrel)509 TEST_F(Reader, DW_EH_PE_pcrel) {
510 static const uint8_t data[] = {
511 0x4a, 0x8b, 0x1b, 0x14, 0xc8, 0xc4, 0x02, 0xce
512 };
513 ByteReader reader(ENDIANNESS_BIG);
514 reader.SetAddressSize(4);
515 DwarfPointerEncoding encoding =
516 DwarfPointerEncoding(google_breakpad::DW_EH_PE_pcrel
517 | google_breakpad::DW_EH_PE_absptr);
518 reader.SetCFIDataBase(0x89951377, data);
519 EXPECT_EQ(0x89951377 + 3 + 0x14c8c402,
520 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size));
521 EXPECT_EQ(4U, pointer_size);
522 }
523
TEST_F(Reader,DW_EH_PE_textrel)524 TEST_F(Reader, DW_EH_PE_textrel) {
525 static const uint8_t data[] = {
526 0xd9, 0x0d, 0x05, 0x17, 0xc9, 0x7a, 0x42, 0x1e
527 };
528 ByteReader reader(ENDIANNESS_LITTLE);
529 reader.SetAddressSize(4);
530 reader.SetTextBase(0xb91beaf0);
531 DwarfPointerEncoding encoding =
532 DwarfPointerEncoding(google_breakpad::DW_EH_PE_textrel
533 | google_breakpad::DW_EH_PE_sdata2);
534 EXPECT_EQ((0xb91beaf0 + 0xffffc917) & 0xffffffff,
535 reader.ReadEncodedPointer(data + 3, encoding, &pointer_size));
536 EXPECT_EQ(2U, pointer_size);
537 }
538
TEST_F(Reader,DW_EH_PE_datarel)539 TEST_F(Reader, DW_EH_PE_datarel) {
540 static const uint8_t data[] = {
541 0x16, 0xf2, 0xbb, 0x82, 0x68, 0xa7, 0xbc, 0x39
542 };
543 ByteReader reader(ENDIANNESS_BIG);
544 reader.SetAddressSize(8);
545 reader.SetDataBase(0xbef308bd25ce74f0ULL);
546 DwarfPointerEncoding encoding =
547 DwarfPointerEncoding(google_breakpad::DW_EH_PE_datarel
548 | google_breakpad::DW_EH_PE_sleb128);
549 EXPECT_EQ(0xbef308bd25ce74f0ULL + 0xfffffffffffa013bULL,
550 reader.ReadEncodedPointer(data + 2, encoding, &pointer_size));
551 EXPECT_EQ(3U, pointer_size);
552 }
553
TEST_F(Reader,DW_EH_PE_funcrel)554 TEST_F(Reader, DW_EH_PE_funcrel) {
555 static const uint8_t data[] = {
556 0x84, 0xf8, 0x14, 0x01, 0x61, 0xd1, 0x48, 0xc9
557 };
558 ByteReader reader(ENDIANNESS_BIG);
559 reader.SetAddressSize(4);
560 reader.SetFunctionBase(0x823c3520);
561 DwarfPointerEncoding encoding =
562 DwarfPointerEncoding(google_breakpad::DW_EH_PE_funcrel
563 | google_breakpad::DW_EH_PE_udata2);
564 EXPECT_EQ(0x823c3520 + 0xd148,
565 reader.ReadEncodedPointer(data + 5, encoding, &pointer_size));
566 EXPECT_EQ(2U, pointer_size);
567 }
568
TEST(UsableBase,CFI)569 TEST(UsableBase, CFI) {
570 static const uint8_t data[] = { 0x42 };
571 ByteReader reader(ENDIANNESS_BIG);
572 reader.SetCFIDataBase(0xb31cbd20, data);
573 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
574 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
575 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
576 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
577 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
578 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
579 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
580 }
581
TEST(UsableBase,Text)582 TEST(UsableBase, Text) {
583 ByteReader reader(ENDIANNESS_BIG);
584 reader.SetTextBase(0xa899ccb9);
585 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
586 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
587 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
588 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
589 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
590 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
591 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
592 }
593
TEST(UsableBase,Data)594 TEST(UsableBase, Data) {
595 ByteReader reader(ENDIANNESS_BIG);
596 reader.SetDataBase(0xf7b10bcd);
597 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
598 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
599 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
600 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
601 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
602 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
603 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
604 }
605
TEST(UsableBase,Function)606 TEST(UsableBase, Function) {
607 ByteReader reader(ENDIANNESS_BIG);
608 reader.SetFunctionBase(0xc2c0ed81);
609 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
610 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
611 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
612 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
613 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
614 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
615 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
616 }
617
TEST(UsableBase,ClearFunction)618 TEST(UsableBase, ClearFunction) {
619 ByteReader reader(ENDIANNESS_BIG);
620 reader.SetFunctionBase(0xc2c0ed81);
621 reader.ClearFunctionBase();
622 EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
623 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
624 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
625 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
626 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
627 EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
628 EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
629 }
630
631 struct AlignedFixture {
AlignedFixtureAlignedFixture632 AlignedFixture() : reader(ENDIANNESS_BIG) { reader.SetAddressSize(4); }
633 static const uint8_t data[10];
634 ByteReader reader;
635 size_t pointer_size;
636 };
637
638 const uint8_t AlignedFixture::data[10] = {
639 0xfe, 0x6e, 0x93, 0xd8, 0x34, 0xd5, 0x1c, 0xd3, 0xac, 0x2b
640 };
641
642 class Aligned: public AlignedFixture, public Test { };
643
TEST_F(Aligned,DW_EH_PE_aligned0)644 TEST_F(Aligned, DW_EH_PE_aligned0) {
645 reader.SetCFIDataBase(0xb440305c, data);
646 EXPECT_EQ(0xfe6e93d8U,
647 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
648 &pointer_size));
649 EXPECT_EQ(4U, pointer_size);
650 }
651
TEST_F(Aligned,DW_EH_PE_aligned1)652 TEST_F(Aligned, DW_EH_PE_aligned1) {
653 reader.SetCFIDataBase(0xb440305d, data);
654 EXPECT_EQ(0xd834d51cU,
655 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
656 &pointer_size));
657 EXPECT_EQ(7U, pointer_size);
658 }
659
TEST_F(Aligned,DW_EH_PE_aligned2)660 TEST_F(Aligned, DW_EH_PE_aligned2) {
661 reader.SetCFIDataBase(0xb440305e, data);
662 EXPECT_EQ(0x93d834d5U,
663 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
664 &pointer_size));
665 EXPECT_EQ(6U, pointer_size);
666 }
667
TEST_F(Aligned,DW_EH_PE_aligned3)668 TEST_F(Aligned, DW_EH_PE_aligned3) {
669 reader.SetCFIDataBase(0xb440305f, data);
670 EXPECT_EQ(0x6e93d834U,
671 reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
672 &pointer_size));
673 EXPECT_EQ(5U, pointer_size);
674 }
675
TEST_F(Aligned,DW_EH_PE_aligned11)676 TEST_F(Aligned, DW_EH_PE_aligned11) {
677 reader.SetCFIDataBase(0xb4403061, data);
678 EXPECT_EQ(0xd834d51cU,
679 reader.ReadEncodedPointer(data + 1,
680 google_breakpad::DW_EH_PE_aligned,
681 &pointer_size));
682 EXPECT_EQ(6U, pointer_size);
683 }
684
TEST_F(Aligned,DW_EH_PE_aligned30)685 TEST_F(Aligned, DW_EH_PE_aligned30) {
686 reader.SetCFIDataBase(0xb4403063, data);
687 EXPECT_EQ(0x6e93d834U,
688 reader.ReadEncodedPointer(data + 1,
689 google_breakpad::DW_EH_PE_aligned,
690 &pointer_size));
691 EXPECT_EQ(4U, pointer_size);
692 }
693
TEST_F(Aligned,DW_EH_PE_aligned23)694 TEST_F(Aligned, DW_EH_PE_aligned23) {
695 reader.SetCFIDataBase(0xb4403062, data);
696 EXPECT_EQ(0x1cd3ac2bU,
697 reader.ReadEncodedPointer(data + 3,
698 google_breakpad::DW_EH_PE_aligned,
699 &pointer_size));
700 EXPECT_EQ(7U, pointer_size);
701 }
702
TEST_F(Aligned,DW_EH_PE_aligned03)703 TEST_F(Aligned, DW_EH_PE_aligned03) {
704 reader.SetCFIDataBase(0xb4403064, data);
705 EXPECT_EQ(0x34d51cd3U,
706 reader.ReadEncodedPointer(data + 3,
707 google_breakpad::DW_EH_PE_aligned,
708 &pointer_size));
709 EXPECT_EQ(5U, pointer_size);
710 }
711