Bad codegen with const used on the left of `@` pattern #22850

kmcallister · 2015-02-26T22:46:52Z

Possibly the treatment as a match vs. a binding is inconsistent between typeck and trans. The unused variable lint is also peculiar.

macro_rules! foo {
    ($n:expr) => {
        match $n {
            zzzz @ _ => zzzz + 1,       
            _ => 0,
        }
    }
} 

fn main() {
    const zzzz: i32 = 3; 
    assert_eq!(foo!(3), 4);
}

$ rustc --version
rustc 1.0.0-dev (4db0b3246 2015-02-25) (built 2015-02-26)

$ rustc -C debuginfo=2 foo.rs   # only happens w/o opt
foo.rs:4:13: 4:21 warning: unused variable: `zzzz`, #[warn(unused_variables)] on by default
foo.rs:4             zzzz @ _ => zzzz + 1,
                     ^~~~~~~~
foo.rs:1:1: 8:2 note: in expansion of foo!
foo.rs:12:16: 12:24 note: expansion site
<std macros>:1:1: 9:39 note: in expansion of assert_eq!
foo.rs:12:5: 12:28 note: expansion site
foo.rs:11:5: 11:25 warning: constant `zzzz` should have an upper case name such as `ZZZZ`, #[warn(non_upper_case_globals)] on by default
foo.rs:11     const zzzz: i32 = 3;
              ^~~~~~~~~~~~~~~~~~~~
foo.rs:4:13: 4:21 warning: constant in pattern `zzzz` should have an upper case name such as `ZZZZ`, #[warn(non_upper_case_globals)] on by default
foo.rs:4             zzzz @ _ => zzzz + 1,
                     ^~~~~~~~
foo.rs:1:1: 8:2 note: in expansion of foo!
foo.rs:12:16: 12:24 note: expansion site
<std macros>:1:1: 9:39 note: in expansion of assert_eq!
foo.rs:12:5: 12:28 note: expansion site

$ gdb ./foo
(gdb) run
Starting program: /tmp/foo 
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Program received signal SIGSEGV, Segmentation fault.
0x0000555555559146 in foo::main () at foo.rs:10
10      fn main() {

IR:

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

%str_slice = type { i8*, i64 }
%"2.core::fmt::Formatter" = type { i32, i32, i8, %"2.core::option::Option<usize>", %"2.core::option::Option<usize>", { i8*, void (i8*)** }, %"2.core::slice::Iter<core::fmt::ArgumentV1>", { %"2.core::fmt::ArgumentV1"*, i64 } }
%"2.core::option::Option<usize>" = type { i64, [0 x i64], [1 x i64] }
%"2.core::slice::Iter<core::fmt::ArgumentV1>" = type { %"2.core::fmt::ArgumentV1"*, %"2.core::fmt::ArgumentV1"*, %"2.core::marker::PhantomData<&'static core::fmt::ArgumentV1>" }
%"2.core::fmt::ArgumentV1" = type { %"2.core::fmt::Void"*, i8 (%"2.core::fmt::Void"*, %"2.core::fmt::Formatter"*)* }
%"2.core::fmt::Void" = type {}
%"2.core::marker::PhantomData<&'static core::fmt::ArgumentV1>" = type {}
%"2.core::fmt::Arguments" = type { { %str_slice*, i64 }, %"2.core::option::Option<&'static [core::fmt::rt::v1::Argument]>", { %"2.core::fmt::ArgumentV1"*, i64 } }
%"2.core::option::Option<&'static [core::fmt::rt::v1::Argument]>" = type { { %"2.core::fmt::rt::v1::Argument"*, i64 } }
%"2.core::fmt::rt::v1::Argument" = type { %"2.core::fmt::rt::v1::Position", %"2.core::fmt::rt::v1::FormatSpec" }
%"2.core::fmt::rt::v1::Position" = type { i64, [0 x i64], [1 x i64] }
%"2.core::fmt::rt::v1::FormatSpec" = type { i32, i8, i32, %"2.core::fmt::rt::v1::Count", %"2.core::fmt::rt::v1::Count" }
%"2.core::fmt::rt::v1::Count" = type { i64, [0 x i64], [1 x i64] }

@const19 = internal unnamed_addr constant i32 3
@const22 = internal unnamed_addr constant i32 4
@const26 = internal unnamed_addr constant i32 0
@const27 = internal unnamed_addr constant i32* @const22
@const133 = internal unnamed_addr constant { { i8*, i8* } } zeroinitializer
@str1146 = internal constant [63 x i8] c"assertion failed: `(left == right) && (right == left)` (left: `"
@str1147 = internal constant [11 x i8] c"`, right: `"
@str1148 = internal constant [2 x i8] c"`)"
@ref68 = internal unnamed_addr constant [3 x %str_slice] [%str_slice { i8* getelementptr inbounds ([63 x i8]* @str1146, i32 0, i32 0), i64 63 }, %str_slice { i8* getelementptr inbounds ([11 x i8]* @str1147, i32 0, i32 0), i64 11 }, %str_slice { i8* getelementptr inbounds ([2 x i8]* @str1148, i32 0, i32 0), i64 2 }]
@_ZN4main15__STATIC_FMTSTR20h0eec925d33596e3a9aaE = internal constant { %str_slice*, i64 } { %str_slice* getelementptr inbounds ([3 x %str_slice]* @ref68, i32 0, i32 0), i64 3 }
@const90 = internal unnamed_addr constant i8 (i32*, %"2.core::fmt::Formatter"*)* @_ZN3fmt3num14i32.fmt..Debug3fmt20h82571085d6d53e2c8uBE
@str1159 = internal constant [6 x i8] c"foo.rs"
@_ZN4main10_FILE_LINE20ha7672bc1aa8c4e82KbaE = internal constant { %str_slice, i64 } { %str_slice { i8* getelementptr inbounds ([6 x i8]* @str1159, i32 0, i32 0), i64 6 }, i64 12 }

; Function Attrs: uwtable
define internal void @_ZN4main20hd61647c88ae5d91beaaE() unnamed_addr #0 {
entry-block:
  %0 = alloca { i32*, i32* }
  %1 = alloca i32
  %match = alloca i32
  %__llmatch = alloca i32*
  %zzzz = alloca i32
  %addr_of = alloca i32
  %__llmatch3 = alloca i32**
  %left_val = alloca i32*
  %__llmatch4 = alloca i32**
  %right_val = alloca i32*
  %2 = alloca %"2.core::fmt::Arguments"
  %3 = alloca { %str_slice*, i64 }
  %4 = alloca [2 x %"2.core::fmt::ArgumentV1"]
  %5 = alloca { i32*, i32* }
  %__llmatch7 = alloca i32**
  %__arg0 = alloca i32*
  %__llmatch8 = alloca i32**
  %__arg1 = alloca i32*
  %auto_deref = alloca [2 x %"2.core::fmt::ArgumentV1"]*
  %__fat_ptr = alloca { %"2.core::fmt::ArgumentV1"*, i64 }
  %__fat_ptr10 = alloca { %"2.core::fmt::ArgumentV1"*, i64 }
  %6 = alloca { %str_slice, i64 }*
  %7 = getelementptr inbounds { i32*, i32* }* %0, i32 0, i32 0
  store i32 3, i32* %match
  %8 = load i32* %match
  switch i32 %8, label %match_else [
    i32 3, label %match_case
  ]

case_body:                                        ; preds = %match_case
  %9 = load i32** %__llmatch
  %10 = load i32* %9
  store i32 %10, i32* %zzzz
  store i32 4, i32* %1
  br label %join

case_body1:                                       ; preds = %match_else
  store i32 0, i32* %1
  br label %join

match_else:                                       ; preds = %entry-block
  br label %case_body1

match_case:                                       ; preds = %entry-block
  br label %case_body

join:                                             ; preds = %case_body1, %case_body
  %11 = load i32* %1
  store i32 %11, i32* %addr_of
  store i32* %addr_of, i32** %7
  %12 = getelementptr inbounds { i32*, i32* }* %0, i32 0, i32 1
  store i32* @const22, i32** %12
  %13 = getelementptr inbounds { i32*, i32* }* %0, i32 0, i32 0
  %14 = getelementptr inbounds { i32*, i32* }* %0, i32 0, i32 1
  store i32** %13, i32*** %__llmatch3
  store i32** %14, i32*** %__llmatch4
  br label %case_body2

case_body2:                                       ; preds = %join
  %15 = load i32*** %__llmatch3
  %16 = load i32** %15, !nonnull !0
  store i32* %16, i32** %left_val
  %17 = load i32*** %__llmatch4
  %18 = load i32** %17, !nonnull !0
  store i32* %18, i32** %right_val
  %19 = load i32** %left_val, !nonnull !0
  %20 = load i32** %right_val, !nonnull !0
  %21 = load i32* %19
  %22 = load i32* %20
  %23 = icmp eq i32 %21, %22
  br i1 %23, label %before_rhs, label %join5

join5:                                            ; preds = %before_rhs, %case_body2
  %24 = phi i1 [ %23, %case_body2 ], [ %30, %before_rhs ]
  %25 = xor i1 %24, true
  br i1 %25, label %then-block-51-, label %next-block

before_rhs:                                       ; preds = %case_body2
  %26 = load i32** %right_val, !nonnull !0
  %27 = load i32** %left_val, !nonnull !0
  %28 = load i32* %26
  %29 = load i32* %27
  %30 = icmp eq i32 %28, %29
  br label %join5

then-block-51-:                                   ; preds = %join5
  %31 = bitcast { %str_slice*, i64 }* %3 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %31, i8* bitcast ({ %str_slice*, i64 }* @_ZN4main15__STATIC_FMTSTR20h0eec925d33596e3a9aaE to i8*), i64 16, i32 8, i1 false)
  %32 = getelementptr inbounds { i32*, i32* }* %5, i32 0, i32 0
  %33 = load i32** %left_val, !nonnull !0
  store i32* %33, i32** %32
  %34 = getelementptr inbounds { i32*, i32* }* %5, i32 0, i32 1
  %35 = load i32** %right_val, !nonnull !0
  store i32* %35, i32** %34
  %36 = getelementptr inbounds { i32*, i32* }* %5, i32 0, i32 0
  %37 = getelementptr inbounds { i32*, i32* }* %5, i32 0, i32 1
  store i32** %36, i32*** %__llmatch7
  store i32** %37, i32*** %__llmatch8
  br label %case_body6

case_body6:                                       ; preds = %then-block-51-
  %38 = load i32*** %__llmatch8
  %39 = load i32** %38, !nonnull !0
  store i32* %39, i32** %__arg1
  %40 = load i32*** %__llmatch7
  %41 = load i32** %40, !nonnull !0
  store i32* %41, i32** %__arg0
  %42 = getelementptr inbounds [2 x %"2.core::fmt::ArgumentV1"]* %4, i32 0, i32 0
  %43 = getelementptr inbounds %"2.core::fmt::ArgumentV1"* %42, i32 0
  %44 = load i32** %__arg0, !nonnull !0
  call void @"_ZN3fmt24ArgumentV1$LT$$u27$a$GT$3new21h11701018729727839244E"(%"2.core::fmt::ArgumentV1"* noalias nocapture sret dereferenceable(16) %43, i32* noalias readonly dereferenceable(4) %44, i8 (i32*, %"2.core::fmt::Formatter"*)* @_ZN3fmt3num14i32.fmt..Debug3fmt20h82571085d6d53e2c8uBE)
  %45 = getelementptr inbounds %"2.core::fmt::ArgumentV1"* %42, i32 1
  %46 = load i32** %__arg1, !nonnull !0
  call void @"_ZN3fmt24ArgumentV1$LT$$u27$a$GT$3new21h11701018729727839244E"(%"2.core::fmt::ArgumentV1"* noalias nocapture sret dereferenceable(16) %45, i32* noalias readonly dereferenceable(4) %46, i8 (i32*, %"2.core::fmt::Formatter"*)* @_ZN3fmt3num14i32.fmt..Debug3fmt20h82571085d6d53e2c8uBE)
  br label %join9

join9:                                            ; preds = %case_body6
  store [2 x %"2.core::fmt::ArgumentV1"]* %4, [2 x %"2.core::fmt::ArgumentV1"]** %auto_deref
  %47 = load [2 x %"2.core::fmt::ArgumentV1"]** %auto_deref, !nonnull !0
  %48 = bitcast [2 x %"2.core::fmt::ArgumentV1"]* %47 to %"2.core::fmt::ArgumentV1"*
  %49 = getelementptr inbounds { %"2.core::fmt::ArgumentV1"*, i64 }* %__fat_ptr, i32 0, i32 0
  store %"2.core::fmt::ArgumentV1"* %48, %"2.core::fmt::ArgumentV1"** %49
  %50 = getelementptr inbounds { %"2.core::fmt::ArgumentV1"*, i64 }* %__fat_ptr, i32 0, i32 1
  store i64 2, i64* %50
  %51 = bitcast { %"2.core::fmt::ArgumentV1"*, i64 }* %__fat_ptr to i8*
  %52 = bitcast { %"2.core::fmt::ArgumentV1"*, i64 }* %__fat_ptr10 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %52, i8* %51, i64 16, i32 8, i1 false)
  call void @"_ZN3fmt23Arguments$LT$$u27$a$GT$6new_v120hddb70f9412632ed662BE"(%"2.core::fmt::Arguments"* noalias nocapture sret dereferenceable(48) %2, { %str_slice*, i64 }* noalias nocapture dereferenceable(16) %3, { %"2.core::fmt::ArgumentV1"*, i64 }* noalias nocapture dereferenceable(16) %__fat_ptr10)
  store { %str_slice, i64 }* @_ZN4main10_FILE_LINE20ha7672bc1aa8c4e82KbaE, { %str_slice, i64 }** %6
  %53 = load { %str_slice, i64 }** %6, !nonnull !0
  call void @_ZN2rt6unwind16begin_unwind_fmt20hbda8d92395aa47d1LOIE(%"2.core::fmt::Arguments"* noalias nocapture dereferenceable(48) %2, { %str_slice, i64 }* noalias readonly dereferenceable(24) %53)
  unreachable

next-block:                                       ; preds = %join5
  br label %join11

join11:                                           ; preds = %next-block
  ret void
}

define i64 @main(i64, i8**) unnamed_addr #1 {
top:
  %2 = call i64 @_ZN2rt10lang_start20h7a2fc813423057b2l4IE(i8* bitcast (void ()* @_ZN4main20hd61647c88ae5d91beaaE to i8*), i64 %0, i8** %1)
  ret i64 %2
}

declare i64 @_ZN2rt10lang_start20h7a2fc813423057b2l4IE(i8*, i64, i8**) unnamed_addr #1

; Function Attrs: cold noinline noreturn
declare void @_ZN2rt6unwind16begin_unwind_fmt20hbda8d92395aa47d1LOIE(%"2.core::fmt::Arguments"* noalias nocapture dereferenceable(48), { %str_slice, i64 }* noalias readonly dereferenceable(24)) unnamed_addr #2

; Function Attrs: inlinehint uwtable
define internal void @"_ZN3fmt23Arguments$LT$$u27$a$GT$6new_v120hddb70f9412632ed662BE"(%"2.core::fmt::Arguments"* noalias nocapture sret dereferenceable(48), { %str_slice*, i64 }* noalias nocapture dereferenceable(16), { %"2.core::fmt::ArgumentV1"*, i64 }* noalias nocapture dereferenceable(16)) unnamed_addr #3 {
entry-block:
  %3 = getelementptr inbounds %"2.core::fmt::Arguments"* %0, i32 0, i32 0
  %4 = bitcast { %str_slice*, i64 }* %1 to i8*
  %5 = bitcast { %str_slice*, i64 }* %3 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %5, i8* %4, i64 16, i32 8, i1 false)
  %6 = getelementptr inbounds %"2.core::fmt::Arguments"* %0, i32 0, i32 1
  %7 = bitcast %"2.core::option::Option<&'static [core::fmt::rt::v1::Argument]>"* %6 to { { i8*, i8* } }*
  %8 = bitcast { { i8*, i8* } }* %7 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %8, i8* bitcast ({ { i8*, i8* } }* @const133 to i8*), i64 16, i32 8, i1 false)
  %9 = getelementptr inbounds %"2.core::fmt::Arguments"* %0, i32 0, i32 2
  %10 = bitcast { %"2.core::fmt::ArgumentV1"*, i64 }* %2 to i8*
  %11 = bitcast { %"2.core::fmt::ArgumentV1"*, i64 }* %9 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* %11, i8* %10, i64 16, i32 8, i1 false)
  ret void
}

; Function Attrs: nounwind
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) unnamed_addr #4

; Function Attrs: uwtable
define internal void @"_ZN3fmt24ArgumentV1$LT$$u27$a$GT$3new21h11701018729727839244E"(%"2.core::fmt::ArgumentV1"* noalias nocapture sret dereferenceable(16), i32* noalias readonly dereferenceable(4), i8 (i32*, %"2.core::fmt::Formatter"*)*) unnamed_addr #0 {
entry-block:
  %x = alloca i32*
  %f = alloca i8 (i32*, %"2.core::fmt::Formatter"*)*
  store i32* %1, i32** %x
  store i8 (i32*, %"2.core::fmt::Formatter"*)* %2, i8 (i32*, %"2.core::fmt::Formatter"*)** %f
  %3 = getelementptr inbounds %"2.core::fmt::ArgumentV1"* %0, i32 0, i32 1
  %4 = load i8 (i32*, %"2.core::fmt::Formatter"*)** %f
  %5 = bitcast i8 (i32*, %"2.core::fmt::Formatter"*)* %4 to i8 (%"2.core::fmt::Void"*, %"2.core::fmt::Formatter"*)*
  store i8 (%"2.core::fmt::Void"*, %"2.core::fmt::Formatter"*)* %5, i8 (%"2.core::fmt::Void"*, %"2.core::fmt::Formatter"*)** %3
  %6 = getelementptr inbounds %"2.core::fmt::ArgumentV1"* %0, i32 0, i32 0
  %7 = load i32** %x, !nonnull !0
  %8 = bitcast i32* %7 to %"2.core::fmt::Void"*
  store %"2.core::fmt::Void"* %8, %"2.core::fmt::Void"** %6
  ret void
}

declare i8 @_ZN3fmt3num14i32.fmt..Debug3fmt20h82571085d6d53e2c8uBE(i32* noalias readonly dereferenceable(4), %"2.core::fmt::Formatter"* noalias dereferenceable(96)) unnamed_addr #1

attributes #0 = { uwtable "split-stack" }
attributes #1 = { "split-stack" }
attributes #2 = { cold noinline noreturn "split-stack" }
attributes #3 = { inlinehint uwtable "split-stack" }
attributes #4 = { nounwind "split-stack" }

!0 = !{}

The text was updated successfully, but these errors were encountered:

Aatch · 2015-02-27T08:01:44Z

Hmm, I can't seem to reproduce with a compiler that is very close to the current master. Could you try with the latest master?

kmcallister · 2015-02-27T16:44:32Z

Yeah, I can't reproduce it anymore on rustc 1.0.0-dev (bd0d8e4 2015-02-27) (built 2015-02-27).

There are lots of things that could cause this. My computer isn't 100% stable (heavy overclock) so that's one possibility.

Still pretty worrying, but I don't know how to proceed with investigating.

kmcallister added I-crash Issue: The compiler crashes (SIGSEGV, SIGABRT, etc). Use I-ICE instead when the compiler panics. A-codegen Area: Code generation I-nominated labels Feb 26, 2015

kmcallister closed this as completed Feb 27, 2015

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Bad codegen with const used on the left of `@` pattern #22850

Bad codegen with const used on the left of `@` pattern #22850

kmcallister commented Feb 26, 2015

Aatch commented Feb 27, 2015

kmcallister commented Feb 27, 2015

Bad codegen with const used on the left of @ pattern #22850

Bad codegen with const used on the left of @ pattern #22850

Comments

kmcallister commented Feb 26, 2015

Aatch commented Feb 27, 2015

kmcallister commented Feb 27, 2015

Bad codegen with const used on the left of `@` pattern #22850

Bad codegen with const used on the left of `@` pattern #22850