Оптимизация компилятора C/C++: лучше ли создавать новые переменные, повторно использовать существующие или вообще избегать переменных?

Я всегда задавался вопросом: легче ли компилятору оптимизировать функции, в которых повторно используются существующие переменные, где создаются новые (в идеале const) промежуточные переменные или где вместо создания переменных вместо прямого использования выражений?

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

// 1. Use expression as and when needed, no new variables
void MyFunction1(int a, int b)
{
    SubFunction1(a + b);
    SubFunction2(a + b);
    SubFunction3(a + b);
}

// 2. Re-use existing function parameter variable to compute
// result once, and use result multiple times.
// (I've seen this approach most in old-school C code)
void MyFunction2(int a, int b)
{
    a += b;
    
    SubFunction1(a);
    SubFunction2(a);
    SubFunction3(a);
}

// 3. Use a new variable to compute result once,
// and use result multiple times.
void MyFunction3(int a, int b)
{
    int sum = a + b;
    
    SubFunction1(sum);
    SubFunction2(sum);
    SubFunction3(sum);
}

// 4. Use a new const variable to compute result once,
// and use result multiple times.
void MyFunction4(int a, int b)
{
    const int sum = a + b;
    
    SubFunction1(sum);
    SubFunction2(sum);
    SubFunction3(sum);
}

Моя интуиция такова:

• В этой конкретной ситуации функцию 4 оптимизировать проще всего, поскольку в ней явно указывается намерение использовать данные. Он сообщает компилятору: «Мы суммируем два входных аргумента, результат которых не будет изменен, и мы передаем результат идентичным образом при каждом последующем вызове функции». Я ожидаю, что значение переменной sum будет просто помещено в регистр, и фактического доступа к базовой памяти не произойдет.
• Функция 1 является следующей по простоте оптимизации, хотя она требует большего количества выводов со стороны компилятора. Компилятор должен определить, что a + b используется одинаковым образом для каждого вызова функции, и он должен знать, что результат a + b идентичен при каждом использовании этого выражения. Я бы по-прежнему ожидал, что результат a + b будет помещен в регистр, а не зафиксирован в памяти. Однако, если бы входные аргументы были более сложными, чем простые ints, я вижу, что их было бы сложнее оптимизировать (правила для временных аргументов применялись бы для C++).
• Функция 3 является следующей по простоте после нее: результат не помещается в переменную const, но компилятор видит, что sum нигде в функции не изменяется (при условии, что последующие функции не берут на нее изменяемую ссылку), поэтому он может просто сохранить значение в регистре, как и раньше. Однако это менее вероятно, чем в случае с функцией 4.
• Функция 4 оказывает наименьшую помощь в оптимизации, так как напрямую изменяет входящий аргумент функции. Я не уверен на 100%, что здесь сделает компилятор: я не думаю, что неразумно ожидать, что он будет достаточно умным, чтобы заметить, что a больше нигде в функции не используется (аналогично sum в функции 3), но Я бы не стал этого гарантировать. Это может потребовать изменения памяти стека в зависимости от того, как передаются аргументы функции (я не слишком хорошо знаком с тонкостями работы вызовов функций на этом уровне детализации).

Верны ли мои предположения? Есть ли еще факторы, которые следует учитывать?

Обновлено: Пара пояснений в ответ на комментарии:

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