adam10603 adam10603 - 1 year ago 80
C++ Question

Why does -O2 or greater optimization in clang break this code?

I checked similar questions on the site, but I couldn't find anything that matches my scenario here. This is the code I'm trying to run (requires C++14):

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

class countdownTimer {
using duration_t = chrono::high_resolution_clock::duration;

countdownTimer(duration_t duration) : duration{ duration }, paused{ true } {}

countdownTimer(const countdownTimer&) = default;
countdownTimer(countdownTimer&&) = default;
countdownTimer& operator=(countdownTimer&&) = default;
countdownTimer& operator=(const countdownTimer&) = default;

void start() noexcept {
if (started) return;
startTime = chrono::high_resolution_clock::now();
endTime = startTime + duration;
started = true;
paused = false;

void pause() noexcept {
if (paused || !started) return;
pauseBegin = chrono::high_resolution_clock::now();
paused = true;

void resume() noexcept {
if (!paused || !started) return;
auto pauseDuration = chrono::high_resolution_clock::now() - pauseBegin;
startTime += pauseDuration;
endTime += pauseDuration;
paused = false;

double remainingSeconds() const noexcept {
auto ret = double{ 0.0 };
if (!started) ret = chrono::duration_cast<chrono::duration<double>>(duration).count();
else if (paused) ret = chrono::duration_cast<chrono::duration<double>>(duration - (pauseBegin - startTime)).count();
else ret = chrono::duration_cast<chrono::duration<double>>(duration - (chrono::high_resolution_clock::now() - startTime)).count();
return (ret < 0.0) ? 0.0 : ret;

duration_t remainingTime() const noexcept {
auto ret = duration_t{ 0ms };
if (!started) ret = chrono::duration_cast<duration_t>(duration);
else if (paused) ret = chrono::duration_cast<duration_t>(duration - (pauseBegin - startTime));
else ret = chrono::duration_cast<duration_t>(duration - (chrono::high_resolution_clock::now() - startTime));
return (ret < 0ms) ? 0ms : ret;

bool isPaused() const noexcept { return paused; }

bool hasFinished() const noexcept { return remainingTime() == 0s; }

void reset() noexcept {
started = false;
paused = true;

chrono::high_resolution_clock::time_point startTime;
chrono::high_resolution_clock::time_point endTime;
chrono::high_resolution_clock::time_point pauseBegin;
duration_t duration;
bool paused;
bool started;

int main() {
countdownTimer timer(10s);

while (!timer.hasFinished()) {
cout << timer.remainingSeconds() << endl;

It's a simple countdown timer class that I wrote for one of my projects. The client code in
is pretty self-explanatory, it should output a countdown from 10 to 0, and then exit the program. With no optimization or
, it does exactly that:

Program ended with exit code: 0

But if I step up the optimization to >=
, the program just keeps outputting 10, and runs forever. The countdown simply doesn't work, it's stuck at the starting value.

I'm using the latest Xcode on OS X.
clang --version
Apple LLVM version 7.3.0 (clang-703.0.31)

The strange part is that my code doesn't contain any weird self-written loops, undefined behavior, or anything like that, it's pretty much just standard library calls, so it's very strange that optimization breaks it.

Any ideas?

PS: I haven't tried it on other compilers, but I'm about to. I'll update the question with those results.

Answer Source

The bug is in your constructor:

 countdownTimer(duration_t duration)
 : duration{ duration }, paused{ true } {}

You forgot to initialize started. This triggers undefined behavior when you call start().

No version of clang that I have convenient access to will diagnose this error, but GCC versions 5 and 6 (on Linux - I don't have GCC on my Mac anymore) will:

$ g++ -O2 -Wall -Wextra -std=c++14 In function ‘int main()’: warning: ‘*((void*)& timer +33)’ is used uninitialized in this function [-Wuninitialized]
         if (started) return;
             ^~~~~~~ note: ‘*((void*)& timer +33)’ was declared here
     countdownTimer timer(10s);

(My copy of Xcode seems to be a bit out of date, with Apple LLVM version 7.0.2 (clang-700.1.81); it does not change the behavior of the program at -O2. It's possible that your clang would diagnose this error if you turned on the warnings.)

(I have filed a bug report with GCC about the IR gobbledygook in the diagnostics.)

Recommended from our users: Dynamic Network Monitoring from WhatsUp Gold from IPSwitch. Free Download