/src/test/codegen/debug-vtable.rs

https://gitlab.com/rust-lang/rust · Rust · 107 lines · 37 code · 23 blank · 47 comment · 3 complexity · 11509014a5187b72b4ea136e72cf6ae7 MD5 · raw file 

    

  1. // This test checks the debuginfo for the expected 3 vtables is generated for correct names and number
    2. 

  2. // of entries.
    3. 

  3. 

  4. // Use the v0 symbol mangling scheme to codegen order independent of rustc version.
    5. 

  5. // Unnamed items like shims are generated in lexicographical order of their symbol name and in the
    6. 

  6. // legacy mangling scheme rustc version and generic parameters are both hashed into a single part
    7. 

  7. // of the name, thus randomizing item order with respect to rustc version.
    8. 

  8. 

  9. // compile-flags: -Cdebuginfo=2 -Copt-level=0 -Csymbol-mangling-version=v0
    10. 

  10. // ignore-tidy-linelength
    11. 

  11. 

  12. // NONMSVC: ![[USIZE:[0-9]+]] = !DIBasicType(name: "usize"
    13. 

  13. // MSVC: ![[USIZE:[0-9]+]] = !DIDerivedType(tag: DW_TAG_typedef, name: "usize"
    14. 

  14. // NONMSVC: ![[PTR:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "*const ()"
    15. 

  15. // MSVC: ![[PTR:[0-9]+]] = !DIDerivedType(tag: DW_TAG_pointer_type, name: "ptr_const$<tuple$<> >"
    16. 

  16. 

  17. // NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable}"
    18. 

  18. // MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable$"
    19. 

  19. 

  20. // NONMSVC: ![[VTABLE_TY0:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable_type}", {{.*}} size: {{320|160}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}} vtableHolder: ![[FOO_TYPE:[0-9]+]],
    21. 

  21. // MSVC: ![[VTABLE_TY0:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable_type$", {{.*}} size: {{320|160}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}} vtableHolder: ![[FOO_TYPE:[0-9]+]],
    22. 

  22. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
    23. 

  23. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
    24. 

  24. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
    25. 

  25. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method3", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{192|96}})
    26. 

  26. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method4", scope: ![[VTABLE_TY0]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{256|128}})
    27. 

  27. // CHECK: ![[FOO_TYPE]] = !DICompositeType(tag: DW_TAG_structure_type, name: "Foo",
    28. 

  28. 

  29. // NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable}"
    30. 

  30. // MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable$"
    31. 

  31. 

  32. // NONMSVC: ![[VTABLE_TY1:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable_type}", {{.*}}, size: {{256|128}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
    33. 

  33. // MSVC: ![[VTABLE_TY1:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable_type$", {{.*}}, size: {{256|128}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
    34. 

  34. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
    35. 

  35. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
    36. 

  36. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
    37. 

  37. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "__method3", scope: ![[VTABLE_TY1]], {{.*}} baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}}, offset: {{192|96}})
    38. 

  38. 

  39. // NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as _>::{vtable}"
    40. 

  40. // MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, _>::vtable$"
    41. 

  41. 

  42. // NONMSVC: ![[VTABLE_TY2:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "<debug_vtable::Foo as _>::{vtable_type}", {{.*}}, size: {{192|96}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
    43. 

  43. // MSVC: ![[VTABLE_TY2:[0-9]+]] = !DICompositeType(tag: DW_TAG_structure_type, name: "impl$<debug_vtable::Foo, _>::vtable_type$", {{.*}}, size: {{192|96}}, align: {{64|32}}, flags: DIFlagArtificial, {{.*}}, vtableHolder: ![[FOO_TYPE]],
    44. 

  44. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "drop_in_place", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[PTR]], size: {{64|32}}, align: {{64|32}})
    45. 

  45. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "size", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{64|32}})
    46. 

  46. // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "align", scope: ![[VTABLE_TY2]], {{.*}}, baseType: ![[USIZE]], size: {{64|32}}, align: {{64|32}}, offset: {{128|64}})
    47. 

  47. 

  48. // NONMSVC: !DIGlobalVariable(name: "<debug_vtable::bar::{closure_env#0} as core::ops::function::FnOnce<(core::option::Option<&dyn core::ops::function::Fn<(), Output=()>>)>>::{vtable}"
    49. 

  49. // MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::bar::closure_env$0, core::ops::function::FnOnce<tuple$<enum$<core::option::Option<ref$<dyn$<core::ops::function::Fn<tuple$<>,assoc$<Output,tuple$<> > > > > >, {{.*}}, {{.*}}, Some> > > >::vtable$"
    50. 

  50. 

  51. // NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<bool> as core::ops::function::FnOnce<()>>::{vtable}"
    52. 

  52. // MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<bool>, core::ops::function::FnOnce<tuple$<> > >::vtable$
    53. 

  53. 

  54. // NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<u32> as core::ops::function::FnOnce<()>>::{vtable}"
    55. 

  55. // MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<u32>, core::ops::function::FnOnce<tuple$<> > >::vtable$
    56. 

  56. 

  57. #![crate_type = "lib"]
    58. 

  58. 

  59. // Force emission for debuginfo for usize and *const() early..
    60. 

  60. pub static mut XYZ: Option<(usize, *const ())> = None;
    61. 

  61. 

  62. pub struct Foo;
    63. 

  63. 

  64. pub trait SomeTrait {
    65. 

  65.     fn method1(&self) -> u32;
    66. 

  66.     fn method2(&self) -> u32;
    67. 

  67. }
    68. 

  68. 

  69. impl SomeTrait for Foo {
    70. 

  70.     fn method1(&self) -> u32 {
    71. 

  71.         1
    72. 

  72.     }
    73. 

  73.     fn method2(&self) -> u32 {
    74. 

  74.         2
    75. 

  75.     }
    76. 

  76. }
    77. 

  77. 

  78. pub trait SomeTraitWithGenerics<T, U> {
    79. 

  79.     fn method1(&self) -> (T, U);
    80. 

  80. }
    81. 

  81. 

  82. impl SomeTraitWithGenerics<u64, i8> for Foo {
    83. 

  83.     fn method1(&self) -> (u64, i8) {
    84. 

  84.         (1, 2)
    85. 

  85.     }
    86. 

  86. }
    87. 

  87. 

  88. pub fn foo(x: &Foo) -> (u32, (u64, i8), &dyn Send) {
    89. 

  89.     let y: &dyn SomeTrait = x;
    90. 

  90.     let z: &dyn SomeTraitWithGenerics<u64, i8> = x;
    91. 

  91.     (y.method1(), z.method1(), x as &dyn Send)
    92. 

  92. }
    93. 

  93. 

  94. // Constructing the debuginfo name for the FnOnce vtable below initially caused an ICE on MSVC
    95. 

  95. // because the trait type contains a late bound region that needed to be erased before the type
    96. 

  96. // layout for the niche enum `Option<&dyn Fn()>` could be computed.
    97. 

  97. pub fn bar() -> Box<dyn FnOnce(Option<&dyn Fn()>)> {
    98. 

  98.     Box::new(|_x: Option<&dyn Fn()>| {})
    99. 

  99. }
    100. 

  100. 

  101. fn generic_closure<T: 'static>(x: T) -> Box<dyn FnOnce() -> T> {
    102. 

  102.     Box::new(move || x)
    103. 

  103. }
    104. 

  104. 

  105. pub fn instantiate_generic_closures() -> (Box<dyn FnOnce() -> u32>, Box<dyn FnOnce() -> bool>) {
    106. 

  106.     (generic_closure(1u32), generic_closure(false))
    107. 

  107. }
    108.