Почему компиляторы C ++ не оптимизируют это условное логическое присваивание как безусловное?

Рассмотрим следующую функцию:

void func(bool& flag)
{
    if(!flag) flag=true;
}

Мне кажется, что если флаг имеет допустимое логическое значение, это будет эквивалентно безусловной установке его на true, например:

void func(bool& flag)
{
    flag=true;
}

Однако ни gcc, ни clang не оптимизируют это таким образом - оба генерируют следующее на -O3уровне оптимизации:

_Z4funcRb:
.LFB0:
    .cfi_startproc
    cmp BYTE PTR [rdi], 0
    jne .L1
    mov BYTE PTR [rdi], 1
.L1:
    rep ret

Мой вопрос: просто ли код слишком особенный, чтобы его можно было оптимизировать, или есть какие-то веские причины, по которым такая оптимизация была бы нежелательной, учитывая, что flagэто не ссылка volatile? Кажется, единственная причина, которая может быть, состоит в том, что flagможет каким-то образом иметь значение, отличное от trueили, falseбез неопределенного поведения в момент его чтения, но я не уверен, возможно ли это.

Это может отрицательно сказаться на производительности программы из-за соображений согласованности кеша . Запись в flagкаждый func()вызов будет загрязнять содержащуюся строку кэша. Это произойдет независимо от того, что записываемое значение точно соответствует битам, найденным в адресе назначения до записи.

РЕДАКТИРОВАТЬ

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

После небольшого размышления я могу предложить еще один пример, почему компиляторам следует строго запретить - если они не могут доказать, что преобразование безопасно для конкретного контекста - вводить безусловную запись. Рассмотрим этот код:

const bool foo = true;

int main()
{
    func(const_cast<bool&>(foo));
}

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

Помимо ответа Леона о производительности:

Предположим , что flagесть true. Предположим, что два потока постоянно звонят func(flag). В этом случае функция в том виде, в котором она написана, ничего не сохраняет flag, поэтому она должна быть потокобезопасной. Два потока обращаются к одной и той же памяти, но только для ее чтения. Безоговорочно установки flagс trueпомощью двух разных потоков будет написание одной и той же памяти. Это небезопасно, это небезопасно, даже если записываемые данные идентичны данным, которые уже есть.

Я не уверен в поведении C ++ здесь, но в C память может измениться, потому что, если память содержит ненулевое значение, отличное от 1, оно останется неизменным при проверке, но изменится на 1 при проверке.

Но поскольку я не очень хорошо владею C ++, я не знаю, возможна ли такая ситуация.