Assembly

For some use cases, it may be necessary to directly control the machine code generated by Zig programs, rather than relying on Zig’s code generation. For these cases, one can use inline assembly. Here is an example of implementing Hello, World on x86_64 Linux using inline assembly:

test.zig

  1. pub fn main() noreturn {
  2.     const msg = "hello world\n";
  3.     _ = syscall3(SYS_write, STDOUT_FILENO, @ptrToInt(msg), msg.len);
  4.     _ = syscall1(SYS_exit, 0);
  5.     unreachable;
  6. }
  8. pub const SYS_write = 1;
  9. pub const SYS_exit = 60;
  11. pub const STDOUT_FILENO = 1;
  13. pub fn syscall1(number: usize, arg1: usize) usize {
  14.     return asm volatile ("syscall"
  15.         : [ret] "={rax}" (-> usize)
  16.         : [number] "{rax}" (number),
  17.           [arg1] "{rdi}" (arg1)
  18.         : "rcx", "r11"
  19.     );
  20. }
  22. pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize {
  23.     return asm volatile ("syscall"
  24.         : [ret] "={rax}" (-> usize)
  25.         : [number] "{rax}" (number),
  26.           [arg1] "{rdi}" (arg1),
  27.           [arg2] "{rsi}" (arg2),
  28.           [arg3] "{rdx}" (arg3)
  29.         : "rcx", "r11"
  30.     );
  31. }
  1. $ zig build-exe test.zig -target x86_64-linux
  2. $ ./test
  3. hello world

Dissecting the syntax:

  1. // Inline assembly is an expression which returns a value.
  2. // the `asm` keyword begins the expression.
  3. _ = asm
  4. // `volatile` is an optional modifier that tells Zig this
  5. // inline assembly expression has side-effects. Without
  6. // `volatile`, Zig is allowed to delete the inline assembly
  7. // code if the result is unused.
  8. volatile (
  9. // Next is a comptime string which is the assembly code.
  10. // Inside this string one may use `%[ret]`, `%[number]`,
  11. // or `%[arg1]` where a register is expected, to specify
  12. // the register that Zig uses for the argument or return value,
  13. // if the register constraint strings are used. However in
  14. // the below code, this is not used. A literal `%` can be
  15. // obtained by escaping it with a double percent: `%%`.
  16. // Often multiline string syntax comes in handy here.
  17.     \\syscall
  18. // Next is the output. It is possible in the future Zig will
  19. // support multiple outputs, depending on how
  20. // https://github.com/ziglang/zig/issues/215 is resolved.
  21. // It is allowed for there to be no outputs, in which case
  22. // this colon would be directly followed by the colon for the inputs.
  23.     :
  24. // This specifies the name to be used in `%[ret]` syntax in
  25. // the above assembly string. This example does not use it,
  26. // but the syntax is mandatory.
  27.     [ret]
  28. // Next is the output constraint string. This feature is still
  29. // considered unstable in Zig, and so LLVM/GCC documentation
  30. // must be used to understand the semantics.
  31. // http://releases.llvm.org/10.0.0/docs/LangRef.html#inline-asm-constraint-string
  32. // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html
  33. // In this example, the constraint string means "the result value of
  34. // this inline assembly instruction is whatever is in $rax".
  35.     "={rax}"
  36. // Next is either a value binding, or `->` and then a type. The
  37. // type is the result type of the inline assembly expression.
  38. // If it is a value binding, then `%[ret]` syntax would be used
  39. // to refer to the register bound to the value.
  40.     (-> usize)
  41. // Next is the list of inputs.
  42. // The constraint for these inputs means, "when the assembly code is
  43. // executed, $rax shall have the value of `number` and $rdi shall have
  44. // the value of `arg1`". Any number of input parameters is allowed,
  45. // including none.
  46.     : [number] "{rax}" (number),
  47.         [arg1] "{rdi}" (arg1)
  48. // Next is the list of clobbers. These declare a set of registers whose
  49. // values will not be preserved by the execution of this assembly code.
  50. // These do not include output or input registers. The special clobber
  51. // value of "memory" means that the assembly writes to arbitrary undeclared
  52. // memory locations - not only the memory pointed to by a declared indirect
  53. // output. In this example we list $rcx and $r11 because it is known the
  54. // kernel syscall does not preserve these registers.
  55.     : "rcx", "r11"
  56. );

For i386 and x86_64 targets, the syntax is AT&T syntax, rather than the more popular Intel syntax. This is due to technical constraints; assembly parsing is provided by LLVM and its support for Intel syntax is buggy and not well tested.

Some day Zig may have its own assembler. This would allow it to integrate more seamlessly into the language, as well as be compatible with the popular NASM syntax. This documentation section will be updated before 1.0.0 is released, with a conclusive statement about the status of AT&T vs Intel/NASM syntax.

Output Constraints

Output constraints are still considered to be unstable in Zig, and so LLVM documentation and GCC documentation must be used to understand the semantics.

Note that some breaking changes to output constraints are planned with issue #215.

Input Constraints

Input constraints are still considered to be unstable in Zig, and so LLVM documentation and GCC documentation must be used to understand the semantics.

Note that some breaking changes to input constraints are planned with issue #215.

Clobbers

Clobbers are the set of registers whose values will not be preserved by the execution of the assembly code. These do not include output or input registers. The special clobber value of "memory" means that the assembly causes writes to arbitrary undeclared memory locations - not only the memory pointed to by a declared indirect output.

Failure to declare the full set of clobbers for a given inline assembly expression is unchecked Undefined Behavior.

Global Assembly

When an assembly expression occurs in a top level comptime block, this is global assembly.

This kind of assembly has different rules than inline assembly. First, volatile is not valid because all global assembly is unconditionally included. Second, there are no inputs, outputs, or clobbers. All global assembly is concatenated verbatim into one long string and assembled together. There are no template substitution rules regarding % as there are in inline assembly expressions.

global-asm.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. comptime {
  5.     asm (
  6.         \\.global my_func;
  7.         \\.type my_func, @function;
  8.         \\my_func:
  9.         \\  lea (%rdi,%rsi,1),%eax
  10.         \\  retq
  11.     );
  12. }
  14. extern fn my_func(a: i32, b: i32) i32;
  16. test "global assembly" {
  17.     try expect(my_func(12, 34) == 46);
  18. }
  1. $ zig test global-asm.zig -target x86_64-linux
  2. Test [1/1] test "global assembly"... 
  4. All 1 tests passed.