$ cat code.cpp
#include <stdio.h>
int main(int argc, char* argv[]) { g(); return 0; }
void g() { while(1) {} }
void f() { printf("melt the reactor core!\n"); }

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

$ clang++ -O1 -Wall -Werror code.cpp && ./a.out
melt the reactor core!

"Объяснение" следующее: стандарт С++ требует, чтобы все нити в программе удовлетворяли условиям прогресса. То есть чтобы в них нечто происходило. Вечный цикл без внешних эффектов считается отсутствием прогресса (что ошибочно с логической точки зрения, это известно уже лет 40); и, следовательно, считается неопределённым поведением (undefined behaviour, или UB). Логика разработчиков компиляторов C++ такая: в случае UB компилятор может творить всякую дичь, в том числе и выкидывать такой вечный цикл из кода.

Думаю, это сделано потому, что разработчики C++ уж очень хотят оставить за собой статус "оптимизатейшего из оптимизатейших" языка программирования. И это тщеславие приводит их к необходимости применять некоторые некорректные трансформации кода.

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

for (node p = list; p; p = p->next) { do_something_1(); }
for (node p = list; p; p = p->next) { do_something_2(); }

на

for (node p = list; p; p = p->next) { do_something_1(); do_something_2(); }

Думаю, их тревожат лавры Haskell и других языков, в которых возможны (и корректны!) fusion-оптимизации.

Но в C++ это преобразование некорректное (с точки зрения банальной эрудиции), потому что list может быть циклическим списком и семантика кода после такого объединения меняется. Код do_something_2() может быть недостижим, в зависимости от структуры list. Но комитет стандартизации C++ в лучших традициях поговорки "если нельзя, но очень хочется, то можно" говорит такой: чтобы сделать такое преобразование корректным, объявим вечные циклы UB, и разрешим компилятору делать всё, что угодно.

Компилятор, освобождённый от оков здравого смысла, в исходном примере

#include <stdio.h>
int main(int argc, char* argv[]) { g(); return 0; }
void g() { while(1) {} }
void f() { printf("melt the reactor core!\n"); }

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

Но история не кончается. Clang выбрасывает код своеобразно.

1. Компилятор видит вечный цикл, втыкает после него инструкцию LLVM unreachable, означающую, что до неё исполнение не дойдёт, а потом выкидывает сам цикл. То есть управление таки теперь до unreachable доходит!

2. Кодогенератор LLVM видит unreachable, и такой: о! жизнь прекрасна, можно выкинуть теперь весь код, который следует за unreachable, в том числе и конструкции возврата из g.

3. Хопа-хопа-хопа — и код отмеченный меткой g пропал из ассемблера (объектного файла). Теперь g указывает на то место в памяти, в котором расположен код f.

Это bug в компиляторе: управление передаётся на код, на который управление никогда не передаётся. Инженеры из Samsung считают, что это не bug, а feature: раз в стандарте написано, что это UB, значит, компилятор может творить всякую дичь. А я всё думал, отчего качество ПО в последнее время в устройствах от Samsung такое низкое. Теперь понятно: его пишут настоящие титаны мысли!

Почему такое поведение компилятора дичь, даже если это UB?

Потому что while(1) {} — это вырожденный пример. Легко себе представить ситуацию, когда цикл будет выглядеть так: while(some_insane_condition()) { … }. Программист может просто не видеть, что some_insane_condition() эквивалентно true. Например, потому что кто-то поменял какие-то макроопределения или константы в отдельных модулях или библиотеках, скачиваемых из интернета, а код компилируется с LTO. Компилятор видит, что условие всегда истинно, без предупреждения (sic!!!) не только выкидывает код, но смешивает имена функций (в этом месте всё внутри вас должно завопить от ужаса, как на картине Мунка), и ваш чёртов реактор взрывается!

В этой истории всё прекрасно. И позиция комитета по стандартизации, который вслепую подкручивает семантику языка в случайных, никак не обоснованных, направлениях при помощи UB. И позиция инженеров Clang, агрессивно не признающих свои ошибки, прикрывающихся концепцией UB. И сам C++, сложность и рассогласованность которого, видимо, достигли таких эпических масштабов, что комитету проще ввести UB за номером 100501, а инженерам закрыть глаза на ошибки, чем сделать нормально.

Ужас, короче. Я настолько фрустрирован ситуацией, что иду убирать C++ из списка языков, на которых готов работать. Потому что отлаживать такие вот ситуации просто невообразимо, ППЦ как, тяжело.

Уж лучше тогда Rust, чем вот это вот всё.