las variables volátiles como argumento para funcionar

Question

Tener este código:

typedef volatile int COUNT;  

COUNT functionOne(COUNT *number); 

int functionTwo(int *number); 

no puedo deshacerme de algunas advertencias ..

consigo esta advertencia en 1 functionOne prototipo

[ Advertencia] type calificadores ignorados en función return type

y me da esta advertencia 2, donde quiera que llamo functionTwo con un puntero RECUENTO argumento en lugar de un puntero int

[advertencia] fundido descarta calificadores del tipo de destino puntero

, obviamente, las variables/los punteros no se pueden "convertir" a volátiles/no volátiles ... ¿pero cada argumento debe especificarse también como volátil? Entonces, ¿cómo puedo usar cualquier función de biblioteca si ya está definida para una variable no volátil?

EDITAR: Usando gcc -std=c99 -pedantic -Wall -Wshadow -Wpointer-arith -Wcast-qual -Wextra -Wstrict-prototypes -Wmissing-prototypes …

EDITAR: Después de consejos Jukka Suomela este es un ejemplo de código de advertencia de dos

typedef volatile int COUNT;  

static int functionTwo(int *number) { 
    return *number + 1; 
} 

int main(void) { 
    COUNT count= 10; 
    count = functionTwo(&count); 
    return 0; 
} 

Answer 1

Es posible que esté fuera de lugar aquí, pero ISN volátil' t algo normalmente asociado con la región de memoria de la pila. Por lo tanto, no estoy seguro si el siguiente prototipo realmente tiene mucho sentido.

volatile int functionOne(volatile int number); 

No estoy seguro de cómo un número entero devuelto puede ser volátil. ¿Qué hará que cambie el valor de EAX? Lo mismo aplica para el entero. Una vez que se coloca el valor en la pila para que pueda pasar como parámetro, ¿qué cambiará su valor?

Answer 2

Es posible que quienes lo escribieron quisieron asegurarse de que todas las operaciones son atómicas y declararon todas las variables int como volátiles (¿es una aplicación MT con mala sincronización?), Por lo que se declaran todas las entradas del código como volátil "por consistencia".

O tal vez al declarar el tipo de función como volátil, esperan detener las optimizaciones de las llamadas repetidas para funciones puras? Un incremento de una variable estática dentro de la función lo resolvería. Sin embargo, trate de adivinar su intención original, porque esto simplemente no tiene ningún sentido.

Answer 3

Si Compilo

typedef volatile int COUNT;  

static int functionTwo(int number) { 
    return number + 1; 
} 

int main(void) { 
    COUNT count = 10; 
    count = functionTwo(count); 
    return 0; 
} 

usando

gcc -std=c99 -pedantic -Wall -Wshadow -Wpointer-arith -Wcast-qual \ 
-Wextra -Wstrict-prototypes -Wmissing-prototypes foo.c 

no consigo ninguna advertencia. Intenté gcc 4.0, 4.2, 4.3 y 4.4. Tu advertencia suena como si estuvieras pasando punteros, no valores, y esa es otra historia ...

EDIT:

Su último ejemplo se debe escribir como esto; de nuevo, no hay advertencias:

typedef volatile int COUNT; 

static int functionTwo(COUNT *number) { return *number + 1; } 

int main(void) { COUNT count = 10; count = functionTwo(&count); return 0; } 

EDIT:

Si no puede cambiar functionTwo:

typedef volatile int COUNT; 

static int functionTwo(int *number) { return *number + 1; } 

int main(void) { 
    COUNT count= 10; 
    int countcopy = count; 
    count = functionTwo(&countcopy); 
    return 0; 
} 

Tenga en cuenta que cualquier acceso a una variable volátil es "especial". En la primera versión con functionTwo(COUNT *number), la función Dos sabe cómo acceder correctamente. En la segunda versión con countcopy, la función principal sabe cómo acceder correctamente al asignar countcopy = copy.

Answer 4

No entiendo por qué querría tener el calificador volatile en un tipo de devolución de función. La variable a la que le asigna el valor de retorno de la función debe escribirse como volatile.

trate de hacer estos cambios:

typedef int COUNT_TYPE; 
typedef volatile COUNT_TYPE COUNT;  

COUNT_TYPE functionOne(COUNT number); 

COUNT_TYPE functionTwo(COUNT_TYPE number); 

Y al llamar functionTwo(), convierta explícitamente el argumento:

functionTwo((COUNT_TYPE)arg); 

HTH, Ashish.

Answer 5

La palabra clave volatile se diseñó para aplicarse a objetos que representan almacenamiento y no a funciones. Devolver un volatile int desde una función no tiene mucho sentido. El valor de retorno de una función no se optimizará (con la posible excepción de las funciones en línea, pero ese es otro caso completo ...), y ningún actor externo lo modificará. Cuando una función regresa, pasa una copia del valor de retorno a la función de llamada. Una copia de un objeto volatile no es ella misma volatile. Por lo tanto, intentar devolver un volatile int dará como resultado una copia, fundiéndolo en un no volátil int, que es lo que está activando los mensajes del compilador. Devolver un volatile int* puede ser útil, pero no un volatile int.

Pasar un objeto por valor a una función hace una copia del objeto, por lo tanto, usar un volatile int como parámetro de función implica necesariamente una conversión que ignora un calificador. Pasar una dirección volátil por es perfectamente razonable, pero no por valor.

De acuerdo con la especificación C, el comportamiento de volatile depende completamente de la implementación, por lo tanto, YMMV.

¿Está utilizando volatile de esta manera para tratar de vencer a algún tipo de optimización del compilador? Si es así, probablemente haya una mejor manera de hacerlo.

Editar: Teniendo en cuenta los cambios a su pregunta, parece que usted puede ser capaz de acercarse a esto de una manera diferente. Si intentas vencer las optimizaciones del compilador, ¿por qué no tomar el enfoque directo y simplemente decirle al compilador que no optimice algunas cosas? Puede usar #pragma GCC optimize o __attribute__((optimize)) para proporcionar parámetros de optimización específicos para una función. Por ejemplo, __attribute__((optimize(0))) debe deshabilitar todas las optimizaciones para una función dada.De esta forma, puede mantener sus tipos de datos no volátiles y evitar los problemas de tipo que tiene. Si deshabilitar todas las optimizaciones es demasiado, también puede activar o desactivar las opciones de optimización individuales con ese atributo/pragma.

Editar: yo era capaz de compilar el código siguiente sin ningún tipo de advertencias o errores:

static int functionTwo(int *number) { 
    return *number + 1; 
} 

typedef union { 
       int i; 
    volatile int v; 
} fancy_int; 

int main(void) { 
    fancy_int count; 
    count.v = 10; 
    count.v = functionTwo(&count.i); 
    return 0; 
} 

Este piratear "técnica" probablemente tiene algún tipo de efectos secundarios extraños, por lo que probarlo completamente antes de uso de producción. Lo más probable es que no sea diferente a la conversión directa de la dirección a (int*), pero no activa ninguna advertencia.