Funzione volatile

Question

Sommario: Che cosa fa la parola chiave volatile quando viene applicata a una dichiarazione di funzione in C e in C++?

Dettagli:

vedo che è possibile compilare una funzione che è contrassegnato come volatile. Tuttavia, non sono sicuro di cosa sia l'ottimizzazione del compilatore (se presente). Per esempio ho creato il seguente test case:

volatile int foo() { 
    return 1; 
} 

int main() { 
    int total = 0; 
    int i = 0; 
    for(i = 0; i < 100; i++) { 
    total += foo(); 
    } 

    return total; 
} 

Quando compilo con clang -emit-llvm -S -O3 test.c (gcc potrebbe anche funzionare, ma il IR LLVM è più leggibile a mio parere) ottengo:

target triple = "x86_64-unknown-linux-gnu" 

define i32 @foo() #0 { 
    ret i32 1 
} 

define i32 @main() #0 { 
    ret i32 100 
} 

Così, ovviamente la il compilatore è stato in grado di ottimizzare le chiamate alla funzione foo() in modo che main() restituisca una costante, anche se foo() è contrassegnato come volatile. Quindi la mia domanda è se lo volatile fa qualcosa quando viene applicato a una dichiarazione di funzione in termini di limitazione delle ottimizzazioni del compilatore.

(Nota il mio interesse per questa domanda è in gran parte la curiosità di capire che cosa volatile fa, piuttosto che per risolvere qualsiasi problema specifico.)

(Anche io ho segnato questa domanda sia come C e C++ non perché penso che siano la stessa lingua, ma perché mi interessa sapere se ci sono differenze in ciò che volatile fa in questo caso in queste due lingue).

Answer 1

Nel codice, la parola chiave volatile non si applica alla funzione, ma per il tipo di ritorno, è l'equivalente di:

typedef volatile int Type; 
Type foo(); 

Ora, in C++ è possibile effettuare una funzione di membrovolatile , nello stesso modo in cui il qualificatore const, e il comportamento è lo stesso:

struct test { 
    void vfunction() volatile; 
}; 

in sostanza non si può chiamare una funzione non volatile (alterantively non edificati) su un istanza volatile (const rispettivamente) del tipo:

struct test { 
    void vfunction() volatile; 
    void function(); 
}; 
volatile test t; 
t.vfunction();  // ok 
t.function();  // error 

Answer 2

foo() non è volatile.

È una funzione che restituisce un volatile int.

Quale è legale. Ma strano per un restituito int.

Le funzioni membro, d'altra parte, possono essere volatile per la stessa ragione per cui possono essere const.