rust/src/test/ui/linkage-attr/linkage3.rs

// FIXME https://github.com/rust-lang/rust/issues/59774

// check-fail
// normalize-stderr-test "thread.*panicked.*Metadata module not compiled.*\n" -> ""
// normalize-stderr-test "note:.*RUST_BACKTRACE=1.*\n" -> ""

#![feature(linkage)]

extern {
    #[linkage = "foo"] static foo: *const i32;
    //~^ ERROR: invalid linkage specified
}

fn main() {
    println!("{:?}", unsafe { foo });
}
normalize away spurious error 2019-04-09 20:08:57 +00:00			`// FIXME https://github.com/rust-lang/rust/issues/59774`
rework run-fail and support check,build-fail 2019-12-14 03:28:32 +00:00
A test now fails during check instead of build 2020-04-30 15:27:33 +00:00			`// check-fail`
normalize away spurious error 2019-04-09 20:08:57 +00:00			`// normalize-stderr-test "thread.panicked.Metadata module not compiled.*\n" -> ""`
			`// normalize-stderr-test "note:.RUST_BACKTRACE=1.\n" -> ""`

Convert most code to new inner attribute syntax. Closes #2569 2014-03-22 01:05:05 +00:00			`#![feature(linkage)]`
rustc: Support various flavors of linkages It is often convenient to have forms of weak linkage or other various types of linkage. Sadly, just using these flavors of linkage are not compatible with Rust's typesystem and how it considers some pointers to be non-null. As a compromise, this commit adds support for weak linkage to external symbols, but it requires that this is only placed on extern statics of type `T`. Codegen-wise, we get translations like: // rust code extern { #[linkage = "extern_weak"] static foo: i32; } // generated IR @foo = extern_weak global i32 @_some_internal_symbol = internal global *i32 @foo All references to the rust value of `foo` then reference `_some_internal_symbol` instead of the symbol `_foo` itself. This allows us to guarantee that the address of `foo` will never be null while the value may sometimes be null. An example was implemented in `std::rt::thread` to determine if `__pthread_get_minstack()` is available at runtime, and a test is checked in to use it for a static value as well. Function pointers a little odd because you still need to transmute the pointer value to a function pointer, but it's thankfully better than not having this capability at all. 2014-02-26 00:15:10 +00:00
			`extern {`
Rename all raw pointers as necessary 2014-06-25 19:47:34 +00:00			`#[linkage = "foo"] static foo: *const i32;`
rustc: Support various flavors of linkages It is often convenient to have forms of weak linkage or other various types of linkage. Sadly, just using these flavors of linkage are not compatible with Rust's typesystem and how it considers some pointers to be non-null. As a compromise, this commit adds support for weak linkage to external symbols, but it requires that this is only placed on extern statics of type `T`. Codegen-wise, we get translations like: // rust code extern { #[linkage = "extern_weak"] static foo: i32; } // generated IR @foo = extern_weak global i32 @_some_internal_symbol = internal global *i32 @foo All references to the rust value of `foo` then reference `_some_internal_symbol` instead of the symbol `_foo` itself. This allows us to guarantee that the address of `foo` will never be null while the value may sometimes be null. An example was implemented in `std::rt::thread` to determine if `__pthread_get_minstack()` is available at runtime, and a test is checked in to use it for a static value as well. Function pointers a little odd because you still need to transmute the pointer value to a function pointer, but it's thankfully better than not having this capability at all. 2014-02-26 00:15:10 +00:00			`//~^ ERROR: invalid linkage specified`
			`}`

			`fn main() {`
Issue deprecation warnings for safe accesses to extern statics 2016-08-26 16:23:42 +00:00			`println!("{:?}", unsafe { foo });`
rustc: Support various flavors of linkages It is often convenient to have forms of weak linkage or other various types of linkage. Sadly, just using these flavors of linkage are not compatible with Rust's typesystem and how it considers some pointers to be non-null. As a compromise, this commit adds support for weak linkage to external symbols, but it requires that this is only placed on extern statics of type `T`. Codegen-wise, we get translations like: // rust code extern { #[linkage = "extern_weak"] static foo: i32; } // generated IR @foo = extern_weak global i32 @_some_internal_symbol = internal global *i32 @foo All references to the rust value of `foo` then reference `_some_internal_symbol` instead of the symbol `_foo` itself. This allows us to guarantee that the address of `foo` will never be null while the value may sometimes be null. An example was implemented in `std::rt::thread` to determine if `__pthread_get_minstack()` is available at runtime, and a test is checked in to use it for a static value as well. Function pointers a little odd because you still need to transmute the pointer value to a function pointer, but it's thankfully better than not having this capability at all. 2014-02-26 00:15:10 +00:00			`}`