I compilatori C++ possono ottimizzare le chiamate di funzioni virtuali ripetute sullo stesso puntatore?

Question

Supponiamo che io ho il seguente codice

void f(PolymorphicType *p) 
{ 
    for (int i = 0; i < 1000; ++i) 
    { 
     p->virtualMethod(something); 
    } 
} 

volontà del compilatore codice generato dereferenziare p s' vtable voce per virtualMethod 1 o 1000 volte? Sto usando il compilatore di Microsoft.

modificare

Ecco l'assembly generato per il caso del mondo reale che sto guardando. line->addPoint() è il metodo di preoccupazione virtuale. Non ho esperienza di assemblaggio, quindi lo sto esaminando lentamente ...

; 369 :  for (int i = 0; i < numPts; ++i) 

    test ebx, ebx 
    je SHORT $LN1@RDS_SCANNE 
    lea edi, DWORD PTR [ecx+32] 
    npad 2 
$LL3@RDS_SCANNE: 

; 370 :  { 
; 371 :   double *pts = pPoints[i].SystemXYZ; 
; 372 :   line->addPoint(pts[0], pts[1], pts[2]); 

    fld QWORD PTR [edi+8] 
    mov eax, DWORD PTR [esi] 
    mov edx, DWORD PTR [eax+16] 
    sub esp, 24     ; 00000018H 
    fstp QWORD PTR [esp+16] 
    mov ecx, esi 
    fld QWORD PTR [edi] 
    fstp QWORD PTR [esp+8] 
    fld QWORD PTR [edi-8] 
    fstp QWORD PTR [esp] 
    call edx 
    add edi, 96     ; 00000060H 
    dec ebx 
    jne SHORT $LL3@RDS_SCANNE 
$LN314@RDS_SCANNE: 

; 365 :  } 

Answer 1

In generale, no, non è possibile. La funzione potrebbe distruggere *this e posizionare-nuovi alcuni altri oggetti derivati ​​dalla stessa base in quello spazio.

Modifica: ancora più semplice, la funzione potrebbe cambiare solo p. Il compilatore non può sapere chi ha l'indirizzo di p, a meno che non sia locale all'unità di ottimizzazione in questione.

Answer 2

Impossibile in generale, ma ci sono casi speciali che possono essere ottimizzati, in particolare con l'analisi inter-procedurale. VS2012 con le ottimizzazioni pieno e l'ottimizzazione intero programma viene compilato questo programma:

#include <iostream> 

using namespace std; 

namespace { 
struct A { 
    virtual void foo() { cout << "A::foo\n"; } 
}; 

struct B : public A { 
    virtual void foo() { cout << "B::foo\n"; } 
}; 

void test(A& a) { 
    for (int i = 0; i < 100; ++i) 
    a.foo(); 
} 
} 

int main() { 
    B b; 
    test(b); 
} 

a:

01251221 mov   esi,64h 
01251226 jmp   main+10h (01251230h) 
01251228 lea   esp,[esp] 
0125122F nop 
01251230 mov   ecx,dword ptr ds:[1253044h] 
01251236 mov   edx,12531ACh 
0125123B call  std::operator<<<std::char_traits<char> > (012516B0h) 
01251240 dec   esi 
01251241 jne   main+10h (01251230h) 

in modo che sia efficace ottimizzato il ciclo per:

for(int i = 0; i < 100; ++i) 
    cout << "B::foo()\n";