Links: x86 instruction list. Linux x86-64 syscall list, and a nicer one.
The GNU Assembler (gas, but its executable name is simply as) isn't part of GCC; it's a part of the GNU binutils. Therefore its documentation is also part of the binutils docs.
The main differences between the AT&T syntax used by the GNU assembler and the Intel syntax that's used by (among others) NASM, and that's in all the books and documentation on x86 assembly, are:
movq %rax, %rbx moves data from rax to rbx, while the equivalent in Intel syntax has the destination on the left: mov rbx, rax. (There are a few exceptions for historical reasons with some floating-point instructions.)
b for 8-bit, w for 16-bit, l for 32-bit, and q for 64-bit operands. Thus, movl moves 32-bit words, while movq moves 64-bit ones. If suffixes are left out it should be able to figure it out on its own, though.
$, and all registers are prefixed with a percent sign %.
/* */ to mark comments – this is the only cross-platform comment symbol. On the x86 architecture, it also supports using # to mark single-line comments. It does not support using the NASM-style semicolon ; to mark comments.
$ on its own evaluates to the current memory address, or current position loosely defined. It's commonly used in idioms like first defining some identifier buf point to the start of some bytes (like a string), immediately followed by buflen: equ $-buf, "buflen is equal to this position minus the start position of buf, i.e. buflen is the length of buf". The equivalent in the GNU Assembler is a dot on its own.One learning resource for AT&T-style, GNU Assembler-compatible assembly is to write C programs and almost compile them with GCC: if you give GCC the -S option, it will compile your code to assembly language, but it won't assemble and link it for you. Each C file is assembled into a file with an .s filename extension.
Input C program, "foo.c":
char buf[70];
int buflen = sizeof(buf);
int main(int argc, char** argv) {
return buflen;
}This was compiled into "foo.s":
.file "foo.c"
.text
.globl buf
.bss
.align 32
.type buf, @object
.size buf, 70
buf:
.zero 70
.globl buflen
.data
.align 4
.type buflen, @object
.size buflen, 4
buflen:
.long 70
.text
.globl main
.type main, @function
main:
.LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
movl %edi, -4(%rbp)
movq %rsi, -16(%rbp)
movl buflen(%rip), %eax
popq %rbp
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE0:
.size main, .-main
.ident "GCC: (GNU) 13.2.1 20230801"
.section .note.GNU-stack,"",@progbitsThe statically-allocated but unfilled memory is put in the .bss section. Allocated and predefined memory, which is here just one 32-bit long, is put in the .data section. Actual program code goes in the .text section. (I've bolded the directives that start these sections, as a kind of syntax highlighting.) As you can see, the code weaves in and out of the segments; unlike in some NASM examples I've seen, it is not necessary to have each section's code be contiguous.
We also see here a use of the dot on its own, as a label referring to the current position (equivalent to NASM's $). On the third line from the bottom, .size main, .-main, the size of the object referred to by the symbol main (corresponding to the int main(int, char**) C function) is calculated by subtracting it's start position from the current start position.
hello.s:
.data
.align 4
msg: .ascii "hello "
.byte 0xf0, 0x9f, 0xa4, 0x96 /* u+01f916 robot face */
.byte 10 /* newline */
/* msglen isn't part of the assembled .data;
it's known only to the assembler */
msglen = . - msg
.text
/* .global = make a symbol visible to the linker */
.global _start
_start:
/* preparing a write syscall */
movq $1, %rax /* syscall 1 = write */
movq $1, %rdi /* file descriptor 1 = stdout */
movq $msg, %rsi /* pointer to data */
movq $msglen, %rdx /* length of data */
syscall
/* preparing an exit syscall */
movq $60, %rax /* syscall 60 = exit */
movq $0, %rdi /* return value */
syscallThis was hand-written, not compiled. The message contains a Unicode astral plane robot emoji; it's manually encoded as a series of bytes, but it could also have been encoded in the string in octal. I don't think the GNU assembler has any directives for directly including UTF-8 strings in the source code.
Assemble this with as hello.s; it'll produce a.out. You also need to manually link it: ld -o hello a.out. Then run it like normal, ./hello.
The dollar sign really is critical in all those movs, and it's also required when moving those memory addresses (pointers) to the write syscall. Otherwise you'll move some garbage data and probably cause a segfault.
created 2023-12-03, last edited 2023-12-03. index