Удивительное рядом, но оно не определено

[spamsink]

Задачка для оптимизирующих программистов (по крайней мере на C++)

В предположении, что компилятор делает все разрешенные стандартом оптимизации, что будет (если будет) напечатано в результате выполнения следующего участка кода (обвязку пишите сами):

    int *p = (int*)malloc(4);
    int *q = (int*)realloc(p, 4);
    *p = 1;
    *q = 2;
    if (p == q) {
        printf("%d %d\n", *p, *q);
    }

Comments

[yigal_s]

Строго говоря, будет всё что угодно в пределах возможностей компьютера.

[spamsink]

Нет, если оптимизации будут выполнены, то всё undefined behavior будет ликвидировано.

[yigal_s]

Мммм... Позволю себе не согласиться.

Стандарт (да благословит его Аллах) не определяет что такое "оптимизации" и как именно эти оптимизации делаются. Применение оптимизации не меняет наличия или отсутствия UB.

Хм

[krakozabr.livejournal.com]

Я не оптимизирующий программист.

Но доступные мне (различные) компиляторы делали одно и то же:

2 2

Re: Хм

[spamsink]

Внизу febb пишет, что уже доступен компилятор, делающий подразумеваемую оптимизацию ("1 2").

[b0p0h0k.livejournal.com]

Не вижу причин для не "2 2".

Оговорка: я не сильно много знаю про xx-rated C, так что глядел на это в парадигме C.

[spamsink]

Очень может быть, что и в режиме какого-нибудь нового С оптимизация будет та же, и получится "1 2". Вопрос для размышления: что именно разрешает компилятору так сделать?

[archaicos.livejournal.com]

Жулики. Комитетчики и компиляторщики. UB со всеми вытекающими.

Кстати, ролик вышел некоторое время назад (блин, там столько вывалили! смотреть - не пересмотреть), можно было не ходить, а смотреть тюбик в халате и тапках, попивая чай.

[spamsink]

Это мы знаем, что формально там есть UB, а компилятор этого не знает, и стандарт ему говорит думать про другое, отсюда и все лулзы.

[archaicos.livejournal.com]

Стандарт говорит очень забавно, примерно как «Видишь кролика? Нет? А он есть!». С одной стороны, указатель не меняется, но с другой стороны формально жизнь не очень-то существовавшего объекта прерывается, и формально же указатель перестаёт указывать туда, куда он продолжает указывать. Форменное издевательство!

[yigal_s]

а что там где вывалили?

CppCon 2016

[archaicos.livejournal.com]

Обсуждаемое есть на видео в списке (“My Little Optimizer: Undefined Behavior is Magic").

[febb.livejournal.com]

Наверное realloc оставит всё как есть.
Тогда программа напечатает: "2 2\n"

[febb.livejournal.com]

Интересно что с оптимизацией оно напечатало "1 2\n"
Забавно)

[spamsink]

Вот именно! Потому что имеет право. Теперь дело лишь за тем, чтобы объяснить, почему имеет право.

[yurikhan]

Отыгрываю Omniscient Omnipotent Lawful Evil компилятор. Предполагаю sizeof(int) ≤ 4, иначе всё ещё интереснее.

В первой строчке malloc может вернуть nullptr, если памяти нет, или ненулевой указатель на область памяти не менее 4 байт.

Во второй строчке realloc может вернуть (a) nullptr, если p == nullptr и памяти всё ещё нет; (b) указатель p; или же (c) указатель, отличный от p, если реализация стандартной библиотеки не связана ограничением делать все разрешённые оптимизации. В последнем случае указатель p становится невалидным.

В третьей строчке делается разыменование указателя p без проверки, что он не нулевой и валидный, варианты (a) и (c) ведут к UB.

В качестве разрешённой оптимизации предполагаем, что UB не происходит — память всегда есть, а realloc не реаллочит по пустякам. Далее везде считаем, что p == q.

Раз p == q, то запись единицы в третьей строке избыточна. Выоптимизируем её.

В четвёртой строке пишем двойку, если escape-анализ покажет, что значение указателя p или q куда-то выходит из рассматриваемого фрагмента. Если же не выходит, то никто не может легально получить доступ к этой памяти, поэтому запись в память тоже выоптимизируем, а в следующих трёх строчках будем делать вид, что записали.

В пятой строке проверку пропустим, поскольку в рамках сделанных уже предположений условие всегда истинно.

В шестой строке память не читаем. Используем тот факт, что мы только что сделали вид, что записали туда двойку, а переменная не volatile. Форматную строку "%s %s\n" в объектник не пишем, поскольку результат форматирования известен на этапе компиляции. Вызов printf заменяем на puts("2 2\n").

[spamsink]

Канва рассуждения правильная, но некоторые детали отсутствуют, поэтому вывод неправильный. На самом деле будет "1 2\n", как уже получилось у febb выше.

[janatem.livejournal.com]

Придумал только такой вариант, который требует извращенного оптимизатора, который «ошибается» в предположениях. Он знает, что размер для realloc() такой же, как у заведенного ранее указателя, поэтому (вообще говоря, ошибочно (?)) предполагает, что realloc() не перемещает указатель. Тогда (корректный вывод) будет выполнено условие p == q, и if можно выбросить. Правда, еще придется предположить, что первый malloc() никогда не возвратит NULL, это уж не знаю, почему может быть (например, оптимизатор заметит, что указатели нигде далее налево не ходят, поэтому можно заменить аллокацию в куче на аллокацию на стеке). Но в реальном запуске выясняется, что (1) оптимизатор ошибся в первом предположении, (2) после освобождения p страница не сдохла, поэтому его можно разыменовывать без сегфолта. Поэтому печатается "1 2".

[spamsink]

Если компилятор предполагает, что realloc не перемещает указатель, то он, максимально оптимизируя в соответствии с этим предположением, будет обязан выбросить *p = 1.

[ormuz.livejournal.com]

Strict aliasing rule!

Компилятор может не думать о реаллоке и предпооагает q отдельной областью памяти

[spamsink]

p и q одного типа, поэтому strict aliasing rule не при делах, но направление мысли правильное.

[ormuz.livejournal.com]

Собственно на маллок и реаллок оно, возможно даже и не смотрит - ну какая-то там память, оптимизируя только принтф.

[archaicos.livejournal.com]

А вот это интереснее.

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

int main(void)
{
  int* p = malloc(sizeof(int));
  uintptr_t ap = (uintptr_t)p;
  int* q = realloc(p, sizeof(int));
//  *p = 1;
  *(int*)ap = 1;
  *q = 2;
//  if (p == q)
  if ((int*)ap == q)
  {
//    printf("%d %d\n", *p, *q);
    printf("%d %d\n", *(int*)ap, *q);
  }
  return 0;
}

[spamsink]

Ты б говорил, что печатается.

В принципе, любое поведение компилятора можно объяснить фразой "изощрён, но не злонамерен".

[dvv.livejournal.com]

Идеальный компилятор должен выдать ошибку компиляции, соптимизировав время выполнения и футпринт программы до нуля.