почему объектный код, сгенерированный для noexcept и throw(), одинаков в С++ 11?

Они генерируют один и тот же код, потому что вы ничего не выбрасываете. Ваша тестовая программа настолько проста, что компилятор может тривиально проанализировать ее, определить, что она не генерирует исключение и фактически вообще ничего не делает! При включенных оптимизациях (-O1 и выше) код объекта:

fun():
        rep ret
main:
        xor     eax, eax
        ret

показывает, что ваш тестовый код оптимизируется просто для самого тривиального допустимого приложения C++:

int main()
{
    return 0;
}

Если вы действительно хотите проверить разницу в генерации объектного кода для двух типов спецификаторов исключений, вам нужно использовать реальную (то есть, нетривиальную) тестовую программу. Что-то, что на самом деле генерирует исключение, и где этот выброс не может быть проанализирован с помощью небольшого анализа времени компиляции:

void fun(int args) throw()  // C++98 style
{
   if (args == 0)
   {
      throw "Not enough arguments!";
   }
   else
   {
      // do something
   }
}

int main(int argc, char** argv)
{
   fun(argc);
   return 0;
}

В этом коде исключение создается условно в зависимости от значения входного параметра (argc), переданного в функцию main. Компилятор не может знать во время компиляции, каким будет значение этого аргумента, поэтому он не может оптимизировать ни эту условную проверку, ни создание исключения. Это заставляет его генерировать код исключения и раскручивания стека.

Теперь мы можем сравнить полученный объектный код. Используя GCC 5.3 с -O3 и -std=c++11, я получаю следующее:

Стиль С++ 98 (throw())

.LC0:
        .string "Not enough arguments!"
fun(int):
        test    edi, edi
        je      .L9
        rep ret
.L9:
        push    rax
        mov     edi, 8
        call    __cxa_allocate_exception
        xor     edx, edx
        mov     QWORD PTR [rax], OFFSET FLAT:.LC0
        mov     esi, OFFSET FLAT:typeinfo for char const*
        mov     rdi, rax
        call    __cxa_throw
        add     rdx, 1
        mov     rdi, rax
        je      .L4
        call    _Unwind_Resume
.L4:
        call    __cxa_call_unexpected
main:
        sub     rsp, 8
        call    fun(int)
        xor     eax, eax
        add     rsp, 8
        ret

Стиль С++ 11 (noexcept)

.LC0:
        .string "Not enough arguments!"
fun(int) [clone .part.0]:
        push    rax
        mov     edi, 8
        call    __cxa_allocate_exception
        xor     edx, edx
        mov     QWORD PTR [rax], OFFSET FLAT:.LC0
        mov     esi, OFFSET FLAT:typeinfo for char const*
        mov     rdi, rax
        call    __cxa_throw
fun(int):
        test    edi, edi
        je      .L8
        rep ret
.L8:
        push    rax
        call    fun(int) [clone .part.0]
main:
        test    edi, edi
        je      .L12
        xor     eax, eax
        ret
.L12:
        push    rax
        call    fun(int) [clone .part.0]

Обратите внимание, что они явно отличаются. Как утверждал Мейерс и др., спецификация throw() в стиле C++98, указывающая, что функция не генерирует исключение, заставляет компилятор, соответствующий стандартам, выдавать код для очистки стека и вызова std::unexpected когда внутри этой функции генерируется исключение. Это именно то, что происходит здесь. Поскольку fun помечен как throw(), но на самом деле выполняет исключение, объектный код показывает, что компилятор вызывает вызов __cxa_call_unexpected.

Clang также соответствует стандартам и делает то же самое. Я не буду воспроизводить объектный код, потому что он длиннее и сложнее (вы можете увидеть его на отличном сайте Мэтта Годболта), но помещение в функцию спецификации исключения в стиле C++98 приводит к тому, что компилятор явно вызывает std::terminate, если функция вызывает исключение, нарушающее ее спецификацию, тогда как спецификация исключения в стиле C++11 не приводит к вызову std::terminate.