os-rust/src/test/codegen/export-no-mangle.rs

// compile-flags: -C no-prepopulate-passes

#![crate_type = "lib"]

mod private {
    // CHECK: @FOO =
    #[no_mangle]
    pub static FOO: u32 = 3;

    // CHECK: @BAR =
    #[export_name = "BAR"]
    static BAR: u32 = 3;

    // CHECK: void @a()
    #[no_mangle]
    pub extern fn a() {}

    // CHECK: void @b()
    #[export_name = "b"]
    extern fn b() {}

    // CHECK: void @c()
    #[export_name = "c"]
    #[inline]
    extern fn c() {}

    // CHECK: void @d()
    #[export_name = "d"]
    #[inline(always)]
    extern fn d() {}
}
Enable -mergefunc-use-aliases If the Rust LLVM fork is used, enable the -mergefunc-use-aliases flag, which will create aliases for merged functions, rather than inserting a call from one to the other. A number of codegen tests needed to be adjusted, because functions that previously fell below the thunk limit are now being merged. Merging is prevented either using -C no-prepopulate-passes, or by making the functions non-identical. I expect that this is going to break something, somewhere, because it isn't able to deal with aliases properly, but we won't find out until we try :) This fixes #52651. 2018-11-29 23:05:23 +01:00			`// compile-flags: -C no-prepopulate-passes`

rustc: Allow `#[no_mangle]` anywhere in a crate This commit updates the compiler to allow the `#[no_mangle]` (and `#[export_name]` attributes) to be located anywhere within a crate. These attributes are unconditionally processed, causing the compiler to always generate an exported symbol with the appropriate name. After some discussion on #54135 it was found that not a great reason this hasn't been allowed already, and it seems to match the behavior that many expect! Previously the compiler would only export a `#[no_mangle]` symbol if it were publicly reachable, meaning that it itself is `pub` and it's otherwise publicly reachable from the root of the crate. This new definition is that `#[no_mangle]` is always reachable, no matter where it is in a crate or whether it has `pub` or not. This should make it much easier to declare an exported symbol with a known and unique name, even when it's an internal implementation detail of the crate itself. Note that these symbols will persist beyond LTO as well, always making their way to the linker. Along the way this commit removes the `private_no_mangle_functions` lint (also for statics) as there's no longer any need to lint these situations. Furthermore a good number of tests were updated now that symbol visibility has been changed. Closes #54135 2018-09-21 15:58:11 -07:00			`#![crate_type = "lib"]`

			`mod private {`
			`// CHECK: @FOO =`
			`#[no_mangle]`
			`pub static FOO: u32 = 3;`

			`// CHECK: @BAR =`
			`#[export_name = "BAR"]`
			`static BAR: u32 = 3;`

Fix exports with `#[inline(always)]` 2020-06-09 15:49:59 +01:00			`// CHECK: void @a()`
rustc: Allow `#[no_mangle]` anywhere in a crate This commit updates the compiler to allow the `#[no_mangle]` (and `#[export_name]` attributes) to be located anywhere within a crate. These attributes are unconditionally processed, causing the compiler to always generate an exported symbol with the appropriate name. After some discussion on #54135 it was found that not a great reason this hasn't been allowed already, and it seems to match the behavior that many expect! Previously the compiler would only export a `#[no_mangle]` symbol if it were publicly reachable, meaning that it itself is `pub` and it's otherwise publicly reachable from the root of the crate. This new definition is that `#[no_mangle]` is always reachable, no matter where it is in a crate or whether it has `pub` or not. This should make it much easier to declare an exported symbol with a known and unique name, even when it's an internal implementation detail of the crate itself. Note that these symbols will persist beyond LTO as well, always making their way to the linker. Along the way this commit removes the `private_no_mangle_functions` lint (also for statics) as there's no longer any need to lint these situations. Furthermore a good number of tests were updated now that symbol visibility has been changed. Closes #54135 2018-09-21 15:58:11 -07:00			`#[no_mangle]`
Fix exports with `#[inline(always)]` 2020-06-09 15:49:59 +01:00			`pub extern fn a() {}`
rustc: Allow `#[no_mangle]` anywhere in a crate This commit updates the compiler to allow the `#[no_mangle]` (and `#[export_name]` attributes) to be located anywhere within a crate. These attributes are unconditionally processed, causing the compiler to always generate an exported symbol with the appropriate name. After some discussion on #54135 it was found that not a great reason this hasn't been allowed already, and it seems to match the behavior that many expect! Previously the compiler would only export a `#[no_mangle]` symbol if it were publicly reachable, meaning that it itself is `pub` and it's otherwise publicly reachable from the root of the crate. This new definition is that `#[no_mangle]` is always reachable, no matter where it is in a crate or whether it has `pub` or not. This should make it much easier to declare an exported symbol with a known and unique name, even when it's an internal implementation detail of the crate itself. Note that these symbols will persist beyond LTO as well, always making their way to the linker. Along the way this commit removes the `private_no_mangle_functions` lint (also for statics) as there's no longer any need to lint these situations. Furthermore a good number of tests were updated now that symbol visibility has been changed. Closes #54135 2018-09-21 15:58:11 -07:00
Fix exports with `#[inline(always)]` 2020-06-09 15:49:59 +01:00			`// CHECK: void @b()`
			`#[export_name = "b"]`
			`extern fn b() {}`
Fix whitespace 2020-06-08 09:54:33 +01:00
Fix exports with `#[inline(always)]` 2020-06-09 15:49:59 +01:00			`// CHECK: void @c()`
			`#[export_name = "c"]`
Export all fns with extern indicator 2020-06-08 09:37:11 +01:00			`#[inline]`
Fix exports with `#[inline(always)]` 2020-06-09 15:49:59 +01:00			`extern fn c() {}`
Fix whitespace 2020-06-09 15:54:34 +01:00
Fix exports with `#[inline(always)]` 2020-06-09 15:49:59 +01:00			`// CHECK: void @d()`
			`#[export_name = "d"]`
			`#[inline(always)]`
			`extern fn d() {}`
rustc: Allow `#[no_mangle]` anywhere in a crate This commit updates the compiler to allow the `#[no_mangle]` (and `#[export_name]` attributes) to be located anywhere within a crate. These attributes are unconditionally processed, causing the compiler to always generate an exported symbol with the appropriate name. After some discussion on #54135 it was found that not a great reason this hasn't been allowed already, and it seems to match the behavior that many expect! Previously the compiler would only export a `#[no_mangle]` symbol if it were publicly reachable, meaning that it itself is `pub` and it's otherwise publicly reachable from the root of the crate. This new definition is that `#[no_mangle]` is always reachable, no matter where it is in a crate or whether it has `pub` or not. This should make it much easier to declare an exported symbol with a known and unique name, even when it's an internal implementation detail of the crate itself. Note that these symbols will persist beyond LTO as well, always making their way to the linker. Along the way this commit removes the `private_no_mangle_functions` lint (also for statics) as there's no longer any need to lint these situations. Furthermore a good number of tests were updated now that symbol visibility has been changed. Closes #54135 2018-09-21 15:58:11 -07:00			`}`