Debian Codegraph @

tests/helpers/common/test_type.py

raw
1 # Copyright (c) Meta Platforms, Inc. and affiliates.
2 # SPDX-License-Identifier: LGPL-2.1-or-later
3
4
5 from drgn import NoDefaultProgramError, TypeMember
6 from drgn.helpers.common.type import member_at_offset, typeof_member
7 from tests import TestCase, mock_program, with_default_prog
8
9
10 class TestMemberAtOffset(TestCase):
11 def test_simple(self):
12 prog = mock_program()
13 point_type = prog.struct_type(
14 "point",
15 8,
16 (
17 TypeMember(prog.int_type("int", 4, True), "x", 0),
18 TypeMember(prog.int_type("int", 4, True), "y", 32),
19 ),
20 )
21 self.assertEqual(member_at_offset(point_type, 0), "x")
22 self.assertEqual(member_at_offset(point_type, 4), "y")
23
24 def test_unnamed_member(self):
25 prog = mock_program()
26 type = prog.struct_type(
27 None,
28 8,
29 (
30 TypeMember(
31 prog.struct_type(
32 None,
33 8,
34 (
35 TypeMember(prog.int_type("int", 4, True), "x", 0),
36 TypeMember(prog.int_type("int", 4, True), "y", 32),
37 ),
38 ),
39 None,
40 ),
41 ),
42 )
43 self.assertEqual(member_at_offset(type, 0), "x")
44 self.assertEqual(member_at_offset(type, 4), "y")
45
46 def test_end(self):
47 prog = mock_program()
48 point_type = prog.struct_type(
49 "point",
50 8,
51 (
52 TypeMember(prog.int_type("int", 4, True), "x", 0),
53 TypeMember(prog.int_type("int", 4, True), "y", 32),
54 ),
55 )
56 self.assertEqual(member_at_offset(point_type, 8), "<end>")
57 self.assertEqual(member_at_offset(point_type, 9), "<past end>")
58
59 def test_padding_between_members(self):
60 prog = mock_program()
61 type = prog.struct_type(
62 None,
63 16,
64 (
65 TypeMember(prog.int_type("int", 4, True), "i", 0),
66 TypeMember(prog.int_type("long", 8, True), "l", 64),
67 ),
68 )
69 self.assertEqual(member_at_offset(type, 4), "<padding between i and l>")
70
71 def test_padding_between_unnamed_members(self):
72 prog = mock_program()
73
74 type = prog.struct_type(
75 None,
76 16,
77 (
78 TypeMember(prog.int_type("int", 4, True), "i"),
79 TypeMember(
80 prog.struct_type(
81 None, 8, (TypeMember(prog.int_type("long", 8, True), "l"),)
82 ),
83 None,
84 64,
85 ),
86 ),
87 )
88 self.assertEqual(member_at_offset(type, 4), "<padding between i and <unnamed>>")
89
90 type = prog.struct_type(
91 None,
92 16,
93 (
94 TypeMember(
95 prog.struct_type(
96 None, 4, (TypeMember(prog.int_type("int", 4, True), "i"),)
97 ),
98 None,
99 ),
100 TypeMember(prog.int_type("long", 8, True), "l", 64),
101 ),
102 )
103 self.assertEqual(member_at_offset(type, 4), "<padding between <unnamed> and l>")
104
105 type = prog.struct_type(
106 None,
107 16,
108 (
109 TypeMember(
110 prog.struct_type(
111 None, 4, (TypeMember(prog.int_type("int", 4, True), "i"),)
112 ),
113 None,
114 ),
115 TypeMember(
116 prog.struct_type(
117 None, 8, (TypeMember(prog.int_type("long", 8, True), "l"),)
118 ),
119 None,
120 64,
121 ),
122 ),
123 )
124 self.assertEqual(
125 member_at_offset(type, 4), "<padding between <unnamed> and <unnamed>>"
126 )
127
128 def test_padding_at_end(self):
129 prog = mock_program()
130 type = prog.struct_type(
131 None,
132 16,
133 (
134 TypeMember(prog.int_type("long", 8, True), "l", 0),
135 TypeMember(prog.int_type("int", 4, True), "i", 64),
136 ),
137 )
138 self.assertEqual(member_at_offset(type, 12), "<padding at end>")
139
140 def test_padding_at_beginning(self):
141 prog = mock_program()
142 type = prog.struct_type(
143 None,
144 16,
145 (TypeMember(prog.int_type("int", 4, True), "i", 32),),
146 )
147 self.assertEqual(member_at_offset(type, 0), "<padding at beginning>")
148
149 def test_offset(self):
150 prog = mock_program()
151 point_type = prog.struct_type(
152 "point",
153 8,
154 (
155 TypeMember(prog.int_type("int", 4, True), "x", 0),
156 TypeMember(prog.int_type("int", 4, True), "y", 32),
157 ),
158 )
159 self.assertEqual(member_at_offset(point_type, 2), "x+0x2")
160 self.assertEqual(member_at_offset(point_type, 6), "y+0x2")
161
162 def test_nested(self):
163 prog = mock_program()
164 point_type = prog.struct_type(
165 "point",
166 8,
167 (
168 TypeMember(prog.int_type("int", 4, True), "x", 0),
169 TypeMember(prog.int_type("int", 4, True), "y", 32),
170 ),
171 )
172 line_segment_type = prog.struct_type(
173 "line_segment",
174 16,
175 (TypeMember(point_type, "a"), TypeMember(point_type, "b", 64)),
176 )
177 self.assertEqual(member_at_offset(line_segment_type, 0), "a.x")
178 self.assertEqual(member_at_offset(line_segment_type, 4), "a.y")
179 self.assertEqual(member_at_offset(line_segment_type, 8), "b.x")
180 self.assertEqual(member_at_offset(line_segment_type, 12), "b.y")
181
182 def test_padding_in_nested(self):
183 prog = mock_program()
184 type = prog.struct_type(
185 None,
186 16,
187 (
188 TypeMember(
189 prog.struct_type(
190 None,
191 16,
192 (
193 TypeMember(prog.int_type("int", 4, True), "i", 0),
194 TypeMember(prog.int_type("long", 8, True), "l", 64),
195 ),
196 ),
197 "x",
198 ),
199 ),
200 )
201 self.assertEqual(member_at_offset(type, 4), "x.<padding between i and l>")
202
203 def test_array(self):
204 prog = mock_program()
205 type = prog.array_type(prog.int_type("int", 4, True), 2)
206 self.assertEqual(member_at_offset(type, 0), "[0]")
207 self.assertEqual(member_at_offset(type, 4), "[1]")
208
209 def test_array_end(self):
210 prog = mock_program()
211 type = prog.array_type(prog.int_type("int", 4, True), 2)
212 self.assertEqual(member_at_offset(type, 8), "<end>")
213 self.assertEqual(member_at_offset(type, 9), "<past end>")
214
215 def test_array_padding_at_end_of_element(self):
216 prog = mock_program()
217 type = prog.array_type(
218 prog.struct_type(
219 None,
220 16,
221 (
222 TypeMember(prog.int_type("long", 8, True), "l", 0),
223 TypeMember(prog.int_type("int", 4, True), "i", 64),
224 ),
225 ),
226 2,
227 )
228 self.assertEqual(member_at_offset(type, 12), "[0].<padding at end>")
229
230 def test_array_offset(self):
231 prog = mock_program()
232 type = prog.array_type(prog.int_type("int", 4, True), 2)
233 self.assertEqual(member_at_offset(type, 1), "[0]+0x1")
234 self.assertEqual(member_at_offset(type, 7), "[1]+0x3")
235
236 def test_array_of_structs(self):
237 prog = mock_program()
238 type = prog.array_type(
239 prog.struct_type(
240 "point",
241 8,
242 (
243 TypeMember(prog.int_type("int", 4, True), "x", 0),
244 TypeMember(prog.int_type("int", 4, True), "y", 32),
245 ),
246 ),
247 2,
248 )
249 self.assertEqual(member_at_offset(type, 0), "[0].x")
250 self.assertEqual(member_at_offset(type, 4), "[0].y")
251 self.assertEqual(member_at_offset(type, 8), "[1].x")
252 self.assertEqual(member_at_offset(type, 12), "[1].y")
253
254 def test_array_of_structs_end(self):
255 prog = mock_program()
256 type = prog.array_type(
257 prog.struct_type(
258 "point",
259 8,
260 (
261 TypeMember(prog.int_type("int", 4, True), "x", 0),
262 TypeMember(prog.int_type("int", 4, True), "y", 32),
263 ),
264 ),
265 2,
266 )
267 self.assertEqual(member_at_offset(type, 16), "<end>")
268 self.assertEqual(member_at_offset(type, 17), "<past end>")
269
270 def test_array_of_structs_padding(self):
271 prog = mock_program()
272 type = prog.array_type(
273 prog.struct_type(
274 None,
275 16,
276 (
277 TypeMember(prog.int_type("int", 4, True), "i", 0),
278 TypeMember(prog.int_type("long", 8, True), "l", 64),
279 ),
280 ),
281 2,
282 )
283 self.assertEqual(member_at_offset(type, 4), "[0].<padding between i and l>")
284 self.assertEqual(member_at_offset(type, 20), "[1].<padding between i and l>")
285
286 def test_array_member(self):
287 prog = mock_program()
288 type = prog.struct_type(
289 None,
290 16,
291 (
292 TypeMember(prog.array_type(prog.int_type("int", 4, True), 3), "a", 0),
293 TypeMember(prog.array_type(prog.int_type("int", 4, True), 1), "b", 96),
294 ),
295 )
296 self.assertEqual(member_at_offset(type, 0), "a[0]")
297 self.assertEqual(member_at_offset(type, 4), "a[1]")
298 self.assertEqual(member_at_offset(type, 8), "a[2]")
299 self.assertEqual(member_at_offset(type, 12), "b[0]")
300
301 def test_array_member_end(self):
302 prog = mock_program()
303 type = prog.struct_type(
304 None,
305 16,
306 (
307 TypeMember(prog.array_type(prog.int_type("int", 4, True), 3), "a", 0),
308 TypeMember(prog.array_type(prog.int_type("int", 4, True), 1), "b", 96),
309 ),
310 )
311 self.assertEqual(member_at_offset(type, 16), "<end>")
312 self.assertEqual(member_at_offset(type, 17), "<past end>")
313
314 def test_incomplete_array(self):
315 prog = mock_program()
316 type = prog.array_type(prog.int_type("int", 4, True), None)
317 self.assertEqual(member_at_offset(type, 0), "[0]")
318 self.assertEqual(member_at_offset(type, 8), "[2]")
319
320 def test_incomplete_array_offset(self):
321 prog = mock_program()
322 type = prog.array_type(prog.int_type("int", 4, True), None)
323 self.assertEqual(member_at_offset(type, 3), "[0]+0x3")
324 self.assertEqual(member_at_offset(type, 10), "[2]+0x2")
325
326 def test_incomplete_array_member(self):
327 prog = mock_program()
328 type = prog.struct_type(
329 None,
330 16,
331 (
332 TypeMember(prog.int_type("int", 4, True), "n", 0),
333 TypeMember(
334 prog.array_type(prog.int_type("int", 4, True), None), "a", 32
335 ),
336 ),
337 )
338 self.assertEqual(member_at_offset(type, 0), "n")
339 self.assertEqual(member_at_offset(type, 4), "a[0]")
340 self.assertEqual(member_at_offset(type, 8), "a[1]")
341
342 def test_union(self):
343 prog = mock_program()
344 option_type = prog.union_type(
345 "option",
346 4,
347 (
348 TypeMember(prog.int_type("int", 4, True), "i"),
349 TypeMember(prog.float_type("float", 4), "f"),
350 ),
351 )
352 self.assertEqual(member_at_offset(option_type, 0), "i or f")
353
354 def test_union_end(self):
355 prog = mock_program()
356 option_type = prog.union_type(
357 "option",
358 4,
359 (
360 TypeMember(prog.int_type("int", 4, True), "i"),
361 TypeMember(prog.float_type("float", 4), "f"),
362 ),
363 )
364 self.assertEqual(member_at_offset(option_type, 4), "<end>")
365
366 def test_union_of_structs(self):
367 prog = mock_program()
368 type = prog.union_type(
369 None,
370 8,
371 (
372 TypeMember(
373 prog.struct_type(
374 None,
375 8,
376 (
377 TypeMember(prog.int_type("int", 4, True), "x", 0),
378 TypeMember(prog.int_type("int", 4, True), "y", 32),
379 ),
380 ),
381 "point",
382 ),
383 TypeMember(prog.float_type("int", 4), "i"),
384 ),
385 )
386 self.assertEqual(member_at_offset(type, 0), "point.x or i")
387 self.assertEqual(member_at_offset(type, 4), "point.y")
388
389 def test_unions_nested(self):
390 prog = mock_program()
391 type = prog.union_type(
392 None,
393 8,
394 (
395 TypeMember(
396 prog.union_type(
397 None,
398 8,
399 (
400 TypeMember(prog.int_type("long", 8, True), "l"),
401 TypeMember(prog.float_type("double", 8), "d"),
402 ),
403 ),
404 "big",
405 ),
406 TypeMember(
407 prog.union_type(
408 None,
409 4,
410 (
411 TypeMember(prog.int_type("int", 4, True), "i"),
412 TypeMember(prog.float_type("float", 4), "f"),
413 ),
414 ),
415 "small",
416 ),
417 ),
418 )
419 self.assertEqual(
420 member_at_offset(type, 0), "big.l or big.d or small.i or small.f"
421 )
422 self.assertEqual(member_at_offset(type, 4), "big.l+0x4 or big.d+0x4")
423
424 def test_type_error(self):
425 prog = mock_program()
426 self.assertRaises(TypeError, member_at_offset, prog.int_type("int", 4, True), 0)
427
428 def test_typedefs(self):
429 prog = mock_program()
430 point_type = prog.typedef_type(
431 "Point",
432 prog.struct_type(
433 None,
434 8,
435 (
436 TypeMember(prog.int_type("int", 4, True), "x", 0),
437 TypeMember(prog.int_type("int", 4, True), "y", 32),
438 ),
439 ),
440 )
441 line_segment_type = prog.typedef_type(
442 "LineSegment",
443 prog.struct_type(
444 None,
445 16,
446 (TypeMember(point_type, "a"), TypeMember(point_type, "b", 64)),
447 ),
448 )
449 self.assertEqual(member_at_offset(line_segment_type, 0), "a.x")
450 self.assertEqual(member_at_offset(line_segment_type, 4), "a.y")
451 self.assertEqual(member_at_offset(line_segment_type, 8), "b.x")
452 self.assertEqual(member_at_offset(line_segment_type, 12), "b.y")
453
454 def test_default_prog(self):
455 self.assertRaises(NoDefaultProgramError, member_at_offset, "struct point", 0)
456
457 types = []
458 prog = mock_program(types=types)
459 types.append(
460 prog.struct_type(
461 "point",
462 8,
463 (
464 TypeMember(prog.int_type("int", 4, True), "x", 0),
465 TypeMember(prog.int_type("int", 4, True), "y", 32),
466 ),
467 )
468 )
469 with with_default_prog(prog):
470 self.assertIdentical(member_at_offset("struct point", 0), "x")
471 self.assertRaises(LookupError, member_at_offset, "struct foo", 0)
472
473
474 class TestTypeofMember(TestCase):
475 def test_simple(self):
476 prog = mock_program()
477 point_type = prog.struct_type(
478 "point",
479 8,
480 (
481 TypeMember(prog.int_type("int", 4, True), "x", 0),
482 TypeMember(prog.int_type("int", 4, True), "y", 32),
483 ),
484 )
485 self.assertIdentical(
486 typeof_member(point_type, "x"), prog.int_type("int", 4, True)
487 )
488
489 def test_default_prog(self):
490 self.assertRaises(NoDefaultProgramError, typeof_member, "struct point", "x")
491
492 types = []
493 prog = mock_program(types=types)
494 types.append(
495 prog.struct_type(
496 "point",
497 8,
498 (
499 TypeMember(prog.int_type("int", 4, True), "x", 0),
500 TypeMember(prog.int_type("int", 4, True), "y", 32),
501 ),
502 )
503 )
504 with with_default_prog(prog):
505 self.assertIdentical(
506 typeof_member("struct point", "x"), prog.int_type("int", 4, True)
507 )
508 self.assertRaises(LookupError, typeof_member, "struct foo", "x")