Um compilador C / C ++ pode armazenar em cache legalmente uma variável em um registro em uma chamada de biblioteca pthread?

Suponha que tenhamos o seguinte bit de código:

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void guarantee(bool cond, const char *msg) {
    if (!cond) {
        fprintf(stderr, "%s", msg);
        exit(1);
    }
}

bool do_shutdown = false;   // Not volatile!
pthread_cond_t shutdown_cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_t shutdown_cond_mutex = PTHREAD_MUTEX_INITIALIZER;

/* Called in Thread 1. Intended behavior is to block until
trigger_shutdown() is called. */
void wait_for_shutdown_signal() {

    int res;

    res = pthread_mutex_lock(&shutdown_cond_mutex);
    guarantee(res == 0, "Could not lock shutdown cond mutex");

    while (!do_shutdown) {   // while loop guards against spurious wakeups
        res = pthread_cond_wait(&shutdown_cond, &shutdown_cond_mutex);
        guarantee(res == 0, "Could not wait for shutdown cond");
    }

    res = pthread_mutex_unlock(&shutdown_cond_mutex);
    guarantee(res == 0, "Could not unlock shutdown cond mutex");
}

/* Called in Thread 2. */
void trigger_shutdown() {

    int res;

    res = pthread_mutex_lock(&shutdown_cond_mutex);
    guarantee(res == 0, "Could not lock shutdown cond mutex");

    do_shutdown = true;

    res = pthread_cond_signal(&shutdown_cond);
    guarantee(res == 0, "Could not signal shutdown cond");

    res = pthread_mutex_unlock(&shutdown_cond_mutex);
    guarantee(res == 0, "Could not unlock shutdown cond mutex");
}

Um compilador C / C ++ compatível com os padrões pode armazenar em cache o valor dedo_shutdown em um registro na chamada parapthread_cond_wait()? Caso contrário, quais normas / cláusulas garantem isso?

O compilador poderia hipoteticamente saber quepthread_cond_wait() não modificado_shutdown. Parece improvável, mas não conheço nenhum padrão que o impeça.

Na prática, qualquer compilador C / C ++ armazena em cache o valor dedo_shutdown em um registro na chamada parapthread_cond_wait()?

Quais chamadas de função é garantida ao compilador para não armazenar em cache o valor dedo_shutdown através? É claro que, se a função for declarada externamente e o compilador não puder acessar sua definição, ele não deverá fazer suposições sobre seu comportamento, para que não possa provar que não acessado_shutdown. Se o compilador puder incorporar a função e provar que não acessado_shutdown, então ele pode armazenar em cachedo_shutdown mesmo em uma configuração multithread? Que tal uma função não embutida na mesma unidade de compilação?