Better diagnostic for unaligned reference in `println!`

[osa1]

Tried with current master (ccffcaf).

This builds without warnings:

#[repr(packed)]
pub struct ObjInd {
    _header: u32,
    field: u32,
}

pub unsafe fn test(obj: *const ObjInd) {
    let field = (*obj).field;
    println!("{}", field);
}

But this generates a "ref to packed field" warning:

#[repr(packed)]
pub struct ObjInd {
    _header: u32,
    field: u32,
}

pub unsafe fn test(obj: *const ObjInd) {
    println!("{}", (*obj).field);
}

Output:

   Compiling packed_field_ptr v0.1.0 (/home/omer/rust/packed_field_ptr)
warning: reference to packed field is unaligned
 --> src/lib.rs:8:20
  |
8 |     println!("{}", (*obj).field);
  |                    ^^^^^^^^^^^^
  |
  = note: `#[warn(unaligned_references)]` on by default
  = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
  = note: for more information, see issue #82523 <https://github.com/rust-lang/rust/issues/82523>
  = note: fields of packed structs are not properly aligned, and creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)

warning: `packed_field_ptr` (lib) generated 1 warning
    Finished dev [unoptimized + debuginfo] target(s) in 0.11s

Same with similar macros like writeln.

My guess is println is taking reference of its arguments, to avoid moving. No idea how to fix these warnings or if it's even possible without breaking backwards compat by making println move the args.

[RalfJung]

This is indeed expected behavior -- println! does implicitly take a reference by adding an & to each argument, as you guessed. So the warning is totally correct, but probably confusing since the & is not visible in the code.

I suppose the only thing we could do here is to adjust the warning in the special case that the & is the one added by println! (or other users of format_args!). I am not sure how to best do that, though.

The fix in the code, btw, is to wrap the argument in braces, which forces a move:

pub unsafe fn test(obj: *const ObjInd) {
    println!("{}", { (*obj).field });
}

This is basically a shorter version of your first code example.

[osa1]

This also happens with assertion macros:

#[repr(packed)]
pub struct ObjInd {
    _header: u32,
    field: u32,
}

pub unsafe fn test(obj: *const ObjInd) {
    assert_eq!((*obj).field, 123); // "reference to packed field is unaligned"
}

[RalfJung]

Yes, assert_eq! also adds an implicit &.

[fralalonde]

Quick workaround: here's an align_copy! macro that copies the field value to a temp var and returns the now-aligned value copy.

macro_rules! align_copy {
    ($value:expr) => {{ let copy = $value; copy }};
}

// example usage
println!("{}", align_copy!(packed_struct.unaligned_field))

If there's a nicer way to do this, I'd like to know.

[RalfJung]

println!("{}", { packed_struct.unaligned_field }) should work without the macro.

I am renaming this issue to track printing a better error message for code like this

#[repr(packed)]
pub struct ObjInd {
    _header: u32,
    field: u32,
}

pub unsafe fn test(obj: *const ObjInd) {
    println!("{}", (*obj).field);
}

It is expected that this code gets rejected, but the error could explain that there is an implicit & added by the format macro, and that one way to resolve the issue is create a copy of the field data by writing println!("{}", { (*obj).field });

[fralalonde]

Doesn't the (*obj).field form imply that the whole struct will be copied first? This seems wasteful if a single field needs to be accessed out of a large struct, more so if it's multiple fields, each requiring a full copy. Unless the full copy can be reliably optimized away by the compiler to keep only the field value? In which case, the macro approach would not be required.

[RalfJung]

No, that code means that only the field is copied. The place-to-value conversion happens after the field projection.

[clubby789]

@rustbot label +A-diagnostics