Line data Source code
1 : use lief_ffi as ffi;
2 :
3 : use crate::{common::FromFFI, Error};
4 :
5 : use crate::to_conv_result;
6 : use std::marker::PhantomData;
7 : use crate::debug_location::DebugLocation;
8 : use crate::dwarf::Scope;
9 : use crate::common::into_optional;
10 : use crate::declare_fwd_iterator;
11 :
12 : pub mod classlike;
13 : pub mod pointer;
14 : pub mod const_ty;
15 : pub mod base;
16 : pub mod array;
17 : pub mod typedef;
18 : pub mod atomic;
19 : pub mod coarray;
20 : pub mod dynamic;
21 : pub mod enum_type;
22 : pub mod file;
23 : pub mod immutable;
24 : pub mod interface;
25 : pub mod pointer_to_member;
26 : pub mod rvalue_ref;
27 : pub mod reference;
28 : pub mod restrict;
29 : pub mod set_type;
30 : pub mod shared;
31 : pub mod string;
32 : pub mod subroutine;
33 : pub mod template_alias;
34 : pub mod thrown;
35 : pub mod volatile;
36 :
37 : #[doc(inline)]
38 : pub use classlike::Structure;
39 :
40 : #[doc(inline)]
41 : pub use classlike::Class;
42 :
43 : #[doc(inline)]
44 : pub use classlike::Union;
45 :
46 : #[doc(inline)]
47 : pub use classlike::Packed;
48 :
49 : #[doc(inline)]
50 : pub use classlike::ClassLike;
51 :
52 : #[doc(inline)]
53 : pub use pointer::Pointer;
54 :
55 : #[doc(inline)]
56 : pub use const_ty::Const;
57 :
58 : #[doc(inline)]
59 : pub use base::Base;
60 :
61 : #[doc(inline)]
62 : pub use array::Array;
63 :
64 : #[doc(inline)]
65 : pub use typedef::Typedef;
66 :
67 : #[doc(inline)]
68 : pub use atomic::Atomic;
69 :
70 : #[doc(inline)]
71 : pub use coarray::Coarray;
72 :
73 : #[doc(inline)]
74 : pub use dynamic::Dynamic;
75 :
76 : #[doc(inline)]
77 : pub use file::File;
78 :
79 : #[doc(inline)]
80 : pub use immutable::Immutable;
81 :
82 : #[doc(inline)]
83 : pub use enum_type::Enum;
84 :
85 : #[doc(inline)]
86 : pub use interface::Interface;
87 :
88 : #[doc(inline)]
89 : pub use pointer_to_member::PointerToMember;
90 :
91 : #[doc(inline)]
92 : pub use rvalue_ref::RValueReference;
93 :
94 : #[doc(inline)]
95 : pub use reference::Reference;
96 :
97 : #[doc(inline)]
98 : pub use restrict::Restrict;
99 :
100 : #[doc(inline)]
101 : pub use set_type::SetTy;
102 :
103 : #[doc(inline)]
104 : pub use shared::Shared;
105 :
106 : #[doc(inline)]
107 : pub use string::StringTy;
108 :
109 : #[doc(inline)]
110 : pub use subroutine::Subroutine;
111 :
112 : #[doc(inline)]
113 : pub use template_alias::TemplateAlias;
114 :
115 : #[doc(inline)]
116 : pub use thrown::Thrown;
117 :
118 : #[doc(inline)]
119 : pub use volatile::Volatile;
120 :
121 : /// This class represents a DWARF Type which includes:
122 : ///
123 : /// - `DW_TAG_array_type`
124 : /// - `DW_TAG_atomic_type`
125 : /// - `DW_TAG_base_type`
126 : /// - `DW_TAG_class_type`
127 : /// - `DW_TAG_coarray_type`
128 : /// - `DW_TAG_const_type`
129 : /// - `DW_TAG_dynamic_type`
130 : /// - `DW_TAG_enumeration_type`
131 : /// - `DW_TAG_file_type`
132 : /// - `DW_TAG_immutable_type`
133 : /// - `DW_TAG_interface_type`
134 : /// - `DW_TAG_packed_type`
135 : /// - `DW_TAG_pointer_type`
136 : /// - `DW_TAG_ptr_to_member_type`
137 : /// - `DW_TAG_reference_type`
138 : /// - `DW_TAG_restrict_type`
139 : /// - `DW_TAG_rvalue_reference_type`
140 : /// - `DW_TAG_set_type`
141 : /// - `DW_TAG_shared_type`
142 : /// - `DW_TAG_string_type`
143 : /// - `DW_TAG_structure_type`
144 : /// - `DW_TAG_subroutine_type`
145 : /// - `DW_TAG_template_alias`
146 : /// - `DW_TAG_thrown_type`
147 : /// - `DW_TAG_typedef`
148 : /// - `DW_TAG_union_type`
149 : /// - `DW_TAG_unspecified_type`
150 : /// - `DW_TAG_volatile_type`d_type`
151 : pub enum Type<'a> {
152 : /// Interface over `DW_TAG_structure_type`
153 : Structure(Structure<'a>),
154 :
155 : /// Interface over `DW_TAG_class_type`
156 : Class(Class<'a>),
157 :
158 : /// Interface over `DW_TAG_union_type`
159 : Union(Union<'a>),
160 :
161 : /// Interface over `DW_TAG_packed_type`
162 : Packed(Packed<'a>),
163 :
164 : /// Interface over `DW_TAG_pointer_type`
165 : Pointer(Pointer<'a>),
166 :
167 : /// Interface over `DW_TAG_const_type`
168 : Const(Const<'a>),
169 :
170 : /// Interface over `DW_TAG_base_type`
171 : Base(Base<'a>),
172 :
173 : /// Interface over `DW_TAG_array_type`
174 : Array(Array<'a>),
175 :
176 : /// Interface over `DW_TAG_typedef`
177 : Typedef(Typedef<'a>),
178 :
179 : /// Interface over `DW_TAG_atomic_type`
180 : Atomic(Atomic<'a>),
181 :
182 : /// Interface over `DW_TAG_coarray_type`
183 : Coarray(Coarray<'a>),
184 :
185 : /// Interface over `DW_TAG_dynamic_type`
186 : Dynamic(Dynamic<'a>),
187 :
188 : /// Interface over `DW_TAG_enumeration_type`
189 : Enum(Enum<'a>),
190 :
191 : /// Interface over `DW_TAG_file_type`
192 : File(File<'a>),
193 :
194 : /// Interface over `DW_TAG_immutable_type`
195 : Immutable(Immutable<'a>),
196 :
197 : /// Interface over `DW_TAG_interface_type`
198 : Interface(Interface<'a>),
199 :
200 : /// Interface over `DW_TAG_ptr_to_member_type`
201 : PointerToMember(PointerToMember<'a>),
202 :
203 : /// Interface over `DW_TAG_rvalue_reference_type`
204 : RValueReference(RValueReference<'a>),
205 :
206 : /// Interface over `DW_TAG_reference_type`
207 : Reference(Reference<'a>),
208 :
209 : /// Interface over `DW_TADW_TAG_restrict_type`
210 : Restrict(Restrict<'a>),
211 :
212 : /// Interface over `DW_TAG_set_type`
213 : SetTy(SetTy<'a>),
214 :
215 : /// Interface over `DW_TAG_shared_type`
216 : Shared(Shared<'a>),
217 :
218 : /// Interface over `DW_TAG_string_type`
219 : StringTy(StringTy<'a>),
220 :
221 : /// Interface over `DW_TAG_subroutine_type`
222 : Subroutine(Subroutine<'a>),
223 :
224 : /// Interface over `DW_TAG_template_alias`
225 : TemplateAlias(TemplateAlias<'a>),
226 :
227 : /// Interface over `DW_TAG_thrown_type`
228 : Thrown(Thrown<'a>),
229 :
230 : /// Interface over `DW_TAG_volatile_type`
231 : Volatile(Volatile<'a>),
232 :
233 : /// Generic type (fallback value)
234 : Generic(Generic<'a>),
235 : }
236 :
237 : impl FromFFI<ffi::DWARF_Type> for Type<'_> {
238 0 : fn from_ffi(ffi_entry: cxx::UniquePtr<ffi::DWARF_Type>) -> Self {
239 0 : unsafe {
240 0 : let type_ref = ffi_entry.as_ref().unwrap();
241 0 :
242 0 : if ffi::DWARF_types_Structure::classof(type_ref) {
243 0 : let raw = {
244 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
245 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Structure>;
246 0 : std::mem::transmute::<From, To>(ffi_entry)
247 0 : };
248 0 : Type::Structure(Structure::from_ffi(raw))
249 0 : } else if ffi::DWARF_types_Class::classof(type_ref) {
250 0 : let raw = {
251 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
252 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Class>;
253 0 : std::mem::transmute::<From, To>(ffi_entry)
254 0 : };
255 0 : Type::Class(Class::from_ffi(raw))
256 0 : } else if ffi::DWARF_types_Union::classof(type_ref) {
257 0 : let raw = {
258 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
259 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Union>;
260 0 : std::mem::transmute::<From, To>(ffi_entry)
261 0 : };
262 0 : Type::Union(Union::from_ffi(raw))
263 0 : } else if ffi::DWARF_types_Packed::classof(type_ref) {
264 0 : let raw = {
265 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
266 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Packed>;
267 0 : std::mem::transmute::<From, To>(ffi_entry)
268 0 : };
269 0 : Type::Packed(Packed::from_ffi(raw))
270 0 : } else if ffi::DWARF_types_Pointer::classof(type_ref) {
271 0 : let raw = {
272 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
273 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Pointer>;
274 0 : std::mem::transmute::<From, To>(ffi_entry)
275 0 : };
276 0 : Type::Pointer(Pointer::from_ffi(raw))
277 0 : } else if ffi::DWARF_types_Const::classof(type_ref) {
278 0 : let raw = {
279 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
280 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Const>;
281 0 : std::mem::transmute::<From, To>(ffi_entry)
282 0 : };
283 0 : Type::Const(Const::from_ffi(raw))
284 0 : } else if ffi::DWARF_types_Base::classof(type_ref) {
285 0 : let raw = {
286 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
287 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Base>;
288 0 : std::mem::transmute::<From, To>(ffi_entry)
289 0 : };
290 0 : Type::Base(Base::from_ffi(raw))
291 0 : } else if ffi::DWARF_types_Array::classof(type_ref) {
292 0 : let raw = {
293 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
294 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Array>;
295 0 : std::mem::transmute::<From, To>(ffi_entry)
296 0 : };
297 0 : Type::Array(Array::from_ffi(raw))
298 0 : } else if ffi::DWARF_types_Typedef::classof(type_ref) {
299 0 : let raw = {
300 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
301 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Typedef>;
302 0 : std::mem::transmute::<From, To>(ffi_entry)
303 0 : };
304 0 : Type::Typedef(Typedef::from_ffi(raw))
305 0 : } else if ffi::DWARF_types_Atomic::classof(type_ref) {
306 0 : let raw = {
307 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
308 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Atomic>;
309 0 : std::mem::transmute::<From, To>(ffi_entry)
310 0 : };
311 0 : Type::Atomic(Atomic::from_ffi(raw))
312 0 : } else if ffi::DWARF_types_Coarray::classof(type_ref) {
313 0 : let raw = {
314 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
315 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Coarray>;
316 0 : std::mem::transmute::<From, To>(ffi_entry)
317 0 : };
318 0 : Type::Coarray(Coarray::from_ffi(raw))
319 0 : } else if ffi::DWARF_types_Dynamic::classof(type_ref) {
320 0 : let raw = {
321 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
322 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Dynamic>;
323 0 : std::mem::transmute::<From, To>(ffi_entry)
324 0 : };
325 0 : Type::Dynamic(Dynamic::from_ffi(raw))
326 0 : } else if ffi::DWARF_types_Enum::classof(type_ref) {
327 0 : let raw = {
328 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
329 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Enum>;
330 0 : std::mem::transmute::<From, To>(ffi_entry)
331 0 : };
332 0 : Type::Enum(Enum::from_ffi(raw))
333 0 : } else if ffi::DWARF_types_File::classof(type_ref) {
334 0 : let raw = {
335 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
336 0 : type To = cxx::UniquePtr<ffi::DWARF_types_File>;
337 0 : std::mem::transmute::<From, To>(ffi_entry)
338 0 : };
339 0 : Type::File(File::from_ffi(raw))
340 0 : } else if ffi::DWARF_types_Immutable::classof(type_ref) {
341 0 : let raw = {
342 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
343 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Immutable>;
344 0 : std::mem::transmute::<From, To>(ffi_entry)
345 0 : };
346 0 : Type::Immutable(Immutable::from_ffi(raw))
347 0 : } else if ffi::DWARF_types_Interface::classof(type_ref) {
348 0 : let raw = {
349 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
350 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Interface>;
351 0 : std::mem::transmute::<From, To>(ffi_entry)
352 0 : };
353 0 : Type::Interface(Interface::from_ffi(raw))
354 0 : } else if ffi::DWARF_types_PointerToMember::classof(type_ref) {
355 0 : let raw = {
356 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
357 0 : type To = cxx::UniquePtr<ffi::DWARF_types_PointerToMember>;
358 0 : std::mem::transmute::<From, To>(ffi_entry)
359 0 : };
360 0 : Type::PointerToMember(PointerToMember::from_ffi(raw))
361 0 : } else if ffi::DWARF_types_RValueReference::classof(type_ref) {
362 0 : let raw = {
363 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
364 0 : type To = cxx::UniquePtr<ffi::DWARF_types_RValueReference>;
365 0 : std::mem::transmute::<From, To>(ffi_entry)
366 0 : };
367 0 : Type::RValueReference(RValueReference::from_ffi(raw))
368 0 : } else if ffi::DWARF_types_Reference::classof(type_ref) {
369 0 : let raw = {
370 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
371 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Reference>;
372 0 : std::mem::transmute::<From, To>(ffi_entry)
373 0 : };
374 0 : Type::Reference(Reference::from_ffi(raw))
375 0 : } else if ffi::DWARF_types_Restrict::classof(type_ref) {
376 0 : let raw = {
377 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
378 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Restrict>;
379 0 : std::mem::transmute::<From, To>(ffi_entry)
380 0 : };
381 0 : Type::Restrict(Restrict::from_ffi(raw))
382 0 : } else if ffi::DWARF_types_SetTy::classof(type_ref) {
383 0 : let raw = {
384 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
385 0 : type To = cxx::UniquePtr<ffi::DWARF_types_SetTy>;
386 0 : std::mem::transmute::<From, To>(ffi_entry)
387 0 : };
388 0 : Type::SetTy(SetTy::from_ffi(raw))
389 0 : } else if ffi::DWARF_types_Shared::classof(type_ref) {
390 0 : let raw = {
391 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
392 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Shared>;
393 0 : std::mem::transmute::<From, To>(ffi_entry)
394 0 : };
395 0 : Type::Shared(Shared::from_ffi(raw))
396 0 : } else if ffi::DWARF_types_StringTy::classof(type_ref) {
397 0 : let raw = {
398 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
399 0 : type To = cxx::UniquePtr<ffi::DWARF_types_StringTy>;
400 0 : std::mem::transmute::<From, To>(ffi_entry)
401 0 : };
402 0 : Type::StringTy(StringTy::from_ffi(raw))
403 0 : } else if ffi::DWARF_types_Subroutine::classof(type_ref) {
404 0 : let raw = {
405 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
406 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Subroutine>;
407 0 : std::mem::transmute::<From, To>(ffi_entry)
408 0 : };
409 0 : Type::Subroutine(Subroutine::from_ffi(raw))
410 0 : } else if ffi::DWARF_types_TemplateAlias::classof(type_ref) {
411 0 : let raw = {
412 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
413 0 : type To = cxx::UniquePtr<ffi::DWARF_types_TemplateAlias>;
414 0 : std::mem::transmute::<From, To>(ffi_entry)
415 0 : };
416 0 : Type::TemplateAlias(TemplateAlias::from_ffi(raw))
417 0 : } else if ffi::DWARF_types_Thrown::classof(type_ref) {
418 0 : let raw = {
419 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
420 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Thrown>;
421 0 : std::mem::transmute::<From, To>(ffi_entry)
422 0 : };
423 0 : Type::Thrown(Thrown::from_ffi(raw))
424 0 : } else if ffi::DWARF_types_Volatile::classof(type_ref) {
425 0 : let raw = {
426 0 : type From = cxx::UniquePtr<ffi::DWARF_Type>;
427 0 : type To = cxx::UniquePtr<ffi::DWARF_types_Volatile>;
428 0 : std::mem::transmute::<From, To>(ffi_entry)
429 0 : };
430 0 : Type::Volatile(Volatile::from_ffi(raw))
431 : } else {
432 0 : Type::Generic(Generic::from_ffi(ffi_entry))
433 : }
434 : }
435 0 : }
436 : }
437 :
438 : /// Generic structure for types that do not required a dedicated interface
439 : pub struct Generic<'a> {
440 : ptr: cxx::UniquePtr<ffi::DWARF_Type>,
441 : _owner: PhantomData<&'a ()>,
442 : }
443 :
444 : impl FromFFI<ffi::DWARF_Type> for Generic<'_> {
445 0 : fn from_ffi(cmd: cxx::UniquePtr<ffi::DWARF_Type>) -> Self {
446 0 : Self {
447 0 : ptr: cmd,
448 0 : _owner: PhantomData,
449 0 : }
450 0 : }
451 : }
452 :
453 : /// Generic trait shared by all DWARF types
454 : pub trait DwarfType {
455 : #[doc(hidden)]
456 : fn get_base(&self) -> &ffi::DWARF_Type;
457 :
458 : /// Return the type's name using either `DW_AT_name` or `DW_AT_picture_string` (if any)
459 0 : fn name(&self) -> Result<String, Error> {
460 0 : to_conv_result!(
461 0 : ffi::DWARF_Type::name,
462 0 : self.get_base(),
463 0 : |e: cxx::UniquePtr<cxx::String>| { e.to_string() }
464 : );
465 0 : }
466 :
467 : /// Return the size of the type or an error if it can't be computed.
468 : ///
469 : /// This size should match the equivalent of `sizeof(Type)`.
470 0 : fn size(&self) -> Result<u64, Error> {
471 0 : to_conv_result!(
472 0 : ffi::DWARF_Type::size,
473 0 : self.get_base(),
474 0 : |e| e
475 : );
476 0 : }
477 :
478 : /// Return the debug location where this type is defined.
479 0 : fn location(&self) -> DebugLocation {
480 0 : DebugLocation::from_ffi(self.get_base().location())
481 0 : }
482 :
483 : /// Whether this type is a `DW_TAG_unspecified_type`.
484 0 : fn is_unspecified(&self) -> bool {
485 0 : self.get_base().is_unspecified()
486 0 : }
487 :
488 : /// The scope in which this function is defined
489 0 : fn scope(&self) -> Option<Scope> {
490 0 : into_optional(self.get_base().scope())
491 0 : }
492 : }
493 :
494 : impl DwarfType for Generic<'_> {
495 0 : fn get_base(&self) -> &ffi::DWARF_Type {
496 0 : self.ptr.as_ref().unwrap()
497 0 : }
498 : }
499 :
500 : impl DwarfType for Type<'_> {
501 0 : fn get_base(&self) -> &ffi::DWARF_Type {
502 0 : match &self {
503 0 : Type::Structure(s) => {
504 0 : s.get_base()
505 : }
506 0 : Type::Class(s) => {
507 0 : s.get_base()
508 : }
509 0 : Type::Union(s) => {
510 0 : s.get_base()
511 : }
512 0 : Type::Packed(s) => {
513 0 : s.get_base()
514 : }
515 0 : Type::Pointer(s) => {
516 0 : s.get_base()
517 : }
518 0 : Type::Const(s) => {
519 0 : s.get_base()
520 : }
521 0 : Type::Base(s) => {
522 0 : s.get_base()
523 : }
524 0 : Type::Array(s) => {
525 0 : s.get_base()
526 : }
527 0 : Type::Typedef(s) => {
528 0 : s.get_base()
529 : }
530 0 : Type::Atomic(s) => {
531 0 : s.get_base()
532 : }
533 0 : Type::Coarray(s) => {
534 0 : s.get_base()
535 : }
536 0 : Type::Dynamic(s) => {
537 0 : s.get_base()
538 : }
539 0 : Type::Enum(s) => {
540 0 : s.get_base()
541 : }
542 0 : Type::File(s) => {
543 0 : s.get_base()
544 : }
545 0 : Type::Immutable(s) => {
546 0 : s.get_base()
547 : }
548 0 : Type::Interface(s) => {
549 0 : s.get_base()
550 : }
551 0 : Type::PointerToMember(s) => {
552 0 : s.get_base()
553 : }
554 0 : Type::RValueReference(s) => {
555 0 : s.get_base()
556 : }
557 0 : Type::Reference(s) => {
558 0 : s.get_base()
559 : }
560 0 : Type::Restrict(s) => {
561 0 : s.get_base()
562 : }
563 0 : Type::SetTy(s) => {
564 0 : s.get_base()
565 : }
566 0 : Type::Shared(s) => {
567 0 : s.get_base()
568 : }
569 0 : Type::StringTy(s) => {
570 0 : s.get_base()
571 : }
572 0 : Type::Subroutine(s) => {
573 0 : s.get_base()
574 : }
575 0 : Type::TemplateAlias(s) => {
576 0 : s.get_base()
577 : }
578 0 : Type::Thrown(s) => {
579 0 : s.get_base()
580 : }
581 0 : Type::Volatile(s) => {
582 0 : s.get_base()
583 : }
584 0 : Type::Generic(s) => {
585 0 : s.get_base()
586 : }
587 : }
588 0 : }
589 : }
590 :
591 0 : declare_fwd_iterator!(
592 0 : Types,
593 0 : Type<'a>,
594 0 : ffi::DWARF_Type,
595 0 : ffi::DWARF_CompilationUnit,
596 0 : ffi::DWARF_CompilationUnit_it_types
597 0 : );
598 :
|
