Assembling 32-bit binaries on a 64-bit system (GNU toolchain)

Question

I wrote assembly code that successfully compiles: ``` as power.s -o power.o ``` However, it fails when I try to link the object file: ``` ld power.o -o power ``` In order to run on the 64 bit OS (Ubuntu 14.04), I added `.code32` at the beginning of the `power.s` file, however I still get the error: Segmentation fault (core dumped) `power.s`: ``` .code32 .section .data .section .text .global _start _start: pushl $3 pushl $2 call power addl $8, %esp pushl %eax pushl $2 pushl $5 call power addl $8, %esp popl %ebx addl %eax, %ebx movl $1, %eax int $0x80 .type power, @function power: pushl %ebp movl %esp, %ebp subl $4, %esp movl 8(%ebp), %ebx movl 12(%ebp), %ecx movl %ebx, -4(%ebp) power_loop_start: cmpl $1, %ecx je end_power movl -4(%ebp), %eax imull %ebx, %eax movl %eax, -4(%ebp) decl %ecx jmp power_loop_start end_power: movl -4(%ebp), %eax movl %ebp, %esp popl %ebp ret ```

Accepted Answer

TL:DR: use `gcc -m32 -static -nostdlib foo.S` (or equivalent as and ld options). Or if you don't define your own `_start`, just `gcc -m32 -no-pie foo.S`

You may need to install `gcc-multilib` if you link libc, or however your distro packages `/usr/lib32/libc.so`, `/usr/lib32/libstdc++.so` and so on. But if you define your own `_start` and don't link libraries, you don't need the library package, just a kernel that supports 32-bit processes and system calls. This includes most distros, but not Windows Subsystem for Linux v1.

Don't use `.code32`

`.code32` does not change the output file format, and that's what determines the mode your program will run in. It's up to you to not try to run 32bit code in 64bit mode. `.code32` is for assembling kernels that have some 16 and some 32-bit code, and stuff like that. If that's not what you're doing, avoid it so you'll get build-time errors when you build a `.S` in the wrong mode if it has any `push` or `pop` instructions, for example. `.code32` just lets you create confusing-to-debug runtime problems instead of build-time errors.

Suggestion: use the `.S` extension for hand-written assembler. (`gcc -c foo.S` will run it through the C preprocessor before `as`, so you can `#include <sys/syscall.h>` for syscall numbers, for example). Also, it distinguishes it from `.s` compiler output (from `gcc foo.c -O3 -S`).

To build 32-bit binaries, use one of these commands

```
gcc -g foo.S -o foo -m32 -nostdlib -static  # static binary with absolutely no libraries or startup code
                       # -nostdlib still dynamically links when Linux where PIE is the default, or on OS X

gcc -g foo.S -o foo -m32 -no-pie            # dynamic binary including the startup boilerplate code.
     # Use with code that defines a main(), not a _start
```

Documentation for `nostdlib`, `-nostartfiles`, and `-static`.

Using libc functions from `_start` (see the end of this answer for an example)

Some functions, like `malloc(3)`, or stdio functions including `printf(3)`, depend on some global data being initialized (e.g. `FILE *stdout` and the object it actually points to).

`gcc -nostartfiles` leaves out the CRT `_start` boilerplate code, but still links `libc` (dynamically, by default). On Linux, shared libraries can have initializer sections that are run by the dynamic linker when it loads them, before jumping to your `_start` entry point. So `gcc -nostartfiles hello.S` still lets you call `printf`. For a dynamic executable, the kernel runs `/lib/ld-linux.so.2` on it instead of running it directly (use `readelf -a` to see the "ELF interpreter" string in your binary). When your `_start` eventually runs, not all the registers will be zeroed, because the dynamic linker ran code in your process.

However, `gcc -nostartfiles -static hello.S` will link, but crash at runtime if you call `printf` or something without calling glibc's internal init functions. (see Michael Petch's comment).

Of course you can put any combination of `.c`, `.S`, and `.o` files on the same command line to link them all into one executable. If you have any C, don't forget `-Og -Wall -Wextra`: you don't want to be debugging your asm when the problem was something simple in the C that calls it that the compiler could have warned you about.

Use `-v` to have gcc show you the commands it runs to assemble and link. To do it "manually":

```
as foo.S -o foo.o -g --32 &&      # skips the preprocessor
ld -o foo foo.o  -m elf_i386

file foo
foo: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, not stripped
```

`gcc -nostdlib -m32` is easier to remember and type than the two different options for as and ld (`--32` and `-m elf_i386`). Also, it works on all platforms, including ones where executable format isn't ELF. (But Linux examples won't work on OS X, because the system call numbers are different, or on Windows because it doesn't even use the `int 0x80` ABI.)

NASM/YASM

gcc can't handle NASM syntax. (`-masm=intel` is more like MASM than NASM syntax, where you need `offset symbol` to get the address as an immediate). And of course the directives are different (e.g. `.globl` vs `global`).

You can build with `nasm` or `yasm`, then link the `.o` with `gcc` as above, or `ld` directly.

I use a wrapper script to avoid the repetitive typing of the same filename with three different extensions. (nasm and yasm default to `file.asm` -> `file.o`, unlike GNU as's default output of `a.out`). Use this with `-m32` to assemble and link 32bit ELF executables. Not all OSes use ELF, so this script is less portable than using `gcc -nostdlib -m32` to link would be..

```
#!/bin/bash
# usage: asm-link [-q] [-m32] foo.asm  [assembler options ...]
# Just use a Makefile for anything non-trivial.  This script is intentionally minimal and doesn't handle multiple source files
# Copyright 2020 Peter Cordes.  Public domain.  If it breaks, you get to keep both pieces

verbose=1                       # defaults
fmt=-felf64…

Assembling 32-bit binaries on a 64-bit system (GNU toolchain)

Solution

Problem

Related problems