bytes!(...).as_ptr() generates bad code on 32-bit architectures

[taralx]

On ARM, bytes!(...).as_ptr() generates a cast to i64*, load, truncate to i32. Something is not right here. :)

Code:

#![crate_type="rlib"]
#![no_std]

extern crate core;

use core::slice::ImmutableVector;

extern "C" {
    fn puts(p: *i8) -> i32;
}

unsafe fn dostuff(p: *u8) {
    puts(p as *i8);
}

pub fn main() {
    unsafe { dostuff(bytes!("TEXT!", 0).as_ptr()); }
}

Output on x86:

; ModuleID = 't.rs'
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

@const = private constant [6 x i8] c"TEXT!\00"

; Function Attrs: nounwind
declare i32 @puts(i8* nocapture readonly) unnamed_addr #0

; Function Attrs: nounwind uwtable
define void @_ZN4main20hafd3b7e891e0f6adCaa4v0.0E() unnamed_addr #1 {
entry-block:
  %0 = tail call i32 @puts(i8* getelementptr inbounds ([6 x i8]* @const, i64 0, i64 0)) #2
  ret void
}

attributes #0 = { nounwind "split-stack" }
attributes #1 = { nounwind uwtable "split-stack" }
attributes #2 = { nounwind }

Output on arm:

; ModuleID = 't.rs'
target datalayout = "e-p:32:32-i64:64-v128:64:128-n32"
target triple = "arm-unknown-linux-gnu"

@const = private constant [6 x i8] c"TEXT!\00"
@_ZN4main5BYTES20h9dc6d6c5b6e2b9ccOaa4v0.0E = internal unnamed_addr constant { i8*, i32 } { i8* getelementptr inbounds ([6 x i8]* @const, i32 0, i32 0), i32 6 }

; Function Attrs: nounwind
declare i32 @puts(i8* nocapture readonly) unnamed_addr #0

; Function Attrs: nounwind uwtable
define void @_ZN4main20hafd3b7e891e0f6adCaa4v0.0E() unnamed_addr #1 {
entry-block:
  %0 = load i64* bitcast ({ i8*, i32 }* @_ZN4main5BYTES20h9dc6d6c5b6e2b9ccOaa4v0.0E to i64*), align 8
  %.sroa.0.0.extract.trunc.i = trunc i64 %0 to i32
  %1 = inttoptr i32 %.sroa.0.0.extract.trunc.i to i8*
  %2 = tail call i32 @puts(i8* %1) #2
  ret void
}

attributes #0 = { nounwind "split-stack" }
attributes #1 = { nounwind uwtable "split-stack" }
attributes #2 = { nounwind }

Compiled with: rust/bin/rustc --emit=ir --target=$CPU-unknown-linux-gnu -L . -O t.rs

[taralx]

This affects i386 as well, so I suspect it's a 32/64 problem.

[taralx]

For reference:

rustc 0.11.0-pre-nightly (7580ef9 2014-06-08 00:46:57 -0700)
host: x86_64-apple-darwin

[taralx]

So as far as I can tell, SROA is running before copy elimination can clean things up:

*** IR Dump After Remove unused exception handling info ***
; Function Attrs: inlinehint nounwind uwtable
define internal fastcc i8* @"_ZN5slice60_$BP$$x27a$x20$x5bT$x5d.ImmutableVector$LT$$x27a$C$$x20T$GT$6as_ptr21h152019210325997247454v0.0E"({ i8*, i32 }* nocapture nonnull) unnamed_addr #2 {
entry-block:
  %1 = alloca %"struct.core::raw::Slice<u8>[#1]", align 4
  call fastcc void @_ZN3raw4Repr4repr19h7328813308158244434v0.0E(%"struct.core::raw::Slice<u8>[#1]"* noalias nocapture nonnull sret %1, { i8*, i32 }* nonnull %0)
  %2 = getelementptr inbounds %"struct.core::raw::Slice<u8>[#1]"* %1, i32 0, i32 0
  %3 = load i8** %2, align 4
  ret i8* %3
}
*** IR Dump After Function Integration/Inlining ***
; Function Attrs: inlinehint nounwind uwtable
define internal fastcc i8* @"_ZN5slice60_$BP$$x27a$x20$x5bT$x5d.ImmutableVector$LT$$x27a$C$$x20T$GT$6as_ptr21h152019210325997247454v0.0E"({ i8*, i32 }* nocapture nonnull) unnamed_addr #2 {
entry-block:
  %1 = alloca %"struct.core::raw::Slice<u8>[#1]", align 4
  %2 = bitcast { i8*, i32 }* %0 to i64*
  %3 = load i64* %2, align 4
  %4 = bitcast %"struct.core::raw::Slice<u8>[#1]"* %1 to i64*
  store i64 %3, i64* %4, align 4
  %5 = getelementptr inbounds %"struct.core::raw::Slice<u8>[#1]"* %1, i32 0, i32 0
  %6 = load i8** %5, align 4
  ret i8* %6
}
[snip]
*** IR Dump After SROA ***
; Function Attrs: inlinehint nounwind readonly uwtable
define internal fastcc i8* @"_ZN5slice60_$BP$$x27a$x20$x5bT$x5d.ImmutableVector$LT$$x27a$C$$x20T$GT$6as_ptr21h152019210325997247454v0.0E"({ i8*, i32 }* nocapture nonnull readonly) unnamed_addr #2 {
entry-block:
  %1 = bitcast { i8*, i32 }* %0 to i64*
  %2 = load i64* %1, align 4
  %.sroa.0.0.extract.trunc = trunc i64 %2 to i32
  %3 = inttoptr i32 %.sroa.0.0.extract.trunc to i8*
  %.sroa.2.0.extract.shift = lshr i64 %2, 32
  %.sroa.2.0.extract.trunc = trunc i64 %.sroa.2.0.extract.shift to i32
  ret i8* %3
}

[dotdash]

Using

#![feature(lang_items, intrinsics)]
#![crate_type="rlib"]
#![no_std]

#[lang="copy"]
trait Copy {}
#[lang="sized"]
trait Sizes {}

extern "rust-intrinsic" {


    /// Abort the execution of the process.
    pub fn abort() -> !;
}
#[lang="panic_bounds_check"]
fn panic_bounds_check(file_line: &(&'static str, usize),
                      index: usize, len: usize) -> ! {
    unsafe {
        abort();
    }
}

extern "C" {
    fn puts(p: *const i8) -> i32;
}

unsafe fn dostuff(p: *const u8) {
    puts(p as *const i8);
}

pub fn main() {
    unsafe { dostuff((&b"TEXT!"[0]) as *const u8); }
}

I can't reproduce the problem. I guess this is fixed?

[apasel422]

What is the status of this? The bytes! macro no longer exists.