LLVM pessimises vtable loads.

[Aatch]

This code contains two offset calculations and two function pointer loads:

#![crate_type="lib"]

pub struct Wrapper<T: ?Sized> {
    x: usize,
    y: usize,
    t: T
}

pub trait Foo {
    fn foo(&self);
}

pub fn test(foo: &Wrapper<Foo>) {
    foo.t.foo();
    foo.t.foo();
}

Playpen

LLVM should be able to remove all but the first occurrences via common subexpression elimination, but for some reason it reloads from the vtable pointer each time. The only reasonable explanation I can think of is that LLVM assumes that the vtable pointer may alias some pointer that the called function manipulates.

[Aatch]

/cc @rust-lang/compiler

[dpc]

Any way to help LLVM move vtable stuff out of a tight loop?

This playrust:

#![crate_type="lib"]

use std::sync::Arc;

pub struct Wrapper {
    x: usize,
    y: usize,
    t: Arc<Foo>,
}

pub trait Foo {
    fn foo(&self);
}

pub fn test(foo: Wrapper) {
    for _ in 0..200 {
        foo.t.foo();
    }
}

Generates the tight loop:

.LBB1_1:
	incl	%ebp
	cmpl	$200, %ebp
	jge	.LBB1_2
	movq	16(%rbx), %rdi
	movq	24(%rbx), %rax
	leaq	15(%rdi), %rcx
	negq	%rdi
	andq	%rcx, %rdi
	addq	%r12, %rdi
.Ltmp12:
	callq	*%rax
.Ltmp13:
	jmp	.LBB1_1

while it seems to me the vtable access should be out of the loop, and it shouldn't be hard...