Mfcttrf

Rust has 128-bit integers, denoted with the datatype i128 (and u128 for unsigned ints):

let a: i128 = 170141183460469231731687303715884105727;

How does Rust make these i128 values work on a 64-bit OS? How does it do arithmetic on these? Since, as far as I know, the value cannot fit in one register of a x86-64 CPU. Does the compiler somehow use 2 registers for one i128 value, or are they using some kind of big integer struct to represent them?

All Rust's integer types are compiled to LLVM integers. The LLVM abstract machine allows integers of any bit width from 1 to 2^23 - 1.* LLVM instructions typically work on integers of any size.

Obviously, there aren't many 8388607-bit architectures out there, so when the code is compiled to native machine code, LLVM has to decide how to implement it. The semantics of an abstract instruction like add are defined by LLVM. Typically, instructions that have a single-instruction equivalent in native code will be compiled to that instruction, while those that don't will be emulated, possibly with multiple instructions. mcarton's answer demonstrates both native and emulated instructions.

(This doesn't only apply to integers that are larger than the native machine can support, but also to those that are smaller. For example, modern architectures might not support native 8-bit arithmetic, so an add instruction on two i8s may be emulated with a wider instruction, the extra bits discarded.)

Does the compiler somehow use 2 registers for one i128 value? Or are they using some kind of big integer struct to represent them?

At the level of LLVM IR, the answer is neither: i128 fits in a single register, just like every other single-valued type. On the other hand, once translated to machine code, there isn't really a difference between the two, because structs may be decomposed into registers just like integers. When doing arithmetic, though, loading the whole thing into two registers is a pretty safe bet.

* Although I understand that support for sizes larger than 128 and non-powers of two is spotty and the implementation may have bugs, which may partly explain why Rust only exposes 1-, 8-, 16-, 32-, 64-, and 128-bit integers.

The compiler will store these in multiple registers and use multiple instructions to do arithmetic on those values if needed. For example, given

fn main() 
 let a = 42u128;
 let b = a + 1337;

the compiler generates:

playground::main:
 sub rsp, 56
 mov qword ptr [rsp + 32], 0
 mov qword ptr [rsp + 24], 42
 mov rax, qword ptr [rsp + 24]
 mov rcx, qword ptr [rsp + 32]
 add rax, 1337
 adc rcx, 0
 setb dl
 mov rsi, rax
 test dl, 1
 mov qword ptr [rsp + 16], rax
 mov qword ptr [rsp + 8], rsi
 mov qword ptr [rsp], rcx
 jne .LBB8_2
 mov rax, qword ptr [rsp + 16]
 mov qword ptr [rsp + 40], rax
 mov rcx, qword ptr [rsp]
 mov qword ptr [rsp + 48], rcx
 add rsp, 56
 ret

where you can see that the value 42 is stored in rax and rcx. For comparison, here is the simpler 64 bits variant:

playground::main:
 sub rsp, 24
 mov qword ptr [rsp + 8], 42
 mov rax, qword ptr [rsp + 8]
 add rax, 1337
 setb cl
 test cl, 1
 mov qword ptr [rsp], rax
 jne .LBB8_2
 mov rax, qword ptr [rsp]
 mov qword ptr [rsp + 16], rax
 add rsp, 24
 ret

64 bit in a 64 bit architecture refers to the length of address to the actual position in memory.

128 bit in in the i128 type refers to the size of the data which is stored at the location