Является ли более высокий уровень волатильности или значительным в прототипе функции?

Question

Есть ли практическая разница между следующими прототипами?

void f(const int *p); 

void f(const int *restrict p); 

void f(const int *volatile p); 

Раздел C11 6.7.6.3/15 (последнее предложение) говорит, что отборочные на высшем уровне, не рассматриваются для целей определения совместимости типа, т.е. допускается для определения функции имеют различный верхнего уровня квалификаторы по своим параметрам, чем декларация прототипа.

Однако (в отличие от C++) он не говорит, что их полностью игнорируют. В случае const это явно спорный вопрос; однако в случае volatile и restrict возможно может быть разница.

Пример:

void f(const int *restrict p); 

int main() 
{ 
    int a = 42; 
    const int *p = &a; 
    f(p); 
    return a; 
} 

наличие restrict в прототипе Допускает ли компилятор оптимизировать из чтения из a для return a;?

(Related question)

Answer 1

Если нет ничего в стандарте, то это до составителей, но мне кажется, что по крайней мере для GCC 4.9 (для x86) они игнорируются. Проверьте этот небольшой фрагмент кода, который я использовал, чтобы дразнить компилятор:

static int b; 

void f(const int *p) { 
    b = *p + 1; 
} 

int main() 
{ 
    int a = 42; 
    const int *p = &a; 
    f(p); 
    return a; 
} 

Если я скомпилировать его как есть, я получаю

f(int const*): 
    pushq %rbp 
    movq %rsp, %rbp 
    movq %rdi, -8(%rbp) 
    movq -8(%rbp), %rax 
    movl (%rax), %eax 
    addl $1, %eax 
    movl %eax, b(%rip) 
    popq %rbp 
    ret 
main: 
    pushq %rbp 
    movq %rsp, %rbp 
    subq $16, %rsp 
    movl $42, -12(%rbp) 
    leaq -12(%rbp), %rax 
    movq %rax, -8(%rbp) 
    movq -8(%rbp), %rax 
    movq %rax, %rdi 
    call f(int const*) 
    movl -12(%rbp), %eax 
    leave 
    ret 

Если я скомпилировать его с помощью аннулируются F (сопзЬ Int * __ restrict__ р) я получаю

f(int const*): 
    pushq %rbp 
    movq %rsp, %rbp 
    movq %rdi, -8(%rbp) 
    movq -8(%rbp), %rax 
    movl (%rax), %eax 
    addl $1, %eax 
    movl %eax, b(%rip) 
    popq %rbp 
    ret 
main: 
    pushq %rbp 
    movq %rsp, %rbp 
    subq $16, %rsp 
    movl $42, -12(%rbp) 
    leaq -12(%rbp), %rax 
    movq %rax, -8(%rbp) 
    movq -8(%rbp), %rax 
    movq %rax, %rdi 
    call f(int const*) 
    movl -12(%rbp), %eax 
    leave 
    ret 

ANF, наконец, если я скомпилировать его с помощью аннулируются F (сопзЬ Int * __ volatile__ р) я получаю

f(int const*): 
    pushq %rbp 
    movq %rsp, %rbp 
    movq %rdi, -8(%rbp) 
    movq -8(%rbp), %rax 
    movl (%rax), %eax 
    addl $1, %eax 
    movl %eax, b(%rip) 
    popq %rbp 
    ret 
main: 
    pushq %rbp 
    movq %rsp, %rbp 
    subq $16, %rsp 
    movl $42, -12(%rbp) 
    leaq -12(%rbp), %rax 
    movq %rax, -8(%rbp) 
    movq -8(%rbp), %rax 
    movq %rax, %rdi 
    call f(int const*) 
    movl -12(%rbp), %eax 
    leave 
    ret 

Таким образом, на практике они игнорируются и на C.

Answer 2

Использование «volatile» по параметру означает перечитать параметр каждый раз, когда он используется, а не просто использовать некоторое ранее прочитанное значение.

Это «обычно» бесполезно по переданному параметру.

Время для «volatile» - это то, что что-то может измениться асинхронно на выполнение кода, например, что-то изменилось при прерывании или значении ввода-вывода.

Прошедшие параметры являются копиями и не изменяются асинхронно.

«Ограничить» обещание кодера, компилятор, что некоторые возможные проблемы могут быть проигнорированы компилятором,

, такими как «Я, кодировщик, обещаю, что области памяти этого вызова к memcpy() не перекрываются.

Так просто используйте их, когда они актуальны, и не используйте их в противном случае.

Answer 3

Предполагая определение f, не имеющее квалификатора restrict, код должен быть четко определен. C11 (n1570) 6.5.2.2 (вызовы функций) p7 [emph. мой, идентичные формулировки в C99 ТС3 (n1256)]

Если выражение, которое обозначает вызываемой функции имеет тип, который действительно включает прототип, аргументы неявно преобразуются, как по заданию, к типам соответствующие параметры, , беря тип каждого параметра в качестве неквалифицированной версии объявленного типа.

Функция f вызываются с неквалифицированными аргументами (и, таким образом, с аргументами правильных типов), и все его заявления имеют совместимый типа (согласно цитате в вопросе): Вызов функции является хорошо определены. (Если в стандарте нет ничего, что явно не определено). Я не думаю, что есть.)