Suboptimal debug codegen for integer division with a constant rhs

[alexcrichton]

Codegen for division in general needs to generate code to panic if the division will panic (e.g. divide by zero or integer overflow). In the case of constants, however, it looks like rustc almost optimizes debug codegen but not quite. For example this code:

#[no_mangle]
pub extern fn foo(a: i32) -> i32 {
     a / 256
}

generates this IR in debug mode:

define i32 @foo(i32 %a) unnamed_addr #0 !dbg !6 {
start:
  %a.dbg.spill = alloca i32, align 4
  store i32 %a, i32* %a.dbg.spill, align 4
  call void @llvm.dbg.declare(metadata i32* %a.dbg.spill, metadata !12, metadata !DIExpression()), !dbg !13
  %_4 = icmp eq i32 %a, -2147483648, !dbg !14
  %_5 = and i1 false, %_4, !dbg !14
  %0 = call i1 @llvm.expect.i1(i1 %_5, i1 false), !dbg !14
  br i1 %0, label %panic, label %bb1, !dbg !14

bb1:                                              ; preds = %start
  %1 = sdiv i32 %a, 256, !dbg !14
  ret i32 %1, !dbg !15

panic:                                            ; preds = %start
; call core::panicking::panic
  call void @_ZN4core9panicking5panic17h8a9eda1e10298363E([0 x i8]* noalias nonnull readonly align 1 bitcast ([31 x i8]* @str.0 to [0 x i8]*), i64 31, %"core::panic::Location"* noalias readonly align 8 dereferenceable(24) bitcast (<{ i8*, [16 x i8] }>* @anon.670bbfb7b436af44f45c978390c94a0e.1 to %"core::panic::Location"*)), !dbg !14
  unreachable, !dbg !14
}

It looks like rustc is "smart enough" to generate %_5 = and i1 false, %_4, !dbg !14 to realize the rhs is not negative one and it's not zero, but it's not quite smart enough to know that false && x is always false, so it still generates a branch to panic.

[alex]

I assume the task here is teaching the MIR optimizer to constant fold false && x to false? If someone can suggest where in the codebase such an optimization might live, I'd be interested to take a look.

[xldenis]

fixed by #74491

[camelid]

fixed by #74491

Should this be closed then?

[alex]

This doesn't appear to be fixed by default: https://rust.godbolt.org/z/K8zx5nrYW

[xldenis]

You need to turn on optimizations with -O then it gets reduced to a single sdiv.

https://rust.godbolt.org/z/hfPY1T7x4

define i32 @foo(i32 %a) unnamed_addr #0 !dbg !6 {
  %0 = sdiv i32 %a, 256, !dbg !10
  ret i32 %0, !dbg !11
}

[xldenis]

My bad, I forgot this was about debug builds, it seems like we aren't performing enough mir optimizations in the debug context?

[camelid]

FWIW,

pub fn foo(x: bool) -> bool {
    false && x
}

generates this MIR in debug mode:

// WARNING: This output format is intended for human consumers only
// and is subject to change without notice. Knock yourself out.
fn foo(_1: bool) -> bool {
    debug x => _1;                       // in scope 0 at src/lib.rs:1:12: 1:13
    let mut _0: bool;                    // return place in scope 0 at src/lib.rs:1:24: 1:28

    bb0: {
        _0 = const false;                // scope 0 at src/lib.rs:2:5: 2:15
        return;                          // scope 0 at src/lib.rs:3:2: 3:2
    }
}

So it seems that in simple cases the compiler is smart enough.

[saethlin]

I'm looking into this
@rustbot claim

[oli-obk]

We are causing this issue to occur again: #109900 (comment)

I was unable to find a motivation for fixing this issue beyond "nice to have if easily done". We ususally don't put a lot of effort into avoiding codegen of dead code (like the panic path here). Thus I am not reopening this issue. If you have a motivating use case, please don't hesistate to inform us of it and either open a new issue or comment here to ask for this one to get reopened.