Emit unnamed_addr on statics

[arielb1]

Mutable globals still work with unnamed_addr, and Rust code shouldn't rely on the significance of addresses.

[huonw]

cc the discussion on rust-lang/rfcs#362

[steveklabnik]

I know next to nothing about llvm attributes, but

pub static mut X: i32 = 5;

gives

@_ZN10playground1X17hacd7d7b63e8c9b94E = local_unnamed_addr global <{ [4 x i8] }> <{ [4 x i8] c"\05\00\00\00" }>, align 4

llvm says https://llvm.org/docs/LangRef.html

Global variables can be marked with unnamed_addr which indicates that the address is not significant, only the content. Constants marked like this can be merged with other constants if they have the same initializer. Note that a constant with significant address can be merged with a unnamed_addr constant, the result being a constant whose address is significant.

If the local_unnamed_addr attribute is given, the address is known to not be significant within the module.

I'm not sure if the local_ version is correct or not...

[workingjubilee]

This is -Copt-level dependent.

; in debug
@_ZN10playground12RUSTY_STATIC17h7d2abb51a94403c7E =
    global <{ [4 x i8] }> <{ [4 x i8] c"\05\00\00\00" }>, align 4, !dbg !0
; in --release
@_ZN10playground12RUSTY_STATIC17hd7ab9ec18434d12fE = 
    local_unnamed_addr constant <{ [4 x i8] }> <{ [4 x i8] c"\05\00\00\00" }>, align 4

So we do not appear to emit any such annotation on statics. Instead, it seems that LLVM is capable of inferring local_unnamed_addr via analysis.

[RalfJung]

Rust code shouldn't rely on the significance of addresses.

Rust code should definitely be able to rely on the address of a static. That's one of their defining features.
Cc @rust-lang/opsem

So, closing this issue.

[workingjubilee]

@RalfJung

A static item is similar to a constant, except that it represents a precise memory location in the program. All references to the static refer to the same memory location. Static items have the static lifetime, which outlives all other lifetimes in a Rust program. Static items do not call drop at the end of the program.

The reference there says that a static has a precise memory location, I cannot see where it says that the following must hold:

static ZERO: u8 = 0;
static ZER0: u8 = 0;
assert_ne!(&raw const ZERO, &raw const ZER0);

[RalfJung]

I would say if a static has a wibbly wobbly address not equal to itself, that's not a "precise memory location". We don't even have addresses that are not equal to themselves.

[digama0]

Note, those two statics are not the same, one of them is ZERO and the other is ZER0. Not sure why it was written like that... A slightly less confusing alpha-equivalent formulation is:

static A: u8 = 0;
static B: u8 = 0;
assert_ne!(&raw const A, raw const B);