Как узнать, согласен ли gcc с тем, что что-то нестабильно?

Многие компиляторы в некоторых ситуациях не обрабатывают volatile должным образом. См. этот документ, если вы много работаете с летучими веществами, чтобы избежать неприятных сюрпризов: Неверная компиляция и что с этим делать. Он также содержит довольно хорошее описание волатильности, подкрепленное цитатами из стандарта.

Чтобы быть на 100% уверенным, и для такого простого примера проверьте вывод сборки.

Попробуйте установить переменную вне цикла и прочитать ее внутри цикла. В энергонезависимом случае компилятор может (или не может) поместить его в регистр или сделать его константой времени компиляции или чем-то еще перед циклом, поскольку он «знает», что он не изменится, тогда как, если он изменчив, он будет читать его из пространства переменных каждый раз через цикл.

По сути, когда вы объявляете что-то изменчивым, вы говорите компилятору не выполнять определенные оптимизации. Если он решил не делать эти оптимизации, вы не знаете, знаете, что он их не сделал, потому что он был объявлен изменчивым, или просто решил, что эти регистры нужны ему для чего-то другого, или он не сделал этого. не заметил, что это может превратить его в константу времени компиляции.

Насколько я знаю, volatile помогает оптимизатору. Например, если ваш код выглядел так:

int foo() {
    int x = 0;
    while (x);
    return 42;
}

Цикл while будет оптимизирован из двоичного кода.

Но если вы определите 'x' как изменчивый (т.е. volatile int x;), то компилятор оставит цикл в покое.

Ваш маленький образец не может ничего показать. Разница между изменчивой переменной и той, которая не является таковой, заключается в том, что каждая загрузка или сохранение в коде должна генерировать ровно одну загрузку или сохранение в исполняемом файле для изменчивой переменной, в то время как компилятор может оптимизировать загрузку или сохранение неиспользуемых переменных. -изменчивые переменные. Если вы получаете одну загрузку i в своем образце, это то, что я ожидаю от изменчивого и энергонезависимого.

Чтобы показать разницу, вам понадобятся избыточные нагрузки и/или хранилища. Попробуйте что-то вроде

int i = 5;
int j = i + 2;
i = 5;
i = 5;
printf("%d %d\n", i, j);

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

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

Он должен всегда считать его изменчивым.

Причина того, что код один и тот же, заключается в том, что volatile просто указывает компилятору загружать переменную из памяти каждый раз, когда он к ней обращается. Даже при включенной оптимизации компилятору по-прежнему необходимо один раз загрузить i из памяти в написанном вами коде, потому что он не может вывести значение i во время компиляции. Если вы будете обращаться к нему повторно, вы увидите разницу.

Любой современный компилятор имеет несколько этапов. Один из довольно простых, но интересных вопросов — правильно ли проанализировано объявление самой переменной. Это легко, потому что изменение имени C++ должно различаться в зависимости от изменчивости. Следовательно, если вы скомпилируете дважды, один раз с определением volatile, таблицы символов должны немного отличаться.

Прочтите стандарт, прежде чем неправильно цитировать или ставить минус. Вот цитата из n2798:

7.1.6.1 Квалификаторы cv

7 Примечание: volatile — это подсказка реализации, чтобы избежать агрессивной оптимизации с участием объекта, поскольку значение объекта может быть изменено средствами, не обнаруживаемыми реализацией. Подробную семантику см. в 1.9. В общем, семантика volatile должна быть такой же в C++, как и в C.

Ключевое слово volatile действует как подсказка. Очень похоже на ключевое слово register. Однако volatile просит компилятор не использовать все оптимизации. Таким образом, он не будет хранить копию переменной в регистре или кэше (для оптимизации скорости доступа), а будет извлекать ее из памяти каждый раз, когда вы ее запрашиваете.

Раз так много путаницы: еще немного. Стандарт C99 на самом деле говорит, что изменчивый квалифицированный объект необходимо искать каждый раз, когда он читается, и так далее, как отмечали другие. Но есть еще один раздел, в котором говорится, что то, что представляет собой изменчивый доступ, определяется реализацией. Таким образом, компилятор, который знает аппаратное обеспечение наизнанку, будет знать, например, когда у вас есть автоматическая изменчивая квалифицированная переменная и адрес которой никогда не берется, что она не будет помещена в чувствительную область памяти и почти наверняка проигнорирует подсказку и оптимизировать ее.

Это ключевое слово находит применение в setjmp и longjmp типах обработки ошибок. Единственное, что вы должны иметь в виду, это то, что вы указываете ключевое слово volatile, когда считаете, что переменная может измениться. То есть можно было взять обычный предмет и обойтись несколькими слепками.

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

Если вы действительно хотели компилировать другую сборку с оптимизацией