iter_mut codegen

[macpp]

https://godbolt.org/z/v7fq5q7q8
following code:

pub fn example(x: &mut [f32; 1024]) {
    for x in x.iter_mut() {
        *x *= 4.0;
    }
}

when compiled with codegen_gcc gives following assembly:

example::example:
        test    rdi, rdi
        je      .L6
        movss   xmm1, DWORD PTR .LC0[rip]
        lea     rax, 4092[rdi]
        jmp     .L9
.L19:
        add     rdi, 4
        je      .L6
.L9:
        movss   xmm0, DWORD PTR [rdi]
        mulss   xmm0, xmm1
        movss   DWORD PTR [rdi], xmm0
        cmp     rdi, rax
        jne     .L19
.L6:
        ret
.LC0:
        .long   1082130432

compared to llvm codegen, it seems (at least to me, but i'm definietly not an asm expert) that:

• llvm version is vectorised, gcc not
• while llvm version has 1 label and conditional jump (which is not suprisings for simple loop), gcc version seems unnecessary convoluted, with 3 labels and 4 jump instructions
• gcc version starts with something that looks like a null check , which is strange given that &mut cannot be null

i'm not sure if this is really a problem, but i figured out it is worth asking :)

Anyway, thank you for working on this project, it is really exciting development :)

[antoyo]

For now, the gcc codegen is indeed less optimized than the LLVM one. Optimization is not the priority for now, but thanks for posting this.
I'll take a look at optimization issues when the codegen is correct and all features are implemented.
Some of those features (like LTO and taking into account arch-specific features like SSE) will also improve the generated code ;) .

[antoyo]

When compiled locally (with a sysroot compiled in release mode, which is not the case on Compiler Explorer, which is currently broken, so it doesn't have the latest version), I get the following:

0000000000000000 <_RNvCs5FGpxVWlxX1_9test_rust15my_simd_example>:
   0:	c5 fa 10 0d 00 00 00 	vmovss xmm1,DWORD PTR [rip+0x0]        # 8 <_RNvCs5FGpxVWlxX1_9test_rust15my_simd_example+0x8>
   7:	00
   8:	48 8d 87 00 10 00 00 	lea    rax,[rdi+0x1000]
   f:	c5 f2 59 07          	vmulss xmm0,xmm1,DWORD PTR [rdi]
  13:	48 83 c7 04          	add    rdi,0x4
  17:	c5 fa 11 47 fc       	vmovss DWORD PTR [rdi-0x4],xmm0
  1c:	48 39 c7             	cmp    rdi,rax
  1f:	75 ee                	jne    f <_RNvCs5FGpxVWlxX1_9test_rust15my_simd_example+0xf>
  21:	c3                   	ret

So the superfluous jumps and the null check disappeared (probably since we now support the nonnull attribute).
It could be worth checking if a C example compiled with GCC would auto-vectorize the code to see if this is an issue in GCC or this project.