Why does the assembly encoding of objdump vary?

obdjump defaults to -Matt AT&T syntax (like your 2nd code block). See att vs. intel-syntax. The tag wikis have some info about the syntax differences: https://stackoverflow.com/tags/att/info vs. https://stackoverflow.com/tags/intel-syntax/info

Either syntax has the same limitations, imposed by what the machine itself can do, and what's encodeable in machine code. They're just different ways of expressing that in text.

Use objdump -d -Mintel for Intel syntax. I use alias disas='objdump -drwC -Mintel' in my .bashrc, so I can disas foo.o and get the format I want, with relocations printed (important for making sense of a non-linked .o), without line-wrapping for long instructions, and with C++ symbol names demangled.

In inline asm, you can use either syntax, as long as it matches what the compiler is expecting. The default is AT&T, and that's what I'd recommend using for compatibility with clang. Maybe there's a way, but clang doesn't work the same way as GCC with -masm=intel.

Also, AT&T is basically standard for GNU C inline asm on x86, and it means you don't need special build options for your code to work.

But you can use gcc -masm=intel to compile source files that use Intel syntax in their asm statements. This is fine for your own use if you don't care about clang.

If you're writing code for a header, you can make it portable between AT&T and Intel syntax using dialect alternatives, at least for 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 outputs for gcc/clang on the Godbolt compiler explorer.

With g++ -O3 (default or -masm=att), we get

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

With g++ -O3 -masm=intel, we get

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

clang works with the AT&T version, but fails with -masm=intel (or the -mllvm --x86-asm-syntax=intel which that implies), because that apparently only applies to code emitted by LLVM, not for how the front-end fills in the asm template.

The clang error message is:

<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. 

It picked the "Intel" syntax alternative, but still filled in the template with an AT&T memory operand.