Почему меняется кодировка objdump на ассемблере? - PullRequest
2 голосов
/ 16 марта 2019

Я читал эту статью о позиционно-независимом коде и столкнулся с этим списком функций для сборки.

0000043c <ml_func>:
 43c:   55                      push   ebp
 43d:   89 e5                   mov    ebp,esp
 43f:   e8 16 00 00 00          call   45a <__i686.get_pc_thunk.cx>
 444:   81 c1 b0 1b 00 00       add    ecx,0x1bb0
 44a:   8b 81 f0 ff ff ff       mov    eax,DWORD PTR [ecx-0x10]
 450:   8b 00                   mov    eax,DWORD PTR [eax]
 452:   03 45 08                add    eax,DWORD PTR [ebp+0x8]
 455:   03 45 0c                add    eax,DWORD PTR [ebp+0xc]
 458:   5d                      pop    ebp
 459:   c3                      ret

0000045a <__i686.get_pc_thunk.cx>:
 45a:   8b 0c 24                mov    ecx,DWORD PTR [esp]
 45d:   c3                      ret

Однако на моей машине (gcc-7.3.0, Ubuntu18.04 x86_64), я получил немного другой результат ниже:

0000044d <ml_func>:
 44d:   55                      push   %ebp
 44e:   89 e5                   mov    %esp,%ebp
 450:   e8 29 00 00 00          call   47e <__x86.get_pc_thunk.ax>
 455:   05 ab 1b 00 00          add    $0x1bab,%eax
 45a:   8b 90 f0 ff ff ff       mov    -0x10(%eax),%edx
 460:   8b 0a                   mov    (%edx),%ecx
 462:   8b 55 08                mov    0x8(%ebp),%edx
 465:   01 d1                   add    %edx,%ecx
 467:   8b 90 f0 ff ff ff       mov    -0x10(%eax),%edx
 46d:   89 0a                   mov    %ecx,(%edx)
 46f:   8b 80 f0 ff ff ff       mov    -0x10(%eax),%eax
 475:   8b 10                   mov    (%eax),%edx
 477:   8b 45 0c                mov    0xc(%ebp),%eax
 47a:   01 d0                   add    %edx,%eax
 47c:   5d                      pop    %ebp
 47d:   c3                      ret 

Основное различие, которое я обнаружил, заключалось в том, что семантика mov инструкции.В верхнем списке mov ebp,esp фактически перемещает esp в ebp, в то время как в нижнем списке mov %esp,%ebp делает то же самое, но порядок операндов различен.

Это довольно запутаннодаже когда мне приходится кодировать рукописные сборки.Подводя итог, я хочу задать следующие вопросы: (1) почему я получил разные представления ассемблера для одних и тех же инструкций и (2) какое из них следует использовать при написании кода ассемблера (например, с __asm(:::);)

1 Ответ

5 голосов
/ 16 марта 2019

obdjump по умолчанию -Matt Синтаксис AT & T (как ваш 2-й кодовый блок).См. против .Вики-теги содержат некоторую информацию о различиях синтаксиса: https://stackoverflow.com/tags/att/info против https://stackoverflow.com/tags/intel-syntax/info

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


Используйте objdump -d -Mintel для синтаксиса Intel.Я использую alias disas='objdump -drwC -Mintel' в своем .bashrc, поэтому я могу disas foo.o и получить желаемый формат с распечатанными перемещениями (важно для понимания несвязанного .o), без строки-пакет для длинных инструкций и с разделенными именами символов C ++.


Во встроенном asm вы можете использовать любой синтаксис, если он соответствует ожидаемому компилятором.По умолчанию используется AT & T, и это то, что я бы рекомендовал использовать для совместимости с clang.Может быть, есть способ, но clang не работает так же, как GCC с -masm=intel.

Кроме того, AT & T в основном стандарт для встроенного asm GNU C на x86, и это означает, что вам не нужны специальныеОпции сборки для работы вашего кода.

Но вы можете использовать gcc -masm=intel для компиляции исходных файлов, использующих синтаксис Intel в их операторах asm.Это хорошо для вашего собственного использования, если вас не волнует лязг.


Если вы пишете код для заголовка, вы можете сделать его переносимым междуСинтаксис AT & T и Intel с использованием альтернативных диалектов, по крайней мере для GCC:

static inline
void atomic_inc(volatile int *p) {
    // use __asm__ instead of asm in headers, so it works even with -std=c11 instead of gnu11
    __asm__("lock {addl $1, %0 | add %0, 1}": "+m"(*p));
// TODO: flag output for return value?
   // maybe doesn't need to be asm volatile; compilers know that modifying pointed-to memory is a visible side-effect unless it's a local that fully optimizes away.
   // If you want this to work as a memory barrier, use a `"memory"` clobber to stop compile-time memory reordering.  The lock prefix provides a runtime full barrier
}

source + asm для gcc / clang в проводнике компилятора Godbolt .

При g++ -O3 (по умолчанию или -masm=att) мы получаем

atomic_inc(int volatile*):
    lock addl $1, (%rdi)              # operand-size is from my explicit addl suffix
    ret

При g++ -O3 -masm=intel мы получаем

atomic_inc(int volatile*):
    lock  add DWORD PTR [rdi], 1      # operand-size came from the %0 expansion
    ret

лязгработает с версией AT & T, но не работает с -masm=intel (или -mllvm --x86-asm-syntax=intel, что подразумевается), потому что это, очевидно, относится только к коду, генерируемому LLVM, а не к тому, как внешний интерфейс заполняет шаблон asm.

Сообщение об ошибке clang:

<source>:4:13: error: unknown use of instruction mnemonic without a size suffix
    __asm__("lock {addl $1, %0 | add %0, 1}": "+m"(*p));
            ^
<inline asm>:1:2: note: instantiated into assembly here
        lock  add (%rdi), 1
        ^
1 error generated.

Он выбрал альтернативный синтаксис Intel, но все еще заполнен в шаблоне с операндом памяти AT & T.

...