Auto merge of #93154 - michaelwoerister:fix-generic-closure-and-generator-debuginfo, r=wesleywiser
debuginfo: Make sure that type names for closure and generator environments are unique in debuginfo.
Before this change, closure/generator environments coming from different instantiations of the same generic function were all assigned the same name even though they were distinct types with potentially different data layout. Now we append the generic arguments of the originating function to the type name.
This commit also emits `{closure_env#0}` as the name of these types in order to disambiguate them from the accompanying closure function (which keeps being called `{closure#0}`). Previously both were assigned the same name.
NOTE: Changing debuginfo names like this can break pretty printers and other debugger plugins. I think it's OK in this particular case because the names we are changing were ambiguous anyway. In general though it would be great to have a process for doing changes like these.
This commit is contained in:
bors
commit
dca1e7aa5a
14 changed files with 287 additions and 121 deletions
|
|
@ -17,7 +17,7 @@ async fn async_fn_test() {
|
|||
// FIXME: No way to reliably check the filename.
|
||||
|
||||
// CHECK-DAG: [[ASYNC_FN:!.*]] = !DINamespace(name: "async_fn_test"
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "async_fn$0"
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "async_fn_env$0"
|
||||
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant0", scope: [[GEN]],
|
||||
// For brevity, we only check the struct name and members of the last variant.
|
||||
// CHECK-SAME: file: [[FILE:![0-9]*]], line: 11,
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ async fn async_fn_test() {
|
|||
// FIXME: No way to reliably check the filename.
|
||||
|
||||
// CHECK-DAG: [[ASYNC_FN:!.*]] = !DINamespace(name: "async_fn_test"
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn#0}", scope: [[ASYNC_FN]]
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}", scope: [[ASYNC_FN]]
|
||||
// CHECK: [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[ASYNC_FN]],
|
||||
// CHECK-NOT: flags: DIFlagArtificial
|
||||
// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
|
||||
|
|
|
|||
|
|
@ -1,25 +1,36 @@
|
|||
// compile-flags: -Cdebuginfo=2 -Copt-level=0 -Ccodegen-units=1
|
||||
// ignore-tidy-linelength
|
||||
|
||||
// This test checks the debuginfo for the expected 3 vtables is generated for correct names and number
|
||||
// of entries.
|
||||
|
||||
// NONMSVC-LABEL: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable}"
|
||||
// MSVC-LABEL: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable$"
|
||||
// Use the v0 symbol mangling scheme to codegen order independent of rustc version.
|
||||
// Unnamed items like shims are generated in lexicographical order of their symbol name and in the
|
||||
// legacy mangling scheme rustc version and generic parameters are both hashed into a single part
|
||||
// of the name, thus randomizing item order with respect to rustc version.
|
||||
|
||||
// compile-flags: -Cdebuginfo=2 -Copt-level=0 -Csymbol-mangling-version=v0
|
||||
// ignore-tidy-linelength
|
||||
|
||||
// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTrait>::{vtable}"
|
||||
// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTrait>::vtable$"
|
||||
// NONMSVC: !DIDerivedType(tag: DW_TAG_pointer_type, name: "*const ()",
|
||||
// MSVC: !DIDerivedType(tag: DW_TAG_pointer_type, name: "ptr_const$<tuple$<> >",
|
||||
// CHECK: !DISubrange(count: 5
|
||||
|
||||
// NONMSVC-LABEL: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable}"
|
||||
// MSVC-LABEL: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable$"
|
||||
// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as debug_vtable::SomeTraitWithGenerics<u64, i8>>::{vtable}"
|
||||
// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, debug_vtable::SomeTraitWithGenerics<u64,i8> >::vtable$"
|
||||
// CHECK: !DISubrange(count: 4
|
||||
|
||||
// NONMSVC-LABEL: !DIGlobalVariable(name: "<debug_vtable::Foo as _>::{vtable}"
|
||||
// MSVC-LABEL: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, _>::vtable$"
|
||||
// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::Foo as _>::{vtable}"
|
||||
// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::Foo, _>::vtable$"
|
||||
// CHECK: !DISubrange(count: 3
|
||||
|
||||
// NONMSVC-LABEL: !DIGlobalVariable(name: "<debug_vtable::bar::{closure#0} as core::ops::function::FnOnce<(core::option::Option<&dyn core::ops::function::Fn<(), Output=()>>)>>::{vtable}"
|
||||
// MSVC-LABEL: !DIGlobalVariable(name: "impl$<debug_vtable::bar::closure$0, core::ops::function::FnOnce<tuple$<enum$<core::option::Option<ref$<dyn$<core::ops::function::Fn<tuple$<>,assoc$<Output,tuple$<> > > > > >, {{.*}}, {{.*}}, Some> > > >::vtable$"
|
||||
// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::bar::{closure_env#0} as core::ops::function::FnOnce<(core::option::Option<&dyn core::ops::function::Fn<(), Output=()>>)>>::{vtable}"
|
||||
// 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$"
|
||||
|
||||
// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<bool> as core::ops::function::FnOnce<()>>::{vtable}"
|
||||
// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<bool>, core::ops::function::FnOnce<tuple$<> > >::vtable$
|
||||
|
||||
// NONMSVC: !DIGlobalVariable(name: "<debug_vtable::generic_closure::{closure_env#0}<u32> as core::ops::function::FnOnce<()>>::{vtable}"
|
||||
// MSVC: !DIGlobalVariable(name: "impl$<debug_vtable::generic_closure::closure_env$0<u32>, core::ops::function::FnOnce<tuple$<> > >::vtable$
|
||||
|
||||
#![crate_type = "lib"]
|
||||
|
||||
|
|
@ -31,8 +42,12 @@ pub trait SomeTrait {
|
|||
}
|
||||
|
||||
impl SomeTrait for Foo {
|
||||
fn method1(&self) -> u32 { 1 }
|
||||
fn method2(&self) -> u32 { 2 }
|
||||
fn method1(&self) -> u32 {
|
||||
1
|
||||
}
|
||||
fn method2(&self) -> u32 {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
pub trait SomeTraitWithGenerics<T, U> {
|
||||
|
|
@ -40,7 +55,9 @@ pub trait SomeTraitWithGenerics<T, U> {
|
|||
}
|
||||
|
||||
impl SomeTraitWithGenerics<u64, i8> for Foo {
|
||||
fn method1(&self) -> (u64, i8) { (1, 2) }
|
||||
fn method1(&self) -> (u64, i8) {
|
||||
(1, 2)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn foo(x: &Foo) -> (u32, (u64, i8), &dyn Send) {
|
||||
|
|
@ -55,3 +72,11 @@ pub fn foo(x: &Foo) -> (u32, (u64, i8), &dyn Send) {
|
|||
pub fn bar() -> Box<dyn FnOnce(Option<&dyn Fn()>)> {
|
||||
Box::new(|_x: Option<&dyn Fn()>| {})
|
||||
}
|
||||
|
||||
fn generic_closure<T: 'static>(x: T) -> Box<dyn FnOnce() -> T> {
|
||||
Box::new(move || x)
|
||||
}
|
||||
|
||||
pub fn instantiate_generic_closures() -> (Box<dyn FnOnce() -> u32>, Box<dyn FnOnce() -> bool>) {
|
||||
(generic_closure(1u32), generic_closure(false))
|
||||
}
|
||||
|
|
|
|||
91
src/test/codegen/debuginfo-generic-closure-env-names.rs
Normal file
91
src/test/codegen/debuginfo-generic-closure-env-names.rs
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
// This test checks that we get proper type names for closure environments and
|
||||
// async-fn environments in debuginfo, especially making sure that generic arguments
|
||||
// of the enclosing functions don't get lost.
|
||||
//
|
||||
// Unfortunately, the order that debuginfo gets emitted into LLVM IR becomes a bit hard
|
||||
// to predict once async fns are involved.
|
||||
//
|
||||
// Note that the test does not check async-fns when targeting MSVC because debuginfo for
|
||||
// those does not follow the enum-fallback encoding yet and thus is incomplete.
|
||||
|
||||
// ignore-tidy-linelength
|
||||
|
||||
// Use the v0 symbol mangling scheme to codegen order independent of rustc version.
|
||||
// Unnamed items like shims are generated in lexicographical order of their symbol name and in the
|
||||
// legacy mangling scheme rustc version and generic parameters are both hashed into a single part
|
||||
// of the name, thus randomizing item order with respect to rustc version.
|
||||
|
||||
// compile-flags: -Cdebuginfo=2 --edition 2021 -Copt-level=0 -Csymbol-mangling-version=v0
|
||||
|
||||
|
||||
// CHECK: [[non_generic_closure_NAMESPACE:!.*]] = !DINamespace(name: "non_generic_closure"
|
||||
// CHECK: [[function_containing_closure_NAMESPACE:!.*]] = !DINamespace(name: "function_containing_closure"
|
||||
// CHECK: [[generic_async_function_NAMESPACE:!.*]] = !DINamespace(name: "generic_async_function"
|
||||
// CHECK: [[generic_async_block_NAMESPACE:!.*]] = !DINamespace(name: "generic_async_block"
|
||||
|
||||
// non_generic_closure()
|
||||
// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}", scope: [[non_generic_closure_NAMESPACE]]
|
||||
// MSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0", scope: [[non_generic_closure_NAMESPACE]]
|
||||
|
||||
// function_containing_closure<u32>()
|
||||
// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}<u32>", scope: [[function_containing_closure_NAMESPACE]]
|
||||
// MSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0<u32>", scope: [[function_containing_closure_NAMESPACE]]
|
||||
|
||||
// generic_async_function<Foo>()
|
||||
// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: [[generic_async_function_NAMESPACE]]
|
||||
|
||||
// generic_async_function<u32>()
|
||||
// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_fn_env#0}<u32>", scope: [[generic_async_function_NAMESPACE]]
|
||||
|
||||
// generic_async_block<Foo>()
|
||||
// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_block_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: [[generic_async_block_NAMESPACE]]
|
||||
|
||||
// generic_async_block<u32>()
|
||||
// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{async_block_env#0}<u32>", scope: [[generic_async_block_NAMESPACE]]
|
||||
|
||||
// function_containing_closure<Foo>()
|
||||
// NONMSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}<debuginfo_generic_closure_env_names::Foo>", scope: [[function_containing_closure_NAMESPACE]]
|
||||
// MSVC: !DICompositeType(tag: DW_TAG_structure_type, name: "closure_env$0<debuginfo_generic_closure_env_names::Foo>", scope: [[function_containing_closure_NAMESPACE]]
|
||||
|
||||
|
||||
#![crate_type = "lib"]
|
||||
use std::future::Future;
|
||||
|
||||
pub struct Foo;
|
||||
|
||||
pub fn non_generic_closure(x: Foo) -> Box<dyn FnOnce() -> Foo> {
|
||||
// This static only exists to trigger generating the namespace debuginfo for
|
||||
// `function_containing_closure` at a predictable, early point, which makes
|
||||
// writing the FileCheck tests above simpler.
|
||||
static _X: u8 = 0;
|
||||
return Box::new(move || x);
|
||||
}
|
||||
|
||||
fn function_containing_closure<T: 'static>(x: T) -> impl FnOnce() -> T {
|
||||
static _X: u8 = 0; // Same as above
|
||||
|
||||
return move || x;
|
||||
}
|
||||
|
||||
async fn generic_async_function<T: 'static>(x: T) -> T {
|
||||
static _X: u8 = 0; // Same as above
|
||||
x
|
||||
}
|
||||
|
||||
fn generic_async_block<T: 'static>(x: T) -> impl Future<Output=T> {
|
||||
static _X: u8 = 0; // Same as above
|
||||
async move {
|
||||
x
|
||||
}
|
||||
}
|
||||
|
||||
pub fn instantiate_generics() {
|
||||
let _closure_u32 = function_containing_closure(7u32);
|
||||
let _closure_foo = function_containing_closure(Foo);
|
||||
|
||||
let _async_fn_u32 = generic_async_function(42u32);
|
||||
let _async_fn_foo = generic_async_function(Foo);
|
||||
|
||||
let _async_block_u32 = generic_async_block(64u32);
|
||||
let _async_block_foo = generic_async_block(Foo);
|
||||
}
|
||||
|
|
@ -21,7 +21,7 @@ fn generator_test() -> impl Generator<Yield = i32, Return = ()> {
|
|||
// FIXME: No way to reliably check the filename.
|
||||
|
||||
// CHECK-DAG: [[GEN_FN:!.*]] = !DINamespace(name: "generator_test"
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "generator$0"
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_union_type, name: "generator_env$0"
|
||||
// CHECK: {{!.*}} = !DIDerivedType(tag: DW_TAG_member, name: "variant0", scope: [[GEN]],
|
||||
// For brevity, we only check the struct name and members of the last variant.
|
||||
// CHECK-SAME: file: [[FILE:![0-9]*]], line: 14,
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ fn generator_test() -> impl Generator<Yield = i32, Return = ()> {
|
|||
// FIXME: No way to reliably check the filename.
|
||||
|
||||
// CHECK-DAG: [[GEN_FN:!.*]] = !DINamespace(name: "generator_test"
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{generator#0}", scope: [[GEN_FN]]
|
||||
// CHECK-DAG: [[GEN:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{generator_env#0}", scope: [[GEN_FN]]
|
||||
// CHECK: [[VARIANT:!.*]] = !DICompositeType(tag: DW_TAG_variant_part, scope: [[GEN_FN]],
|
||||
// CHECK-NOT: flags: DIFlagArtificial
|
||||
// CHECK-SAME: discriminator: [[DISC:![0-9]*]]
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue