3 // GDB changed the way that it formatted Foreign types
4 // min-gdb-version: 9.2
8 // === GDB TESTS ===================================================================================
13 // gdb-command:whatis simple_struct
14 // gdb-check:type = type_names::Struct1
16 // gdb-command:whatis generic_struct1
17 // gdb-check:type = type_names::GenericStruct<type_names::mod1::Struct2, type_names::mod1::mod2::Struct3>
19 // gdb-command:whatis generic_struct2
20 // gdb-check:type = type_names::GenericStruct<type_names::Struct1, extern "fastcall" fn(isize) -> usize>
22 // gdb-command:whatis mod_struct
23 // gdb-check:type = type_names::mod1::Struct2
26 // gdb-command:whatis simple_enum_1
27 // gdb-check:type = type_names::Enum1
29 // gdb-command:whatis simple_enum_2
30 // gdb-check:type = type_names::Enum1
32 // gdb-command:whatis simple_enum_3
33 // gdb-check:type = type_names::mod1::Enum2
35 // gdb-command:whatis generic_enum_1
36 // gdb-check:type = type_names::mod1::mod2::Enum3
38 // gdb-command:whatis generic_enum_2
39 // gdb-check:type = type_names::mod1::mod2::Enum3
42 // gdb-command:whatis tuple1
43 // gdb-check:type = (u32, type_names::Struct1, type_names::mod1::mod2::Enum3<type_names::mod1::Struct2>)
45 // gdb-command:whatis tuple2
46 // gdb-check:type = ((type_names::Struct1, type_names::mod1::mod2::Struct3), type_names::mod1::Enum2, char)
49 // gdb-command:whatis box1
50 // gdb-check:type = (alloc::boxed::Box<f32, alloc::alloc::Global>, i32)
52 // gdb-command:whatis box2
53 // gdb-check:type = (alloc::boxed::Box<type_names::mod1::mod2::Enum3<f32>, alloc::alloc::Global>, i32)
56 // gdb-command:whatis ref1
57 // gdb-check:type = (&type_names::Struct1, i32)
59 // gdb-command:whatis ref2
60 // gdb-check:type = (&type_names::GenericStruct<char, type_names::Struct1>, i32)
62 // gdb-command:whatis mut_ref1
63 // gdb-check:type = (&mut type_names::Struct1, i32)
65 // gdb-command:whatis mut_ref2
66 // gdb-check:type = (&mut type_names::GenericStruct<type_names::mod1::Enum2, f64>, i32)
69 // gdb-command:whatis mut_ptr1
70 // gdb-check:type = (*mut type_names::Struct1, isize)
72 // gdb-command:whatis mut_ptr2
73 // gdb-check:type = (*mut isize, isize)
75 // gdb-command:whatis mut_ptr3
76 // gdb-check:type = (*mut type_names::mod1::mod2::Enum3<type_names::Struct1>, isize)
78 // gdb-command:whatis const_ptr1
79 // gdb-check:type = (*const type_names::Struct1, isize)
81 // gdb-command:whatis const_ptr2
82 // gdb-check:type = (*const isize, isize)
84 // gdb-command:whatis const_ptr3
85 // gdb-check:type = (*const type_names::mod1::mod2::Enum3<type_names::Struct1>, isize)
88 // gdb-command:whatis fixed_size_vec1
89 // gdb-check:type = ([type_names::Struct1; 3], i16)
91 // gdb-command:whatis fixed_size_vec2
92 // gdb-check:type = ([usize; 3], i16)
94 // gdb-command:whatis slice1
95 // gdb-check:type = &[usize]
97 // gdb-command:whatis slice2
98 // gdb-check:type = &[type_names::mod1::Enum2]
101 // gdb-command:whatis box_trait
102 // gdb-check:type = alloc::boxed::Box<dyn type_names::Trait1, alloc::alloc::Global>
104 // gdb-command:whatis ref_trait
105 // gdb-check:type = &dyn type_names::Trait1
107 // gdb-command:whatis mut_ref_trait
108 // gdb-check:type = &mut dyn type_names::Trait1
110 // gdb-command:whatis generic_box_trait
111 // gdb-check:type = alloc::boxed::Box<dyn type_names::Trait2<i32, type_names::mod1::Struct2>, alloc::alloc::Global>
113 // gdb-command:whatis generic_ref_trait
114 // gdb-check:type = &dyn type_names::Trait2<type_names::Struct1, type_names::Struct1>
116 // gdb-command:whatis generic_mut_ref_trait
117 // gdb-check:type = &mut dyn type_names::Trait2<type_names::mod1::mod2::Struct3, type_names::GenericStruct<usize, isize>>
119 // gdb-command:whatis no_principal_trait
120 // gdb-check:type = alloc::boxed::Box<dyn core::marker::Send + core::marker::Sync, alloc::alloc::Global>
123 // gdb-command:whatis rust_fn
124 // gdb-check:type = (fn(core::option::Option<isize>, core::option::Option<&type_names::mod1::Struct2>), usize)
126 // gdb-command:whatis extern_c_fn
127 // gdb-check:type = (extern "C" fn(isize), usize)
129 // gdb-command:whatis unsafe_fn
130 // gdb-check:type = (unsafe fn(core::result::Result<char, f64>), usize)
132 // gdb-command:whatis rust_fn_with_return_value
133 // gdb-check:type = (fn(f64) -> usize, usize)
135 // gdb-command:whatis extern_c_fn_with_return_value
136 // gdb-check:type = (extern "C" fn() -> type_names::Struct1, usize)
138 // gdb-command:whatis unsafe_fn_with_return_value
139 // gdb-check:type = (unsafe fn(type_names::GenericStruct<u16, u8>) -> type_names::mod1::Struct2, usize)
141 // gdb-command:whatis generic_function_int
142 // gdb-check:type = (fn(isize) -> isize, usize)
144 // gdb-command:whatis generic_function_struct3
145 // gdb-check:type = (fn(type_names::mod1::mod2::Struct3) -> type_names::mod1::mod2::Struct3, usize)
147 // gdb-command:whatis variadic_function
148 // gdb-check:type = (unsafe extern "C" fn(*const u8, ...) -> isize, usize)
151 // gdb-command:whatis closure1
152 // gdb-check:type = (type_names::main::{closure#0}, usize)
154 // gdb-command:whatis closure2
155 // gdb-check:type = (type_names::main::{closure#1}, usize)
158 // gdb-command:whatis foreign1
159 // gdb-check:type = *mut ForeignType1
161 // gdb-command:whatis foreign2
162 // gdb-check:type = *mut ForeignType2
164 // === CDB TESTS ==================================================================================
169 // 0-sized structs appear to be optimized away in some cases, so only check the structs that do
171 // cdb-command:dv /t *_struct
172 // cdb-check:struct type_names::GenericStruct<enum$<type_names::mod1::Enum2>, f64> mut_generic_struct = [...]
175 // cdb-command:dv /t *_enum_*
176 // cdb-check:union enum$<type_names::Enum1> simple_enum_1 = [...]
177 // cdb-check:union enum$<type_names::Enum1> simple_enum_2 = [...]
178 // cdb-check:type_names::mod1::Enum2 simple_enum_3 = [...]
179 // cdb-check:type_names::mod1::mod2::Enum3 generic_enum_1 = [...]
180 // cdb-check:type_names::mod1::mod2::Enum3 generic_enum_2 = [...]
183 // cdb-command:dv /t tuple*
184 // cdb-check:struct tuple$<u32,type_names::Struct1,enum$<type_names::mod1::mod2::Enum3<type_names::mod1::Struct2> > > tuple1 = [...]
185 // cdb-check:struct tuple$<tuple$<type_names::Struct1,type_names::mod1::mod2::Struct3>,enum$<type_names::mod1::Enum2>,char> tuple2 = [...]
188 // cdb-command:dv /t box*
189 // cdb-check:struct tuple$<alloc::boxed::Box<f32, alloc::alloc::Global>,i32> box1 = [...]
190 // cdb-check:struct tuple$<alloc::boxed::Box<enum$<type_names::mod1::mod2::Enum3<f32> >, alloc::alloc::Global>,i32> box2 = [...]
193 // cdb-command:dv /t *ref*
194 // cdb-check:struct tuple$<ref$<type_names::Struct1>,i32> ref1 = [...]
195 // cdb-check:struct tuple$<ref$<type_names::GenericStruct<char, type_names::Struct1> >,i32> ref2 = [...]
196 // cdb-check:struct tuple$<ref_mut$<type_names::Struct1>,i32> mut_ref1 = [...]
197 // cdb-check:struct tuple$<ref_mut$<type_names::GenericStruct<enum$<type_names::mod1::Enum2>, f64> >,i32> mut_ref2 = [...]
200 // cdb-command:dv /t *_ptr*
201 // cdb-check:struct tuple$<ptr_mut$<type_names::Struct1>,isize> mut_ptr1 = [...]
202 // cdb-check:struct tuple$<ptr_mut$<isize>,isize> mut_ptr2 = [...]
203 // cdb-check:struct tuple$<ptr_mut$<enum$<type_names::mod1::mod2::Enum3<type_names::Struct1> > >,isize> mut_ptr3 = [...]
204 // cdb-check:struct tuple$<ptr_const$<type_names::Struct1>,isize> const_ptr1 = [...]
205 // cdb-check:struct tuple$<ptr_const$<isize>,isize> const_ptr2 = [...]
206 // cdb-check:struct tuple$<ptr_const$<enum$<type_names::mod1::mod2::Enum3<type_names::Struct1> > >,isize> const_ptr3 = [...]
209 // cdb-command:dv /t *vec*
210 // cdb-check:struct tuple$<array$<type_names::Struct1,3>,i16> fixed_size_vec1 = [...]
211 // cdb-check:struct tuple$<array$<usize,3>,i16> fixed_size_vec2 = [...]
212 // cdb-check:struct alloc::vec::Vec<usize, alloc::alloc::Global> vec1 = [...]
213 // cdb-check:struct alloc::vec::Vec<enum$<type_names::mod1::Enum2>, alloc::alloc::Global> vec2 = [...]
214 // cdb-command:dv /t slice*
215 // cdb-check:struct slice$<usize> slice1 = [...]
216 // cdb-check:struct slice$<enum$<type_names::mod1::Enum2> > slice2 = [...]
219 // cdb-command:dv /t *_trait
220 // cdb-check:struct ref_mut$<dyn$<type_names::Trait2<type_names::mod1::mod2::Struct3, type_names::GenericStruct<usize, isize> > > > generic_mut_ref_trait = [...]
221 // cdb-check:struct ref$<dyn$<type_names::Trait2<type_names::Struct1, type_names::Struct1> > > generic_ref_trait = [...]
222 // cdb-check:struct alloc::boxed::Box<dyn$<type_names::Trait2<i32, type_names::mod1::Struct2> >, alloc::alloc::Global> generic_box_trait = [...]
223 // cdb-check:struct alloc::boxed::Box<dyn$<type_names::Trait1>, alloc::alloc::Global> box_trait = [...]
224 // cdb-check:struct ref$<dyn$<type_names::Trait1> > ref_trait = [...]
225 // cdb-check:struct ref_mut$<dyn$<type_names::Trait1> > mut_ref_trait = [...]
226 // cdb-check:struct alloc::boxed::Box<dyn$<core::marker::Send, core::marker::Sync>, alloc::alloc::Global> no_principal_trait = [...]
227 // cdb-check:struct ref$<dyn$<type_names::Trait3> > has_associated_type_trait = struct ref$<dyn$<type_names::Trait3> >
230 // cdb-command:dv /t *_fn*
231 // cdb-check:struct tuple$<type_names::mod1::Struct2 (*)(type_names::GenericStruct<u16, u8>),usize> unsafe_fn_with_return_value = [...]
232 // cdb-check:struct tuple$<type_names::Struct1 (*)(),usize> extern_c_fn_with_return_value = [...]
233 // cdb-check:struct tuple$<usize (*)(f64),usize> rust_fn_with_return_value = [...]
234 // cdb-check:struct tuple$<void (*)(enum$<core::result::Result<char, f64> >),usize> unsafe_fn = [...]
235 // cdb-check:struct tuple$<void (*)(isize),usize> extern_c_fn = [...]
236 // cdb-check:struct tuple$<void (*)(enum$<core::option::Option<isize> >, enum$<core::option::Option<ref$<type_names::mod1::Struct2> >, 1, [...], Some>),usize> rust_fn = [...]
237 // cdb-command:dv /t *_function*
238 // cdb-check:struct tuple$<isize (*)(ptr_const$<u8>, ...),usize> variadic_function = [...]
239 // cdb-check:struct tuple$<type_names::mod1::mod2::Struct3 (*)(type_names::mod1::mod2::Struct3),usize> generic_function_struct3 = [...]
240 // cdb-check:struct tuple$<isize (*)(isize),usize> generic_function_int = [...]
241 // cdb-command:dx Debugger.State.Scripts.@"type-names.cdb".Contents.getFunctionDetails("rust_fn")
242 // cdb-check:Return Type: void
243 // cdb-check:Parameter Types: enum$<core::option::Option<isize> >,enum$<core::option::Option<ref$<type_names::mod1::Struct2> >, 1, [...], Some>
244 // cdb-command:dx Debugger.State.Scripts.@"type-names.cdb".Contents.getFunctionDetails("rust_fn_with_return_value")
245 // cdb-check:Return Type: usize
246 // cdb-check:Parameter Types: f64
247 // cdb-command:dx Debugger.State.Scripts.@"type-names.cdb".Contents.getFunctionDetails("extern_c_fn_with_return_value")
248 // cdb-check:Return Type: type_names::Struct1
249 // cdb-check:Parameter Types:
252 // cdb-command:dv /t closure*
253 // cdb-check:struct tuple$<type_names::main::closure$1,usize> closure2 = [...]
254 // cdb-check:struct tuple$<type_names::main::closure$0,usize> closure1 = [...]
257 // cdb-command:dv /t foreign*
258 // cdb-check:struct ForeignType2 * foreign2 = [...]
259 // cdb-check:struct ForeignType1 * foreign1 = [...]
261 #![feature(box_syntax)]
262 #![allow(unused_variables)]
263 #![feature(omit_gdb_pretty_printer_section)]
264 #![omit_gdb_pretty_printer_section]
265 #![feature(extern_types)]
267 use self::Enum1::{Variant1, Variant2};
268 use std::marker::PhantomData;
272 struct GenericStruct<T1, T2>(PhantomData<(T1, T2)>);
279 extern { type ForeignType1; }
282 pub use self::Enum2::{Variant1, Variant2};
287 Variant2(super::Struct1),
291 pub use self::Enum3::{Variant1, Variant2};
300 extern { pub type ForeignType2; }
306 trait Trait2<T1, T2> {
307 fn dummy(&self, _: T1, _: T2) {}
314 impl Trait1 for isize {}
315 impl<T1, T2> Trait2<T1, T2> for isize {}
316 impl Trait3 for isize {
317 type AssocType = isize;
320 fn rust_fn(_: Option<isize>, _: Option<&mod1::Struct2>) {}
321 extern "C" fn extern_c_fn(_: isize) {}
322 unsafe fn unsafe_fn(_: Result<char, f64>) {}
324 fn rust_fn_with_return_value(_: f64) -> usize {
327 extern "C" fn extern_c_fn_with_return_value() -> Struct1 {
330 unsafe fn unsafe_fn_with_return_value(_: GenericStruct<u16, u8>) -> mod1::Struct2 {
334 fn generic_function<T>(x: T) -> T {
338 #[allow(improper_ctypes)]
340 fn printf(_: *const u8, ...) -> isize;
343 // In many of the cases below, the type that is actually under test is wrapped
344 // in a tuple, e.g., Box<T>, references, raw pointers, fixed-size vectors, ...
345 // This is because GDB will not print the type name from DWARF debuginfo for
346 // some kinds of types (pointers, arrays, functions, ...)
347 // Since tuples are structs as far as GDB is concerned, their name will be
348 // printed correctly, so the tests below just construct a tuple type that will
349 // then *contain* the type name that we want to see.
352 let simple_struct = Struct1;
353 let generic_struct1: GenericStruct<mod1::Struct2, mod1::mod2::Struct3> =
354 GenericStruct(PhantomData);
355 let generic_struct2: GenericStruct<Struct1, extern "fastcall" fn(isize) -> usize> =
356 GenericStruct(PhantomData);
357 let mod_struct = mod1::Struct2;
360 let simple_enum_1 = Variant1;
361 let simple_enum_2 = Variant2(0);
362 let simple_enum_3 = mod1::Variant2(Struct1);
364 let generic_enum_1: mod1::mod2::Enum3<mod1::Struct2> = mod1::mod2::Variant1;
365 let generic_enum_2 = mod1::mod2::Variant2(Struct1);
368 let tuple1 = (8u32, Struct1, mod1::mod2::Variant2(mod1::Struct2));
369 let tuple2 = ((Struct1, mod1::mod2::Struct3), mod1::Variant1, 'x');
372 let box1 = (box 1f32, 0i32);
373 let box2 = (box mod1::mod2::Variant2(1f32), 0i32);
376 let ref1 = (&Struct1, 0i32);
377 let ref2 = (&GenericStruct::<char, Struct1>(PhantomData), 0i32);
379 let mut mut_struct1 = Struct1;
380 let mut mut_generic_struct = GenericStruct::<mod1::Enum2, f64>(PhantomData);
381 let mut_ref1 = (&mut mut_struct1, 0i32);
382 let mut_ref2 = (&mut mut_generic_struct, 0i32);
385 let mut_ptr1: (*mut Struct1, isize) = (ptr::null_mut(), 0);
386 let mut_ptr2: (*mut isize, isize) = (ptr::null_mut(), 0);
387 let mut_ptr3: (*mut mod1::mod2::Enum3<Struct1>, isize) = (ptr::null_mut(), 0);
389 let const_ptr1: (*const Struct1, isize) = (ptr::null(), 0);
390 let const_ptr2: (*const isize, isize) = (ptr::null(), 0);
391 let const_ptr3: (*const mod1::mod2::Enum3<Struct1>, isize) = (ptr::null(), 0);
394 let fixed_size_vec1 = ([Struct1, Struct1, Struct1], 0i16);
395 let fixed_size_vec2 = ([0_usize, 1, 2], 0i16);
397 let vec1 = vec![0_usize, 2, 3];
399 let vec2 = vec![mod1::Variant2(Struct1)];
403 let box_trait = (box 0_isize) as Box<dyn Trait1>;
404 let ref_trait = &0_isize as &dyn Trait1;
405 let mut mut_int1 = 0_isize;
406 let mut_ref_trait = (&mut mut_int1) as &mut dyn Trait1;
407 let no_principal_trait = (box 0_isize) as Box<dyn Send + Sync>;
408 let has_associated_type_trait = &0_isize as &dyn Trait3<AssocType = isize>;
410 let generic_box_trait = (box 0_isize) as Box<dyn Trait2<i32, mod1::Struct2>>;
411 let generic_ref_trait = (&0_isize) as &dyn Trait2<Struct1, Struct1>;
413 let mut generic_mut_ref_trait_impl = 0_isize;
414 let generic_mut_ref_trait = (&mut generic_mut_ref_trait_impl)
415 as &mut dyn Trait2<mod1::mod2::Struct3, GenericStruct<usize, isize>>;
418 let rust_fn = (rust_fn, 0_usize);
419 let extern_c_fn = (extern_c_fn, 0_usize);
420 let unsafe_fn = (unsafe_fn, 0_usize);
422 let rust_fn_with_return_value = (rust_fn_with_return_value, 0_usize);
423 let extern_c_fn_with_return_value = (extern_c_fn_with_return_value, 0_usize);
424 let unsafe_fn_with_return_value = (unsafe_fn_with_return_value, 0_usize);
426 let generic_function_int = (generic_function::<isize>, 0_usize);
427 let generic_function_struct3 = (generic_function::<mod1::mod2::Struct3>, 0_usize);
429 let variadic_function = (printf, 0_usize);
432 // I (mw) am a bit unclear about the current state of closures, their
433 // various forms (boxed, unboxed, proc, capture-by-ref, by-val, once) and
434 // how that maps to rustc's internal representation of these forms.
435 // Once closures have reached their 1.0 form, the tests below should
436 // probably be expanded.
437 let closure1 = (|x: isize| {}, 0_usize);
438 let closure2 = (|x: i8, y: f32| (x as f32) + y, 0_usize);
441 let foreign1 = unsafe{ 0 as *const ForeignType1 };
442 let foreign2 = unsafe{ 0 as *const mod1::ForeignType2 };