Что мешает g ++ устранить временный массив std ::, не используемый во время выполнения?

Во-первых, отличный вопрос.

РЕДАКТИРОВАТЬ:

Я не очень правильно прочитал ваш код с первого раза. В вашем коде есть важный внешний вызов. Это в этой инструкции e8 00 00 00 00 callq 2c <_Z3foov+0x2c>1, Он не вызывает адрес впереди себя — вместо этого его цель будет заменена во время соединения. Вот как работает связывание — в файле эльфа будет сказано: «такая-то и такая инструкция разрешит эту цель во время ссылки». Ассемблер не был перечислен полностью, и поэтому мы не знаем адрес этого звонка. Предположительно это delete _value в коде, однако libstdc ++ (с delet и т. д.) динамически связанный по умолчанию. Вы можете изменить это, используя мои флаги компилятора, или сделать свой листинг внутри GDB (т.е. после ссылки).

Вернуться к ответу:

Это особый случай, когда программисты gcc сделали выбор не оптимизировать. Причина в том, что операторы new и delete помечаются как «слабые символы», и компоновщик будет искать альтернативы, выбирая предоставленного пользователя или отступая, если ничего не найдено.

Вот обсуждение обоснования этого. Эти операторы предназначены для глобальной замены, и слабое связывание является одним из решений.

Статическое связывание не меняет этого, потому что free и malloc в glibc все еще могут быть изменены во время компоновки.

Статическое связывание или использование оптимизации времени соединения должен использовать встроенное удаление, Однако в этом случае, если вы вместо этого статически связаны, шанс все еще упущен. Однако в вашем первоначальном примере такой возможности нет.

Компилируя это:

#include <array>
#include <cassert>
#include <cstdlib>

void * operator new(std::size_t n) throw(std::bad_alloc)
{
return malloc(n);
}
void operator delete(void * p) throw()
{
if(p != nullptr)
free(p);
}

class P {
public:
P() : _value(nullptr) {}
~P() { delete _value; }

private:
char *_value;
};

void foo() {
if(std::array<P, 4>().size() != 4)
assert(false);
}

int main(){
foo();
}

с этим;
g ++ -std = c ++ 11 -O3 -static -Wa, -alh test.cpp -o test

ссылки на libstdc ++ / glibc статически, так что он должен знать, что такое free и malloc, однако он не совсем понимает, что foo тривиален.

Тем не мение, nm -gC test | grep free производит слабый символ __free_hook, который я нашел объяснение Вот. Таким образом, поведение free и malloc (и, следовательно, оператора new и delete) на самом деле всегда можно изменить время ссылки при компиляции с gcc. Вот что мешает оптимизации — досадно -fno-weak оставляет эти символы там.

Вышеприведенный абзац верен, но является результатом пропущенной оптимизации, а не причиной, чтобы избежать оптимизации.

При оптимизации времени соединения возможно, что gcc можно убедить выполнить эту оптимизацию, но сначала вы должны собрать все остальное с помощью -flto, включая libstdc ++.

Вот что делает gcc для меня при статическом построении примера:

Dump of assembler code for function _Z3foov:
0x08048ef0 <+0>:    push   %esi
0x08048ef1 <+1>:    push   %ebx
0x08048ef2 <+2>:    sub    $0x24,%esp
0x08048ef5 <+5>:    movl   $0x0,0x10(%esp)
0x08048efd <+13>:   lea    0x20(%esp),%ebx
0x08048f01 <+17>:   movl   $0x0,0x14(%esp)
0x08048f09 <+25>:   lea    0x10(%esp),%esi
0x08048f0d <+29>:   movl   $0x0,0x18(%esp)
0x08048f15 <+37>:   movl   $0x0,0x1c(%esp)
0x08048f1d <+45>:   lea    0x0(%esi),%esi
0x08048f20 <+48>:   sub    $0x4,%ebx
0x08048f23 <+51>:   mov    (%ebx),%eax
0x08048f25 <+53>:   test   %eax,%eax
0x08048f27 <+55>:   je     0x8048f31 <_Z3foov+65>
0x08048f29 <+57>:   mov    %eax,(%esp)
0x08048f2c <+60>:   call   0x804dea0 <free>
0x08048f31 <+65>:   cmp    %esi,%ebx
0x08048f33 <+67>:   jne    0x8048f20 <_Z3foov+48>
0x08048f35 <+69>:   add    $0x24,%esp
0x08048f38 <+72>:   pop    %ebx
0x08048f39 <+73>:   pop    %esi
0x08048f3a <+74>:   ret

Призыв к свободе никуда не денется.

Если это проблема, оптимизируйте ее самостоятельно. Шаблоны делают это легко (при условии, что std :: array передается как аргумент шаблона, иначе зачем вы проверяете его size ()?).

#include <array>
#include <cassert>

class P {
public:
P() : _value(nullptr) {}
~P() { delete _value; }

private:
char *_value;
};

void foo() {
if(std::tuple_size<std::array<P, 4> >::value != 4)
assert(false);
}

int main(){
foo();
}

Код может быть сделан, чтобы молча потерпеть неудачу, если std::array<P, 4> вектор или что-то, и прибегните к вашему методу построения по умолчанию.

nm -C test выходы W operator new(unsigned int, void*) когда я добавил #include <new>Таким образом, размещение нового по крайней мере может быть изменено по времени ссылки (это слабый символ) — остальные являются особыми, и их конечные цели находятся в libstdc ++ (опять же, они динамически связаны по умолчанию).