Dlaczego kompilator Rusta nie optymalizuje kodu przy założeniu, że dwa zmienne odniesienia nie mogą być aliasem?

Z tego, co wiem, aliasing referencji/wskaźników może utrudnić kompilatorowi generowanie zoptymalizowanego kodu, ponieważ musi zapewnić, że wygenerowany plik binarny zachowuje się poprawnie w przypadku, gdy dwa referencje/wskaźniki rzeczywiście alias. Na przykład w następującym kodzie C

void adds(int  *a, int *b) {
    *a += *b;
    *a += *b;
}

Po skompilowaniu przez clang version 6.0.0-1ubuntu2 (tags/RELEASE_600/final) z flagą -O3, emituje

0000000000000000 <adds>:
   0:    8b 07                    mov    (%rdi),%eax
   2:    03 06                    add    (%rsi),%eax
   4:    89 07                    mov    %eax,(%rdi)  # The first time
   6:    03 06                    add    (%rsi),%eax
   8:    89 07                    mov    %eax,(%rdi)  # The second time
   a:    c3                       retq

Tutaj Kod przechowuje się z powrotem do (%rdi) dwa razy w przypadku int *a i int *b aliasu.

Kiedy wyraźnie powiemy kompilator, którego te dwa wskaźniki nie mogą nazwać słowem kluczowym restrict:

void adds(int * restrict a, int * restrict b) {
    *a += *b;
    *a += *b;
}

Wtedy Clang będzie emitował bardziej zoptymalizowaną wersję kodu binarnego:

0000000000000000 <adds>:
   0:    8b 06                    mov    (%rsi),%eax
   2:    01 c0                    add    %eax,%eax
   4:    01 07                    add    %eax,(%rdi)
   6:    c3                       retq

Ponieważ Rust upewnia się (z wyjątkiem kodu unsafe), że dwa zmienne odniesienia nie mogą być aliasem, myślę, że kompilator powinien być w stanie emitować bardziej zoptymalizowaną wersję kodu.

Kiedy testuję z poniższym kodem i kompiluję go z rustc 1.35.0 z -C opt-level=3 --emit obj,

#![crate_type = "staticlib"]
#[no_mangle]
fn adds(a: &mut i32, b: &mut i32) {
    *a += *b;
    *a += *b;
}

It generuje:

0000000000000000 <adds>:
   0:    8b 07                    mov    (%rdi),%eax
   2:    03 06                    add    (%rsi),%eax
   4:    89 07                    mov    %eax,(%rdi)
   6:    03 06                    add    (%rsi),%eax
   8:    89 07                    mov    %eax,(%rdi)
   a:    c3                       retq

To nie korzysta z gwarancji, że a i b nie mogą być używane.

Czy to dlatego, że obecny kompilator Rusta jest nadal w fazie rozwoju i nie włączył jeszcze analizy aliasów do optymalizacji?

Czy to dlatego, że jest jeszcze szansa, że a i b mogą się nazywać, nawet w safe Rust?