global _start       ; no_libc/start.asm
extern main
section     .text
_start:
    mov ecx, [esp]  ; argc in ecx
    mov eax, esp
    add eax, 4      ; argv in eax
    push eax
    push ecx
    call main
    add esp, 8      ; clean the stack
    mov ebx, eax    ; now call _exit
    mov eax, 1
    int 80h

global sys_read     ; no_libc/calls.asm
global sys_write
global sys_errno

section .text

generic_syscall_3:
    push ebp
    mov ebp, esp
    push ebx
    mov ebx, [ebp+8]
    mov ecx, [ebp+12]
    mov edx, [ebp+16]
    int 80h
    mov edx, eax
    and edx, 0fffff000h
    cmp edx, 0fffff000h
    jnz .okay
    mov [sys_errno], eax
    mov eax, -1
.okay:
    pop ebx
    mov esp, ebp
    pop ebp
    ret

sys_read:
    mov eax, 3
    jmp generic_syscall_3

sys_write:
    mov eax, 4
    jmp generic_syscall_3

section .bss
sys_errno resd 1

/* no_libc/greet3.c */
int sys_write(int fd, const void *buf, int size);

static const char dunno[] = "I don't know how to greet youn";
static const char hello[] = "Hello, dear ";

static int string_length(const char *s)
{
  int i = 0;
  while(s[i])
    i++;
  return i;
}

int main(int argc, char **argv)
{
  if(argc < 2) {
    sys_write(1, dunno, sizeof(dunno)-1);
    return 1;
  }
  sys_write(1, hello, sizeof(hello)-1);
  sys_write(1, argv[1], string_length(argv[1]));
  sys_write(1, "n", 1);
  return 0;
}

Every  architecture has its own way of invoking and passing arguments
to the kernel.  The details for various architectures are listed
in the two tables below.

The first table lists the instruction used to transition to kernel mode
(which might not be the fastest or best way to transition to the kernel,
so  you might have to refer to vdso(7)), the register used to indicate
the system call number, the register(s) used to return the system call
result, and the register used to signal an error.

Arch/ABI    Instruction           System  Ret  Ret  Error    Notes
                                  call #  val  val2
───────────────────────────────────────────────────────────────────
i386        int $0x80             eax     eax  edx  -
x86-64      syscall               rax     rax  rdx  -        5

The second table shows the registers used to pass the system call arguments.

Arch/ABI      arg1  arg2  arg3  arg4  arg5  arg6  arg7  Notes
──────────────────────────────────────────────────────────────
i386          ebx   ecx   edx   esi   edi   ebp   -
x86-64        rdi   rsi   rdx   r10   r8    r9    -

#![feature(no_core)]
#![feature(lang_items)]
#![no_core]
#![no_main]
#![feature(naked_functions)]
#![feature(decl_macro)]
#![feature(rustc_attrs)]
#![feature(intrinsics)]

// Нужно компилятору
#[lang = "sized"]
pub trait Sized {}

#[lang = "copy"]
pub trait Copy {}

impl Copy for i64 {} // Говорим компилятору, что объект этого типа можно копировать байт за байтом
impl Copy for usize {}

#[rustc_builtin_macro]
pub macro asm("assembly template", $(operands,)* $(options($(option),*))?) {
  /* compiler built-in */
}

extern "rust-intrinsic" {
  // Чтобы компилятор знал, что есть некоторый код, которого не достичь.
  // Например, весь код после exit()
  pub fn unreachable() -> !;
}

#[no_mangle]
#[naked]
unsafe extern "C" fn _start() {
  // Стырено из книги А.В. Столярова.
  // А, простите, там код под 32 бита, в книге 2021 года.
  // Значит, не стырено.
  asm!(
    "mov rdi, [rsp]", // argc
    "mov rax, rsp",
    "add rax, 8",
    "mov rsi, rax", // argv
    "call _start_main",
    options(noreturn),
  )
}

#[no_mangle]
extern "C" fn _start_main(argc: usize, argv: *const *const u8) -> ! {
  let status = main(argc, argv);
  exit(status);
}

#[no_mangle]
fn main(_argc: usize, _argv: *const *const u8) -> i64 {
  let string = b"Hello, world!n" as *const _ as *const u8;
  write(1, string, 14);
  return 0;
}

#[inline(never)]
#[no_mangle]
// ! - это never type, компилятор понимает, что функция никогда не возвращается
fn exit(status: i64) -> ! {
  unsafe {
    syscall1(60, status);
    unreachable()
  }
}

#[inline(never)]
#[no_mangle]
fn write(fd: i64, data: *const u8, len: i64) -> i64 {
  unsafe { syscall3(1, fd, data as i64, len) }
}

#[inline(always)]
unsafe fn syscall1(n: i64, a1: i64) -> i64 {
  let ret: i64;
  asm!(
    "syscall",
    in("rax") n,
    in("rdi") a1,
    lateout("rax") ret,
  );
  ret
}

#[inline(always)]
unsafe fn syscall3(n: i64, a1: i64, a2: i64, a3: i64) -> i64 {
  let ret: i64;
  asm!(
    "syscall",
    in("rax") n,
    in("rdi") a1,
    in("rsi") a2,
    in("rdx") a3,
    lateout("rax") ret,
  );
  ret
}

diff --git a/config.sh b/config.sh
index b25e215..18574f2 100644
--- a/config.sh
+++ b/config.sh
@@ -20,8 +20,9 @@ else
 fi

 HOST_TRIPLE=$(rustc -vV | grep host | cut -d: -f2 | tr -d " ")
-TARGET_TRIPLE=$HOST_TRIPLE
+#TARGET_TRIPLE=$HOST_TRIPLE
 #TARGET_TRIPLE="m68k-unknown-linux-gnu"
+TARGET_TRIPLE="i686-unknown-linux-gnu"

 linker=''
 RUN_WRAPPER=''
@@ -33,6 +34,8 @@ if [[ "$HOST_TRIPLE" != "$TARGET_TRIPLE" ]]; then
       # We are cross-compiling for aarch64. Use the correct linker and run tests in qemu.
       linker='-Clinker=aarch64-linux-gnu-gcc'
       RUN_WRAPPER='qemu-aarch64 -L /usr/aarch64-linux-gnu'
+   elif [[ "$TARGET_TRIPLE" == "i686-unknown-linux-gnu" ]]; then
+      : # do nothing
    else
       echo "Unknown non-native platform"
    fi
diff --git a/src/back/write.rs b/src/back/write.rs
index efcf18d..e640fbe 100644
--- a/src/back/write.rs
+++ b/src/back/write.rs
@@ -14,6 +14,8 @@ pub(crate) unsafe fn codegen(cgcx: &CodegenContext<GccCodegenBackend>, _diag_han
     let _timer = cgcx.prof.generic_activity_with_arg("LLVM_module_codegen", &*module.name);
     {
         let context = &module.module_llvm.context;
+        context.add_command_line_option("-m32");
+        context.add_driver_option("-m32");

         let module_name = module.name.clone();
         let module_name = Some(&module_name[..]);
diff --git a/src/base.rs b/src/base.rs
index 8cc9581..fb8bd88 100644
--- a/src/base.rs
+++ b/src/base.rs
@@ -98,7 +98,7 @@ pub fn compile_codegen_unit<'tcx>(tcx: TyCtxt<'tcx>, cgu_name: Symbol, supports_
         context.add_command_line_option("-mpclmul");
         context.add_command_line_option("-mfma");
         context.add_command_line_option("-mfma4");
-        context.add_command_line_option("-m64");
+        context.add_command_line_option("-m32");
         context.add_command_line_option("-mbmi");
         context.add_command_line_option("-mgfni");
         context.add_command_line_option("-mavxvnni");
diff --git a/src/context.rs b/src/context.rs
index 2699559..056352a 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -161,13 +161,13 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         let ulonglong_type = context.new_c_type(CType::ULongLong);
         let sizet_type = context.new_c_type(CType::SizeT);

-        let isize_type = context.new_c_type(CType::LongLong);
-        let usize_type = context.new_c_type(CType::ULongLong);
+        let isize_type = context.new_c_type(CType::Int);
+        let usize_type = context.new_c_type(CType::UInt);
         let bool_type = context.new_type::<bool>();

         // TODO(antoyo): only have those assertions on x86_64.
-        assert_eq!(isize_type.get_size(), i64_type.get_size());
-        assert_eq!(usize_type.get_size(), u64_type.get_size());
+        assert_eq!(isize_type.get_size(), i32_type.get_size());
+        assert_eq!(usize_type.get_size(), u32_type.get_size());

         let mut functions = FxHashMap::default();
         let builtins = [
diff --git a/src/int.rs b/src/int.rs
index 0c5dab0..5fd4925 100644
--- a/src/int.rs
+++ b/src/int.rs
@@ -524,7 +524,7 @@ impl<'a, 'gcc, 'tcx> Builder<'a, 'gcc, 'tcx> {
         // when having proper sized integer types.
         let param_type = bswap.get_param(0).to_rvalue().get_type();
         if param_type != arg_type {
-            arg = self.bitcast(arg, param_type);
+            arg = self.cx.context.new_cast(None, arg, param_type);
         }
         self.cx.context.new_call(None, bswap, &[arg])
     }
diff --git a/src/lib.rs b/src/lib.rs
index e43ee5c..8fb5823 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -104,6 +104,7 @@ impl CodegenBackend for GccCodegenBackend {
         let temp_dir = TempDir::new().expect("cannot create temporary directory");
         let temp_file = temp_dir.into_path().join("result.asm");
         let check_context = Context::default();
+        check_context.add_command_line_option("-m32");
         check_context.set_print_errors_to_stderr(false);
         let _int128_ty = check_context.new_c_type(CType::UInt128t);
         // NOTE: we cannot just call compile() as this would require other files than libgccjit.so.

diff --git a/src/base.rs b/src/base.rs
index fb8bd88..d5268dc 100644
--- a/src/base.rs
+++ b/src/base.rs
@@ -87,29 +87,11 @@ pub fn compile_codegen_unit<'tcx>(tcx: TyCtxt<'tcx>, cgu_name: Symbol, supports_
         // Instantiate monomorphizations without filling out definitions yet...
         //let llvm_module = ModuleLlvm::new(tcx, &cgu_name.as_str());
         let context = Context::default();
-        // TODO(antoyo): only set on x86 platforms.
         context.add_command_line_option("-masm=intel");
-        // TODO(antoyo): only add the following cli argument if the feature is supported.
-        context.add_command_line_option("-msse2");
-        context.add_command_line_option("-mavx2");
-        // FIXME(antoyo): the following causes an illegal instruction on vmovdqu64 in std_example on my CPU.
-        // Only add if the CPU supports it.
-        context.add_command_line_option("-msha");
-        context.add_command_line_option("-mpclmul");
-        context.add_command_line_option("-mfma");
-        context.add_command_line_option("-mfma4");
         context.add_command_line_option("-m32");
-        context.add_command_line_option("-mbmi");
-        context.add_command_line_option("-mgfni");
-        context.add_command_line_option("-mavxvnni");
-        context.add_command_line_option("-mf16c");
-        context.add_command_line_option("-maes");
-        context.add_command_line_option("-mxsavec");
-        context.add_command_line_option("-mbmi2");
-        context.add_command_line_option("-mrtm");
-        context.add_command_line_option("-mvaes");
-        context.add_command_line_option("-mvpclmulqdq");
-        context.add_command_line_option("-mavx");
+        context.add_command_line_option("-fno-pic");
+        context.add_command_line_option("-fno-asynchronous-unwind-tables");
+        context.add_command_line_option("-Os");

         for arg in &tcx.sess.opts.cg.llvm_args {
             context.add_command_line_option(arg);

int sys_write(int fd, const void *buf, int size);
void sys_exit(int status);
static int main(int argc, char **argv);
static int syscall1(int n, int a1);
static int syscall3(int n, int a1, int a2, int a3);

static const char hello[] = "Hello, world!n";

void _Noreturn __attribute__((naked)) _start() {
  __asm volatile (
    "_start:n"
    "  mov ecx, [esp]n"
    "  mov eax, espn"
    "  add eax, 4n"
    "  push eaxn"
    "  push ecxn"
    "  call _start_mainn"
  );
}

void _Noreturn _start_main(int argc, char **argv) {
  int status = main(argc, argv);
  sys_exit(status);
}

static int main(int argc, char **argv)
{
  sys_write(1, hello, sizeof(hello)-1);
  return 0;
}

void _Noreturn __attribute__ ((noinline)) sys_exit(int status) {
  syscall1(1, status);
  __builtin_unreachable();
}

int __attribute__ ((noinline)) sys_write(int fd, const void *buf, int size) {
  return syscall3(4, fd, (int) buf, size);
}

static int syscall1(int n, int a1) {
  int ret;
  __asm volatile (
    "  int 0x80"
    : "=a" (ret)
    : "0" (n), "b" (a1)
    : "memory"
  );
  return ret;
}

static int syscall3(int n, int a1, int a2, int a3) {
  int ret;
  __asm volatile (
    "  int 0x80"
    : "=a" (ret)
    : "0" (n), "b" (a1), "c" (a2), "d" (a3)
    : "memory"
  );
  return ret;
}

#![feature(no_core)]
#![feature(lang_items)]
#![feature(naked_functions)]
#![feature(decl_macro)]
#![feature(rustc_attrs)]
#![feature(intrinsics)]
#![no_core]
#![no_main]

#[lang = "sized"]
pub trait Sized {}

#[lang = "copy"]
pub trait Copy {}

impl Copy for i32 {}
impl Copy for usize {}

#[rustc_builtin_macro]
pub macro asm("assembly template", $(operands,)* $(options($(option),*))?) {
  /* compiler built-in */
}

extern "rust-intrinsic" {
  pub fn unreachable() -> !;
}

#[no_mangle]
#[naked]
unsafe extern "C" fn _start() {
  asm!(
    "mov ecx, [esp]",
    "mov eax, esp",
    "add eax, 4",
    "push eax",
    "push ecx",
    "call _start_main",
    options(noreturn),
  )
}

#[no_mangle]
extern "C" fn _start_main(argc: usize, argv: *const *const u8) -> ! {
  let status = main(argc, argv);
  sys_exit(status);
}

#[no_mangle]
fn main(_argc: usize, _argv: *const *const u8) -> i32 {
  let string = b"Hello, world!n" as *const _ as *const u8;
  sys_write(1, string, 14);
  return 0;
}

#[inline(never)]
#[no_mangle]
fn sys_write(fd: i32, data: *const u8, len: i32) -> i32 {
  unsafe { syscall3(4, fd, data as _, len) }
}

#[inline(never)]
#[no_mangle]
fn sys_exit(status: i32) -> ! {
  unsafe {
    syscall1(1, status);
    unreachable()
  }
}

#[inline(always)]
unsafe extern "C" fn syscall1(n: i32, a1: i32) -> i32 {
  let ret: i32;
  asm!(
    "int 0x80",
    in("eax") n,
    in("ebx") a1,
    lateout("eax") ret,
  );
  ret
}

#[inline(always)]
unsafe fn syscall3(n: i32, a1: i32, a2: i32, a3: i32) -> i32 {
  let ret: i32;
  asm!(
    "int 0x80",
    in("eax") n,
    in("ebx") a1,
    in("ecx") a2,
    in("edx") a3,
    lateout("eax") ret,
  );
  ret
}

$ objdump -Cd hello_world

hello_world:     file format elf32-i386

Disassembly of section .text:

004010e3 <_start>:
  4010e3:   8b 0c 24                mov    (%esp),%ecx
  4010e6:   89 e0                   mov    %esp,%eax
  4010e8:   83 c0 04                add    $0x4,%eax
  4010eb:   50                      push   %eax
  4010ec:   51                      push   %ecx
  4010ed:   e8 27 00 00 00          call   401119 <_start_main>
  4010f2:   0f 0b                   ud2    

004010f4 <sys_exit>:
  4010f4:   55                      push   %ebp
  4010f5:   b8 01 00 00 00          mov    $0x1,%eax
  4010fa:   89 e5                   mov    %esp,%ebp
  4010fc:   53                      push   %ebx
  4010fd:   8b 5d 08                mov    0x8(%ebp),%ebx
  401100:   cd 80                   int    $0x80

00401102 <sys_write>:
  401102:   55                      push   %ebp
  401103:   b8 04 00 00 00          mov    $0x4,%eax
  401108:   89 e5                   mov    %esp,%ebp
  40110a:   53                      push   %ebx
  40110b:   8b 4d 0c                mov    0xc(%ebp),%ecx
  40110e:   8b 55 10                mov    0x10(%ebp),%edx
  401111:   8b 5d 08                mov    0x8(%ebp),%ebx
  401114:   cd 80                   int    $0x80
  401116:   5b                      pop    %ebx
  401117:   5d                      pop    %ebp
  401118:   c3                      ret    

00401119 <_start_main>:
  401119:   55                      push   %ebp
  40111a:   89 e5                   mov    %esp,%ebp
  40111c:   83 ec 0c                sub    $0xc,%esp
  40111f:   6a 0e                   push   $0xe
  401121:   68 d4 00 40 00          push   $0x4000d4
  401126:   6a 01                   push   $0x1
  401128:   e8 d5 ff ff ff          call   401102 <sys_write>
  40112d:   31 c0                   xor    %eax,%eax
  40112f:   89 04 24                mov    %eax,(%esp)
  401132:   e8 bd ff ff ff          call   4010f4 <sys_exit>

$ readelf -a hello_world
ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2s complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           Intel 80386
  Version:                           0x1
  Entry point address:               0x4010e3
  Start of program headers:          52 (bytes into file)
  Start of section headers:          336 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         4
  Size of section headers:           40 (bytes)
  Number of section headers:         4
  Section header string table index: 3

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .rodata           PROGBITS        004000d4 0000d4 00000f 00   A  0   0  4
  [ 2] .text             PROGBITS        004010e3 0000e3 000054 00  AX  0   0  1
  [ 3] .shstrtab         STRTAB          00000000 000137 000019 00      0   0  1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  p (processor specific)

There are no section groups in this file.

Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  PHDR           0x000034 0x00400034 0x00400034 0x00080 0x00080 R   0x4
  LOAD           0x000000 0x00400000 0x00400000 0x000e3 0x000e3 R   0x1000
  LOAD           0x0000e3 0x004010e3 0x004010e3 0x00054 0x00054 R E 0x1000
  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0

 Section to Segment mapping:
  Segment Sections...
   00     
   01     .rodata 
   02     .text 
   03     

$ objdump -s ./hello_world

./hello_world:     file format elf32-i386

Contents of section .rodata:
 4000d4 48656c6c 6f2c2077 6f726c64 210a00    Hello, world!.. 
Contents of section .text:
 4010e3 8b0c2489 e083c004 5051e827 0000000f  ..$.....PQ.''....
 4010f3 0b55b801 00000089 e5538b5d 08cd8055  .U.......S.]...U
 401103 b8040000 0089e553 8b4d0c8b 55108b5d  .......S.M..U..]
 401113 08cd805b 5dc35589 e583ec0c 6a0e68d4  ...[].U.....j.h.
 401123 0040006a 01e8d5ff ffff31c0 890424e8  .@.j......1...$.
 401133 bdffffff                             ....               

$ objdump -Cd ./target/i686-unknown-linux-gnu/debug/hello_world

./target/i686-unknown-linux-gnu/debug/hello_world:     file format elf32-i386

Disassembly of section .text:

004010c2 <_start>:
  4010c2:   8b 0c 24                mov    (%esp),%ecx
  4010c5:   89 e0                   mov    %esp,%eax
  4010c7:   83 c0 04                add    $0x4,%eax
  4010ca:   50                      push   %eax
  4010cb:   51                      push   %ecx
  4010cc:   e8 25 00 00 00          call   4010f6 <_start_main>

004010d1 <sys_write>:
  4010d1:   55                      push   %ebp
  4010d2:   b8 04 00 00 00          mov    $0x4,%eax
  4010d7:   89 e5                   mov    %esp,%ebp
  4010d9:   53                      push   %ebx
  4010da:   8b 5d 08                mov    0x8(%ebp),%ebx
  4010dd:   8b 4d 0c                mov    0xc(%ebp),%ecx
  4010e0:   8b 55 10                mov    0x10(%ebp),%edx
  4010e3:   cd 80                   int    $0x80
  4010e5:   5b                      pop    %ebx
  4010e6:   5d                      pop    %ebp
  4010e7:   c3                      ret    

004010e8 <sys_exit>:
  4010e8:   55                      push   %ebp
  4010e9:   b8 01 00 00 00          mov    $0x1,%eax
  4010ee:   89 e5                   mov    %esp,%ebp
  4010f0:   53                      push   %ebx
  4010f1:   8b 5d 08                mov    0x8(%ebp),%ebx
  4010f4:   cd 80                   int    $0x80

004010f6 <_start_main>:
  4010f6:   55                      push   %ebp
  4010f7:   89 e5                   mov    %esp,%ebp
  4010f9:   83 ec 0c                sub    $0xc,%esp
  4010fc:   6a 0e                   push   $0xe
  4010fe:   68 b4 00 40 00          push   $0x4000b4
  401103:   6a 01                   push   $0x1
  401105:   e8 c7 ff ff ff          call   4010d1 <sys_write>
  40110a:   31 c0                   xor    %eax,%eax
  40110c:   89 04 24                mov    %eax,(%esp)
  40110f:   e8 d4 ff ff ff          call   4010e8 <sys_exit>

$ readelf -a ./target/i686-unknown-linux-gnu/debug/hello_world
ELF Header:
  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF32
  Data:                              2s complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              EXEC (Executable file)
  Machine:                           Intel 80386
  Version:                           0x1
  Entry point address:               0x4010c2
  Start of program headers:          52 (bytes into file)
  Start of section headers:          304 (bytes into file)
  Flags:                             0x0
  Size of this header:               52 (bytes)
  Size of program headers:           32 (bytes)
  Number of program headers:         4
  Size of section headers:           40 (bytes)
  Number of section headers:         4
  Section header string table index: 3

Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [ 0]                   NULL            00000000 000000 000000 00      0   0  0
  [ 1] .rodata           PROGBITS        004000b4 0000b4 00000e 00   A  0   0  4
  [ 2] .text             PROGBITS        004010c2 0000c2 000052 00  AX  0   0  1
  [ 3] .shstrtab         STRTAB          00000000 000114 000019 00      0   0  1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  p (processor specific)

There are no section groups in this file.

Program Headers:
  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
  PHDR           0x000034 0x00400034 0x00400034 0x00080 0x00080 R   0x4
  LOAD           0x000000 0x00400000 0x00400000 0x000c2 0x000c2 R   0x1000
  LOAD           0x0000c2 0x004010c2 0x004010c2 0x00052 0x00052 R E 0x1000
  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0

 Section to Segment mapping:
  Segment Sections...
   00     
   01     .rodata 
   02     .text 
   03     

$ objdump -s ./target/i686-unknown-linux-gnu/debug/hello_world

./target/i686-unknown-linux-gnu/debug/hello_world:     file format elf32-i386

Contents of section .rodata:
 4000b4 48656c6c 6f2c2077 6f726c64 210a      Hello, world!.  
Contents of section .text:
 4010c2 8b0c2489 e083c004 5051e825 00000055  ..$.....PQ.%...U
 4010d2 b8040000 0089e553 8b5d088b 4d0c8b55  .......S.]..M..U
 4010e2 10cd805b 5dc355b8 01000000 89e5538b  ...[].U.......S.
 4010f2 5d08cd80 5589e583 ec0c6a0e 68b40040  ]...U.....j.h..@
 401102 006a01e8 c7ffffff 31c08904 24e8d4ff  .j......1...$...
 401112 ffff                                 ..