Support 128-bit integers `i128` `u128`

6 files changed, 194 insertions, 52 deletions

diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 274ed9fc2..1e7e7a965 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -1332,9 +1332,29 @@ bool check_representable_as_constant(CheckerContext *c, ExactValue in_value, Typ
 		BigInt imin = {};
 		BigInt imax = {};
 
-		big_int_from_u64(&umax, unsigned_integer_maxs[bit_size]);
-		big_int_from_i64(&imin, signed_integer_mins[bit_size]);
-		big_int_from_i64(&imax, signed_integer_maxs[bit_size]);
+		if (bit_size < 16) {
+			big_int_from_u64(&umax, unsigned_integer_maxs[bit_size]);
+			big_int_from_i64(&imin, signed_integer_mins[bit_size]);
+			big_int_from_i64(&imax, signed_integer_maxs[bit_size]);
+		} else {
+			big_int_from_u64(&umax, 1);
+			big_int_from_i64(&imin, 1);
+			big_int_from_i64(&imax, 1);
+
+			BigInt bi128 = {};
+			BigInt bi127 = {};
+			big_int_from_i64(&bi128, 128);
+			big_int_from_i64(&bi127, 127);
+
+			big_int_shl_eq(&umax, &bi128);
+			big_int_sub_eq(&umax, &BIG_INT_ONE);
+
+			big_int_shl_eq(&imin, &bi127);
+			big_int_neg(&imin, &imin);
+
+			big_int_shl_eq(&imax, &bi127);
+			big_int_sub_eq(&imax, &BIG_INT_ONE);
+		}
 
 		switch (type->Basic.kind) {
 		case Basic_rune:
@@ -1342,14 +1362,17 @@ bool check_representable_as_constant(CheckerContext *c, ExactValue in_value, Typ
 		case Basic_i16:
 		case Basic_i32:
 		case Basic_i64:
+		case Basic_i128:
 		case Basic_int:
 
 		case Basic_i16le:
 		case Basic_i32le:
 		case Basic_i64le:
+		case Basic_i128le:
 		case Basic_i16be:
 		case Basic_i32be:
 		case Basic_i64be:
+		case Basic_i128be:
 			{
 				// return imin <= i && i <= imax;
 				int a = big_int_cmp(&imin, &i);
@@ -1361,15 +1384,18 @@ bool check_representable_as_constant(CheckerContext *c, ExactValue in_value, Typ
 		case Basic_u16:
 		case Basic_u32:
 		case Basic_u64:
+		case Basic_u128:
 		case Basic_uint:
 		case Basic_uintptr:
 
 		case Basic_u16le:
 		case Basic_u32le:
 		case Basic_u64le:
+		case Basic_u128le:
 		case Basic_u16be:
 		case Basic_u32be:
 		case Basic_u64be:
+		case Basic_u128be:
 			{
 				// return 0ull <= i && i <= umax;
 				int b = big_int_cmp(&i, &umax);
diff --git a/src/check_type.cpp b/src/check_type.cpp
index 790cec789..15c621729 100644
--- a/src/check_type.cpp
+++ b/src/check_type.cpp
@@ -1848,6 +1848,13 @@ Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type) {
 		// NOTE(bill): Changing the passing parameter value type is to match C's ABI
 		// IMPORTANT TODO(bill): This only matches the ABI on MSVC at the moment
 		// SEE: https://msdn.microsoft.com/en-us/library/zthk2dkh.aspx
+
+		if (build_context.word_size == 8) {
+			if (is_type_integer_128bit(original_type)) {
+				return alloc_type_simd_vector(2, t_u64);
+			}
+		}
+
 		Type *bt = core_type(original_type);
 		switch (bt->kind) {
 		// Okay to pass by value (usually)
@@ -1954,6 +1961,12 @@ Type *type_to_abi_compat_result_type(gbAllocator a, Type *original_type) {
 	}
 
 	if (build_context.ODIN_OS == "windows") {
+		if (build_context.word_size == 8) {
+			if (is_type_integer_128bit(single_type)) {
+				return alloc_type_simd_vector(2, t_u64);
+			}
+		}
+
 		Type *bt = core_type(reduce_tuple_to_single_type(original_type));
 		// NOTE(bill): This is just reversed engineered from LLVM IR output
 		switch (bt->kind) {
@@ -1986,6 +1999,13 @@ Type *type_to_abi_compat_result_type(gbAllocator a, Type *original_type) {
 		// their architectures
 	}
 
+	if (is_type_integer_128bit(single_type)) {
+		if (build_context.word_size == 8) {
+			return original_type;
+		}
+	}
+
+
 	if (new_type != original_type) {
 		Type *tuple = alloc_type_tuple();
 		auto variables = array_make<Entity *>(a, 0, 1);
@@ -2012,6 +2032,12 @@ bool abi_compat_return_by_pointer(gbAllocator a, ProcCallingConvention cc, Type
 
 
 	if (build_context.ODIN_OS == "windows") {
+		if (build_context.word_size == 8) {
+			if (is_type_integer_128bit(single_type)) {
+				return false;
+			}
+		}
+
 		i64 size = 8*type_size_of(abi_return_type);
 		switch (size) {
 		case 0:
@@ -2023,7 +2049,14 @@ bool abi_compat_return_by_pointer(gbAllocator a, ProcCallingConvention cc, Type
 		default:
 			return true;
 		}
+	} else {
+		if (is_type_integer_128bit(single_type)) {
+			return build_context.word_size < 8;
+		}
 	}
+
+
+
 	return false;
 }
 
diff --git a/src/checker.cpp b/src/checker.cpp
index 0fd92890d..4712876de 100644
--- a/src/checker.cpp
+++ b/src/checker.cpp
@@ -1585,6 +1585,9 @@ void generate_minimum_dependency_set(Checker *c, Entity *start) {
 
 		str_lit("quo_complex64"),
 		str_lit("quo_complex128"),
+
+		str_lit("umodti3"),
+		str_lit("udivti3"),
 	};
 	for (isize i = 0; i < gb_count_of(required_runtime_entities); i++) {
 		add_dependency_to_set(c, scope_lookup(c->info.runtime_package->scope, required_runtime_entities[i]));
diff --git a/src/ir.cpp b/src/ir.cpp
index 2f2da1826..b06c041e4 100644
--- a/src/ir.cpp
+++ b/src/ir.cpp
@@ -422,6 +422,7 @@ enum irParamPasskind {
 	irParamPass_Pointer,  // Pass as a pointer rather than by value
 	irParamPass_Integer,  // Pass as an integer of the same size
 	irParamPass_ConstRef, // Pass as a pointer but the value is immutable
+	irParamPass_BitCast,  // Pass by value and bit cast to the correct type
 };
 
 struct irValueParam {
@@ -871,7 +872,7 @@ void ir_emit_increment(irProcedure *proc, irValue *addr);
 irValue *ir_emit_array_ep(irProcedure *proc, irValue *s, irValue *index);
 irValue *ir_emit_array_epi(irProcedure *proc, irValue *s, i32 index);
 irValue *ir_emit_struct_ev(irProcedure *proc, irValue *s, i32 index);
-
+irValue *ir_emit_bitcast(irProcedure *proc, irValue *data, Type *type);
 irValue *ir_emit_byte_swap(irProcedure *proc, irValue *value, Type *t);
 
 irValue *ir_alloc_value(irValueKind kind) {
@@ -930,6 +931,8 @@ irValue *ir_value_param(irProcedure *parent, Entity *e, Type *abi_type) {
 			v->Param.kind = irParamPass_Integer;
 		} else if (abi_type == t_llvm_bool) {
 			v->Param.kind = irParamPass_Value;
+		} else if (is_type_simd_vector(abi_type)) {
+			v->Param.kind = irParamPass_BitCast;
 		} else {
 			GB_PANIC("Invalid abi type pass kind");
 		}
@@ -1738,6 +1741,14 @@ irValue *ir_add_param(irProcedure *proc, Entity *e, Ast *expr, Type *abi_type, i
 	case irParamPass_ConstRef:
 		ir_module_add_value(proc->module, e, v);
 		return ir_emit_load(proc, v);
+
+	case irParamPass_BitCast: {
+		irValue *l = ir_add_local(proc, e, expr, false, index);
+		irValue *x = ir_emit_bitcast(proc, v, e->type);
+		ir_emit_store(proc, l, x);
+		return x;
+	}
+
 	}
 
 	GB_PANIC("Unreachable");
@@ -1814,15 +1825,19 @@ irDebugEncoding ir_debug_encoding_for_basic(BasicKind kind) {
 	case Basic_u8:
 		return irDebugBasicEncoding_unsigned_char;
 
+
 	case Basic_i16:
 	case Basic_i32:
 	case Basic_i64:
+	case Basic_i128:
 	case Basic_i16le:
 	case Basic_i32le:
 	case Basic_i64le:
+	case Basic_i128le:
 	case Basic_i16be:
 	case Basic_i32be:
 	case Basic_i64be:
+	case Basic_i128be:
 	case Basic_int:
 	case Basic_rune:
 	case Basic_typeid:
@@ -1831,12 +1846,15 @@ irDebugEncoding ir_debug_encoding_for_basic(BasicKind kind) {
 	case Basic_u16:
 	case Basic_u32:
 	case Basic_u64:
+	case Basic_u128:
 	case Basic_u16le:
 	case Basic_u32le:
 	case Basic_u64le:
+	case Basic_u128le:
 	case Basic_u16be:
 	case Basic_u32be:
 	case Basic_u64be:
+	case Basic_u128be:
 	case Basic_uint:
 	case Basic_uintptr:
 		return irDebugBasicEncoding_unsigned;
@@ -2996,6 +3014,8 @@ irValue *ir_emit_call(irProcedure *p, irValue *value, Array<irValue *> args, Pro
 				args[i] = ir_emit_transmute(p, args[i], new_type);
 			} else if (new_type == t_llvm_bool) {
 				args[i] = ir_emit_conv(p, args[i], new_type);
+			} else if (is_type_simd_vector(new_type)) {
+				args[i] = ir_emit_bitcast(p, args[i], new_type);
 			}
 		}
 	}
@@ -9740,6 +9760,8 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 			case Basic_u32:
 			case Basic_i64:
 			case Basic_u64:
+			case Basic_i128:
+			case Basic_u128:
 
 			case Basic_i16le:
 			case Basic_u16le:
@@ -9747,13 +9769,16 @@ void ir_setup_type_info_data(irProcedure *proc) { // NOTE(bill): Setup type_info
 			case Basic_u32le:
 			case Basic_i64le:
 			case Basic_u64le:
+			case Basic_i128le:
+			case Basic_u128le:
 			case Basic_i16be:
 			case Basic_u16be:
 			case Basic_i32be:
 			case Basic_u32be:
 			case Basic_i64be:
 			case Basic_u64be:
-
+			case Basic_i128be:
+			case Basic_u128be:
 
 			case Basic_int:
 			case Basic_uint:
diff --git a/src/ir_print.cpp b/src/ir_print.cpp
index 46bcfc139..b008fa682 100644
--- a/src/ir_print.cpp
+++ b/src/ir_print.cpp
@@ -75,21 +75,39 @@ void ir_write_u64(irFileBuffer *f, u64 i) {
 	ir_write_string(f, str);
 }
 void ir_write_big_int(irFileBuffer *f, BigInt const &x, Type *type, bool swap_endian) {
-	i64 i = 0;
-	if (x.neg) {
-		i = big_int_to_i64(&x);
+	if (x.len == 2) {
+		gbAllocator a = heap_allocator(); // TODO(bill): Change this allocator
+		u64 words[2] = {};
+		BigInt y = x;
+		if (swap_endian) {
+			gb_memmove(words, y.d.words, 16);
+			u8 *bytes = cast(u8 *)words;
+			for (isize i = 0; i < 8; i++) {
+				bytes[i] = bytes[16-i]; // byte swap
+			}
+			y.d.words = words;
+		}
+
+		String s = big_int_to_string(a, &y, 10);
+		ir_write_string(f, s);
+		gb_free(a, s.text);
 	} else {
-		i = cast(i64)big_int_to_u64(&x);
-	}
-	if (swap_endian) {
-		i64 size = type_size_of(type);
-		switch (size) {
-		case 2: i = cast(i64)cast(i16)gb_endian_swap16(cast(u16)cast(i16)i); break;
-		case 4: i = cast(i64)cast(i32)gb_endian_swap32(cast(u32)cast(i32)i); break;
-		case 8: i = cast(i64)gb_endian_swap64(cast(u64)i); break;
+		i64 i = 0;
+		if (x.neg) {
+			i = big_int_to_i64(&x);
+		} else {
+			i = cast(i64)big_int_to_u64(&x);
+		}
+		if (swap_endian) {
+			i64 size = type_size_of(type);
+			switch (size) {
+			case 2: i = cast(i64)cast(i16)gb_endian_swap16(cast(u16)cast(i16)i); break;
+			case 4: i = cast(i64)cast(i32)gb_endian_swap32(cast(u32)cast(i32)i); break;
+			case 8: i = cast(i64)gb_endian_swap64(cast(u64)i); break;
+			}
 		}
+		ir_write_i64(f, i);
 	}
-	ir_write_i64(f, i);
 }
 
 void ir_file_write(irFileBuffer *f, void *data, isize len) {
@@ -359,28 +377,34 @@ void ir_print_type(irFileBuffer *f, irModule *m, Type *t, bool in_struct) {
 		case Basic_b32:       ir_write_str_lit(f, "i32"); return;
 		case Basic_b64:       ir_write_str_lit(f, "i64"); return;
 
-		case Basic_i8:   ir_write_str_lit(f, "i8");  return;
-		case Basic_u8:   ir_write_str_lit(f, "i8");  return;
-		case Basic_i16:  ir_write_str_lit(f, "i16"); return;
-		case Basic_u16:  ir_write_str_lit(f, "i16"); return;
-		case Basic_i32:  ir_write_str_lit(f, "i32"); return;
-		case Basic_u32:  ir_write_str_lit(f, "i32"); return;
-		case Basic_i64:  ir_write_str_lit(f, "i64"); return;
-		case Basic_u64:  ir_write_str_lit(f, "i64"); return;
-
-		case Basic_i16le: ir_write_str_lit(f, "i16"); return;
-		case Basic_u16le: ir_write_str_lit(f, "i16"); return;
-		case Basic_i32le: ir_write_str_lit(f, "i32"); return;
-		case Basic_u32le: ir_write_str_lit(f, "i32"); return;
-		case Basic_i64le: ir_write_str_lit(f, "i64"); return;
-		case Basic_u64le: ir_write_str_lit(f, "i64"); return;
-
-		case Basic_i16be: ir_write_str_lit(f, "i16"); return;
-		case Basic_u16be: ir_write_str_lit(f, "i16"); return;
-		case Basic_i32be: ir_write_str_lit(f, "i32"); return;
-		case Basic_u32be: ir_write_str_lit(f, "i32"); return;
-		case Basic_i64be: ir_write_str_lit(f, "i64"); return;
-		case Basic_u64be: ir_write_str_lit(f, "i64"); return;
+		case Basic_i8:    ir_write_str_lit(f, "i8");   return;
+		case Basic_u8:    ir_write_str_lit(f, "i8");   return;
+		case Basic_i16:   ir_write_str_lit(f, "i16");  return;
+		case Basic_u16:   ir_write_str_lit(f, "i16");  return;
+		case Basic_i32:   ir_write_str_lit(f, "i32");  return;
+		case Basic_u32:   ir_write_str_lit(f, "i32");  return;
+		case Basic_i64:   ir_write_str_lit(f, "i64");  return;
+		case Basic_u64:   ir_write_str_lit(f, "i64");  return;
+		case Basic_i128:  ir_write_str_lit(f, "i128"); return;
+		case Basic_u128:  ir_write_str_lit(f, "i128"); return;
+
+		case Basic_i16le:  ir_write_str_lit(f, "i16");  return;
+		case Basic_u16le:  ir_write_str_lit(f, "i16");  return;
+		case Basic_i32le:  ir_write_str_lit(f, "i32");  return;
+		case Basic_u32le:  ir_write_str_lit(f, "i32");  return;
+		case Basic_i64le:  ir_write_str_lit(f, "i64");  return;
+		case Basic_u64le:  ir_write_str_lit(f, "i64");  return;
+		case Basic_i128le: ir_write_str_lit(f, "i128"); return;
+		case Basic_u128le: ir_write_str_lit(f, "i128"); return;
+
+		case Basic_i16be:  ir_write_str_lit(f, "i16");  return;
+		case Basic_u16be:  ir_write_str_lit(f, "i16");  return;
+		case Basic_i32be:  ir_write_str_lit(f, "i32");  return;
+		case Basic_u32be:  ir_write_str_lit(f, "i32");  return;
+		case Basic_i64be:  ir_write_str_lit(f, "i64");  return;
+		case Basic_u64be:  ir_write_str_lit(f, "i64");  return;
+		case Basic_i128be: ir_write_str_lit(f, "i128"); return;
+		case Basic_u128be: ir_write_str_lit(f, "i128"); return;
 
 		case Basic_rune: ir_write_str_lit(f, "i32"); return;
 
@@ -2209,6 +2233,9 @@ void print_llvm_ir(irGen *ir) {
 	if (map_get(&m->members, hash_string(str_lit("llvm.bswap.i64"))) == nullptr) {
 		ir_write_str_lit(f, "declare i64 @llvm.bswap.i64(i64) \n");
 	}
+	if (map_get(&m->members, hash_string(str_lit("llvm.bswap.i128"))) == nullptr) {
+		ir_write_str_lit(f, "declare i128 @llvm.bswap.i128(i128) \n");
+	}
 	ir_write_byte(f, '\n');
 
 
diff --git a/src/types.cpp b/src/types.cpp
index 7643f366d..0c4c11175 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -19,6 +19,8 @@ enum BasicKind {
 	Basic_u32,
 	Basic_i64,
 	Basic_u64,
+	Basic_i128,
+	Basic_u128,
 
 	Basic_rune,
 
@@ -47,6 +49,8 @@ enum BasicKind {
 	Basic_u32le,
 	Basic_i64le,
 	Basic_u64le,
+	Basic_i128le,
+	Basic_u128le,
 
 	Basic_i16be,
 	Basic_u16be,
@@ -54,6 +58,8 @@ enum BasicKind {
 	Basic_u32be,
 	Basic_i64be,
 	Basic_u64be,
+	Basic_i128be,
+	Basic_u128be,
 
 	// Untyped types
 	Basic_UntypedBool,
@@ -321,6 +327,9 @@ gb_global Type basic_types[] = {
 	{Type_Basic, {Basic_i64,               BasicFlag_Integer,                          8, STR_LIT("i64")}},
 	{Type_Basic, {Basic_u64,               BasicFlag_Integer | BasicFlag_Unsigned,     8, STR_LIT("u64")}},
 
+	{Type_Basic, {Basic_i128,               BasicFlag_Integer,                        16, STR_LIT("i128")}},
+	{Type_Basic, {Basic_u128,               BasicFlag_Integer | BasicFlag_Unsigned,   16, STR_LIT("u128")}},
+
 	{Type_Basic, {Basic_rune,              BasicFlag_Integer | BasicFlag_Rune,         4, STR_LIT("rune")}},
 
 	// {Type_Basic, {Basic_f16,               BasicFlag_Float,                            2, STR_LIT("f16")}},
@@ -343,19 +352,23 @@ gb_global Type basic_types[] = {
 	{Type_Basic, {Basic_typeid,            0,                                         -1, STR_LIT("typeid")}},
 
 	// Endian
-	{Type_Basic, {Basic_i16le, BasicFlag_Integer |                      BasicFlag_EndianLittle, 2, STR_LIT("i16le")}},
-	{Type_Basic, {Basic_u16le, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianLittle, 2, STR_LIT("u16le")}},
-	{Type_Basic, {Basic_i32le, BasicFlag_Integer |                      BasicFlag_EndianLittle, 4, STR_LIT("i32le")}},
-	{Type_Basic, {Basic_u32le, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianLittle, 4, STR_LIT("u32le")}},
-	{Type_Basic, {Basic_i64le, BasicFlag_Integer |                      BasicFlag_EndianLittle, 8, STR_LIT("i64le")}},
-	{Type_Basic, {Basic_u64le, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianLittle, 8, STR_LIT("u64le")}},
-
-	{Type_Basic, {Basic_i16be, BasicFlag_Integer |                      BasicFlag_EndianBig,    2, STR_LIT("i16be")}},
-	{Type_Basic, {Basic_u16be, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianBig,    2, STR_LIT("u16be")}},
-	{Type_Basic, {Basic_i32be, BasicFlag_Integer |                      BasicFlag_EndianBig,    4, STR_LIT("i32be")}},
-	{Type_Basic, {Basic_u32be, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianBig,    4, STR_LIT("u32be")}},
-	{Type_Basic, {Basic_i64be, BasicFlag_Integer |                      BasicFlag_EndianBig,    8, STR_LIT("i64be")}},
-	{Type_Basic, {Basic_u64be, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianBig,    8, STR_LIT("u64be")}},
+	{Type_Basic, {Basic_i16le,  BasicFlag_Integer |                      BasicFlag_EndianLittle,  2, STR_LIT("i16le")}},
+	{Type_Basic, {Basic_u16le,  BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianLittle,  2, STR_LIT("u16le")}},
+	{Type_Basic, {Basic_i32le,  BasicFlag_Integer |                      BasicFlag_EndianLittle,  4, STR_LIT("i32le")}},
+	{Type_Basic, {Basic_u32le,  BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianLittle,  4, STR_LIT("u32le")}},
+	{Type_Basic, {Basic_i64le,  BasicFlag_Integer |                      BasicFlag_EndianLittle,  8, STR_LIT("i64le")}},
+	{Type_Basic, {Basic_u64le,  BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianLittle,  8, STR_LIT("u64le")}},
+	{Type_Basic, {Basic_i128le, BasicFlag_Integer                      | BasicFlag_EndianLittle, 16, STR_LIT("i128le")}},
+	{Type_Basic, {Basic_u128le, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianLittle, 16, STR_LIT("u128le")}},
+
+	{Type_Basic, {Basic_i16be,  BasicFlag_Integer |                      BasicFlag_EndianBig,     2, STR_LIT("i16be")}},
+	{Type_Basic, {Basic_u16be,  BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianBig,     2, STR_LIT("u16be")}},
+	{Type_Basic, {Basic_i32be,  BasicFlag_Integer |                      BasicFlag_EndianBig,     4, STR_LIT("i32be")}},
+	{Type_Basic, {Basic_u32be,  BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianBig,     4, STR_LIT("u32be")}},
+	{Type_Basic, {Basic_i64be,  BasicFlag_Integer |                      BasicFlag_EndianBig,     8, STR_LIT("i64be")}},
+	{Type_Basic, {Basic_u64be,  BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianBig,     8, STR_LIT("u64be")}},
+	{Type_Basic, {Basic_i128be, BasicFlag_Integer                      | BasicFlag_EndianBig,    16, STR_LIT("i128be")}},
+	{Type_Basic, {Basic_u128be, BasicFlag_Integer | BasicFlag_Unsigned | BasicFlag_EndianBig,    16, STR_LIT("u128be")}},
 
 	// Untyped types
 	{Type_Basic, {Basic_UntypedBool,       BasicFlag_Boolean    | BasicFlag_Untyped,   0, STR_LIT("untyped bool")}},
@@ -384,6 +397,8 @@ gb_global Type *t_i32             = &basic_types[Basic_i32];
 gb_global Type *t_u32             = &basic_types[Basic_u32];
 gb_global Type *t_i64             = &basic_types[Basic_i64];
 gb_global Type *t_u64             = &basic_types[Basic_u64];
+gb_global Type *t_i128            = &basic_types[Basic_i128];
+gb_global Type *t_u128            = &basic_types[Basic_u128];
 
 gb_global Type *t_rune            = &basic_types[Basic_rune];
 
@@ -412,6 +427,8 @@ gb_global Type *t_i32le           = &basic_types[Basic_i32le];
 gb_global Type *t_u32le           = &basic_types[Basic_u32le];
 gb_global Type *t_i64le           = &basic_types[Basic_i64le];
 gb_global Type *t_u64le           = &basic_types[Basic_u64le];
+gb_global Type *t_i128le          = &basic_types[Basic_i128le];
+gb_global Type *t_u128le          = &basic_types[Basic_u128le];
 
 gb_global Type *t_i16be           = &basic_types[Basic_i16be];
 gb_global Type *t_u16be           = &basic_types[Basic_u16be];
@@ -419,6 +436,9 @@ gb_global Type *t_i32be           = &basic_types[Basic_i32be];
 gb_global Type *t_u32be           = &basic_types[Basic_u32be];
 gb_global Type *t_i64be           = &basic_types[Basic_i64be];
 gb_global Type *t_u64be           = &basic_types[Basic_u64be];
+gb_global Type *t_i128be          = &basic_types[Basic_i128be];
+gb_global Type *t_u128be          = &basic_types[Basic_u128be];
+
 
 gb_global Type *t_untyped_bool       = &basic_types[Basic_UntypedBool];
 gb_global Type *t_untyped_integer    = &basic_types[Basic_UntypedInteger];
@@ -799,6 +819,14 @@ bool is_type_unsigned(Type *t) {
 	}
 	return false;
 }
+bool is_type_integer_128bit(Type *t) {
+	// t = core_type(t);
+	t = base_type(t);
+	if (t->kind == Type_Basic) {
+		return (t->Basic.flags & BasicFlag_Integer) != 0 && t->Basic.size == 16;
+	}
+	return false;
+}
 bool is_type_rune(Type *t) {
 	// t = core_type(t);
 	t = base_type(t);