Remove old procedure ABI code

src/check_expr.cpp

@@ -103,10 +103,6 @@ CallArgumentData check_call_arguments   (CheckerContext *c, Operand *operand, Ty
 Type *           check_init_variable    (CheckerContext *c, Entity *e, Operand *operand, String context_name);
 
 
-Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type, ProcCallingConvention cc);
-Type *type_to_abi_compat_result_type(gbAllocator a, Type *original_type, ProcCallingConvention cc);
-bool abi_compat_return_by_pointer(gbAllocator a, ProcCallingConvention cc, Type *abi_return_type);
-void set_procedure_abi_types(Type *type);
 void check_assignment_error_suggestion(CheckerContext *c, Operand *o, Type *type);
 void add_map_key_type_dependencies(CheckerContext *ctx, Type *key);
 
@@ -1088,10 +1084,6 @@ bool is_polymorphic_type_assignable(CheckerContext *c, Type *poly, Type *source,
 				if (!ok) return false;
 			}
 
-			if (modify_type) {
-				set_procedure_abi_types(source);
-			}
-
 			return true;
 			#endif
 		}

src/check_type.cpp

@@ -1162,9 +1162,6 @@ Type *determine_type_from_polymorphic(CheckerContext *ctx, Type *poly_type, Oper
 	}
 
 	if (is_polymorphic_type_assignable(ctx, poly_type, operand.type, false, modify_type)) {
-		if (show_error) {
-			set_procedure_abi_types(poly_type);
-		}
 		return poly_type;
 	}
 	if (show_error) {
@@ -1767,623 +1764,8 @@ Type *check_get_results(CheckerContext *ctx, Scope *scope, Ast *_results) {
 	return tuple;
 }
 
-Array<Type *> systemv_distribute_struct_fields(Type *t) {
-	Type *bt = core_type(t);
-
-
-	isize distributed_cap = 1;
-	if (bt->kind == Type_Struct) {
-		distributed_cap = bt->Struct.fields.count;
-	}
-	auto distributed = array_make<Type *>(heap_allocator(), 0, distributed_cap);
-
-	i64 sz = type_size_of(bt);
-	switch (bt->kind) {
-	case Type_Basic:
-		switch (bt->Basic.kind){
-		case Basic_complex64:
-			array_add(&distributed, t_f32);
-			array_add(&distributed, t_f32);
-			break;
-		case Basic_complex128:
-			array_add(&distributed, t_f64);
-			array_add(&distributed, t_f64);
-			break;
-		case Basic_quaternion128:
-			array_add(&distributed, t_f32);
-			array_add(&distributed, t_f32);
-			array_add(&distributed, t_f32);
-			array_add(&distributed, t_f32);
-			break;
-		case Basic_quaternion256:
-			goto DEFAULT;
-		case Basic_string:
-			array_add(&distributed, t_u8_ptr);
-			array_add(&distributed, t_int);
-			break;
-		case Basic_any:
-			GB_ASSERT(type_size_of(t_uintptr) == type_size_of(t_typeid));
-			array_add(&distributed, t_rawptr);
-			array_add(&distributed, t_uintptr);
-			break;
-
-		case Basic_u128:
-		case Basic_i128:
-			if (build_context.ODIN_OS == "windows") {
-				array_add(&distributed, alloc_type_simd_vector(2, t_u64));
-			} else {
-				array_add(&distributed, bt);
-			}
-			break;
-
-		default:
-			goto DEFAULT;
-		}
-		break;
-
-	case Type_Struct:
-		if (bt->Struct.is_raw_union) {
-			goto DEFAULT;
-		} else {
-			// IMPORTANT TOOD(bill): handle #packed structs correctly
-			// IMPORTANT TODO(bill): handle #align structs correctly
-			for_array(field_index, bt->Struct.fields) {
-				Entity *f = bt->Struct.fields[field_index];
-				auto nested = systemv_distribute_struct_fields(f->type);
-				array_add_elems(&distributed, nested.data, nested.count);
-				array_free(&nested);
-			}
-		}
-		break;
-
-	case Type_Array:
-		for (i64 i = 0; i < bt->Array.count; i++) {
-			array_add(&distributed, bt->Array.elem);
-		}
-		break;
-
-	case Type_BitSet:
-		array_add(&distributed, bit_set_to_int(bt));
-		break;
-
-	case Type_Tuple:
-		GB_PANIC("Invalid struct field type");
-		break;
-
-	case Type_Slice:
-		array_add(&distributed, t_rawptr);
-		array_add(&distributed, t_int);
-		break;
-
-	case Type_Union:
-	case Type_DynamicArray:
-	case Type_Map:
-		// NOTE(bill, 2019-10-10): Odin specific, don't worry about C calling convention yet
-		goto DEFAULT;
-
-	case Type_Pointer:
-	case Type_Proc:
-	case Type_SimdVector: // TODO(bill): Is this correct logic?
-	default:
-	DEFAULT:;
-		if (sz > 0) {
-			array_add(&distributed, bt);
-		}
-		break;
-	}
-
-	return distributed;
-}
-
-Type *struct_type_from_systemv_distribute_struct_fields(Type *abi_type) {
-	GB_ASSERT(is_type_tuple(abi_type));
-	Type *final_type = alloc_type_struct();
-	final_type->Struct.fields = abi_type->Tuple.variables;
-	return final_type;
-}
-
-
-Type *handle_single_distributed_type_parameter(Array<Type *> const &types, bool packed, isize *offset) {
-	GB_ASSERT(types.count > 0);
-
-	if (types.count == 1) {
-		if (offset) *offset = 1;
-
-		i64 sz = type_size_of(types[0]);
-
-		if (is_type_float(types[0])) {
-			return types[0];
-		}
-		switch (sz) {
-		case 0:
-			GB_PANIC("Zero sized type found!");
-		case 1: return t_u8;
-		case 2: return t_u16;
-		case 4: return t_u32;
-		case 8: return t_u64;
-		default:
-			return types[0];
-		}
-	} else if (types.count >= 2) {
-	    if (types[0] == t_f32 && types[1] == t_f32) {
-	    	if (offset) *offset = 2;
-			return alloc_type_simd_vector(2, t_f32);
-		} else if (type_size_of(types[0]) == 8) {
-	    	if (offset) *offset = 1;
-			return types[0];
-		}
-
-		i64 total_size = 0;
-		isize i = 0;
-		if (packed) {
-			for (; i < types.count && total_size < 8; i += 1) {
-				Type *t = types[i];
-				i64 s = type_size_of(t);
-				total_size += s;
-			}
-		} else {
-			for (; i < types.count && total_size < 8; i += 1) {
-				Type *t = types[i];
-				i64 s = gb_max(type_size_of(t), 0);
-				i64 a = gb_max(type_align_of(t), 1);
-				isize ts = align_formula(total_size, a);
-				if (ts >= 8) {
-					break;
-				}
-				total_size = ts + s;
-			}
-		}
-		if (offset) *offset = i;
-		switch (total_size) {
-		case 1: return t_u8;
-		case 2: return t_u16;
-		case 4: return t_u32;
-		case 8: return t_u64;
-		}
-		return t_u64;
-	}
-
-	return nullptr;
-}
-
-Type *handle_struct_system_v_amd64_abi_type(Type *t) {
-	if (type_size_of(t) > 16) {
-		return alloc_type_pointer(t);
-	}
-	Type *original_type = t;
-	Type *bt = core_type(t);
-	t = base_type(t);
-	i64 size = type_size_of(bt);
-
-	switch (t->kind) {
-	case Type_Slice:
-	case Type_Struct:
-		break;
-
-	case Type_Basic:
-		switch (bt->Basic.kind) {
-		case Basic_string:
-		case Basic_any:
-		case Basic_complex64:
-		case Basic_complex128:
-		case Basic_quaternion128:
-			break;
-		default:
-			return original_type;
-		}
-		break;
-
-	default:
-		return original_type;
-	}
-
-	bool is_packed = false;
-	if (is_type_struct(bt)) {
-		is_packed = bt->Struct.is_packed;
-	}
-
-	if (is_type_raw_union(bt)) {
-		// TODO(bill): Handle raw union correctly for
-		return t;
-	} else {
-		auto field_types = systemv_distribute_struct_fields(bt);
-		defer (array_free(&field_types));
-
-		GB_ASSERT(field_types.count <= 16);
-
-		Type *final_type = nullptr;
-
-		if (field_types.count == 0) {
-			final_type = t;
-		} else if (field_types.count == 1) {
-			final_type = field_types[0];
-		} else {
-			if (size <= 8) {
-				isize offset = 0;
-				final_type = handle_single_distributed_type_parameter(field_types, is_packed, &offset);
-			} else {
-				isize offset = 0;
-				isize next_offset = 0;
-				Type *two_types[2] = {};
-
-				two_types[0] = handle_single_distributed_type_parameter(field_types, is_packed, &offset);
-				auto remaining = array_slice(field_types, offset, field_types.count);
-				two_types[1] = handle_single_distributed_type_parameter(remaining, is_packed, &next_offset);
-				GB_ASSERT(offset + next_offset == field_types.count);
-
-				auto variables = array_make<Entity *>(heap_allocator(), 2);
-				variables[0] = alloc_entity_param(nullptr, empty_token, two_types[0], false, false);
-				variables[1] = alloc_entity_param(nullptr, empty_token, two_types[1], false, false);
-				final_type = alloc_type_tuple();
-				final_type->Tuple.variables = variables;
-				if (t->kind == Type_Struct) {
-					// NOTE(bill): Make this packed
-					final_type->Tuple.is_packed = t->Struct.is_packed;
-				}
-			}
-		}
-
-
-		GB_ASSERT(final_type != nullptr);
-		i64 ftsz = type_size_of(final_type);
-		i64 otsz = type_size_of(original_type);
-		if (ftsz != otsz) {
-			// TODO(bill): Handle this case which will be caused by #packed most likely
-			switch (otsz) {
-			case 1:
-			case 2:
-			case 4:
-			case 8:
-				GB_PANIC("Incorrectly handled case for handle_struct_system_v_amd64_abi_type, %s %lld vs %s %lld", type_to_string(final_type), ftsz, type_to_string(original_type), otsz);
-			}
-		}
-
-		return final_type;
-	}
-}
 
-Type *type_to_abi_compat_param_type(gbAllocator a, Type *original_type, ProcCallingConvention cc) {
-	Type *new_type = original_type;
 
-	if (is_type_boolean(original_type)) {
-		Type *t = core_type(base_type(new_type));
-		if (t == t_bool) {
-			return t_llvm_bool;
-		}
-		return new_type;
-	}
-
-	if (is_type_proc(original_type)) {
-		// NOTE(bill): Force a cast to prevent a possible type cycle
-		return t_rawptr;
-	}
-
-	if (is_calling_convention_none(cc)) {
-		return new_type;
-	}
-
-	if (build_context.ODIN_ARCH == "386") {
-		return new_type;
-	}
-
-	if (is_type_simd_vector(original_type)) {
-		return new_type;
-	}
-	if (build_context.ODIN_ARCH == "amd64") {
-		bool is_128 = is_type_integer_128bit(original_type);
-		if (!is_128 && is_type_bit_set(original_type) && type_size_of(original_type) == 16) {
-			// is_128 = true;
-		}
-		if (is_128) {
-			if (build_context.ODIN_OS == "windows") {
-				return alloc_type_simd_vector(2, t_u64);
-			} else {
-				return original_type;
-			}
-		}
-	}
-
-	if (build_context.ODIN_OS == "windows") {
-		// 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
-
-
-		Type *bt = core_type(original_type);
-		switch (bt->kind) {
-		// Okay to pass by value (usually)
-		// Especially the only Odin types
-		case Type_Basic: {
-			i64 sz = bt->Basic.size;
-			// if (sz > 8 && build_context.word_size < 8) {
-			if (sz > 8) {
-				new_type = alloc_type_pointer(original_type);
-			}
-			break;
-		}
-		case Type_Pointer:
-			if (is_type_struct(bt->Pointer.elem)) {
-				// Force to a raw pointer
-				new_type = t_rawptr;
-			}
-			break;
-		case Type_Proc:
-			new_type = t_rawptr;
-			break; // NOTE(bill): Just a pointer
-
-		// Odin specific
-		case Type_Slice:
-		case Type_Array:
-		case Type_DynamicArray:
-		case Type_Map:
-		case Type_Union:
-		// Could be in C too
-		case Type_Struct:
-		{
-			i64 align = type_align_of(original_type);
-			i64 size  = type_size_of(original_type);
-
-			switch (8*size) {
-			case 8:  new_type = t_u8;  break;
-			case 16: new_type = t_u16; break;
-			case 32: new_type = t_u32; break;
-			case 64: new_type = t_u64; break;
-			default:
-				new_type = alloc_type_pointer(original_type);
-				break;
-			}
-
-			break;
-		}
-		}
-	} else if (build_context.ODIN_OS == "linux" ||
-	           build_context.ODIN_OS == "darwin") {
-		Type *bt = core_type(original_type);
-		switch (bt->kind) {
-		// Okay to pass by value (usually)
-		// Especially the only Odin types
-		case Type_Basic: {
-			i64 sz = bt->Basic.size;
-			// if (sz > 8 && build_context.word_size < 8) {
-			if (sz > 8) {
-				new_type = alloc_type_pointer(original_type);
-			}
-
-			break;
-		}
-		case Type_Pointer: break;
-		case Type_Proc:    break; // NOTE(bill): Just a pointer
-
-		default: {
-			i64 size = type_size_of(original_type);
-			if (size > 16) {
-				new_type = alloc_type_pointer(original_type);
-			} else if (build_context.ODIN_ARCH == "amd64") {
-				// NOTE(bill): System V AMD64 ABI
-				new_type = handle_struct_system_v_amd64_abi_type(bt);
-				if (are_types_identical(core_type(original_type), new_type)) {
-					new_type = original_type;
-				}
-				return new_type;
-			}
-
-			break;
-		}
-		}
-	} else {
-		// IMPORTANT TODO(bill): figure out the ABI settings for Linux, OSX etc. for
-		// their architectures
-	}
-
-	return new_type;
-}
-
-
-Type *type_to_abi_compat_result_type(gbAllocator a, Type *original_type, ProcCallingConvention cc) {
-	Type *new_type = original_type;
-	if (new_type == nullptr) {
-		return nullptr;
-	}
-	GB_ASSERT(is_type_tuple(original_type));
-
-	Type *single_type = reduce_tuple_to_single_type(original_type);
-
-	if (cc == ProcCC_InlineAsm) {
-		return new_type;
-	}
-
-	if (is_type_proc(single_type)) {
-		// NOTE(bill): Force a cast to prevent a possible type cycle
-		return t_rawptr;
-	}
-
-	if (is_type_simd_vector(single_type)) {
-		return new_type;
-	}
-
-	if (is_type_pointer(single_type)) {
-		// NOTE(bill): Force a cast to prevent a possible type cycle
-		return t_rawptr;
-	}
-
-	if (build_context.ODIN_OS == "windows") {
-		if (build_context.ODIN_ARCH == "amd64") {
-			if (is_type_integer_128bit(single_type)) {
-				if (is_calling_convention_none(cc)) {
-					return original_type;
-				} else {
-					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) {
-		// Okay to pass by value
-		// Especially the only Odin types
-		case Type_Pointer: break;
-		case Type_Proc:    break; // NOTE(bill): Just a pointer
-		case Type_Basic:   break;
-
-
-		default: {
-			i64 align = type_align_of(original_type);
-			i64 size  = type_size_of(original_type);
-			switch (8*size) {
-#if 1
-			case 8:  new_type = t_u8;  break;
-			case 16: new_type = t_u16; break;
-			case 32: new_type = t_u32; break;
-			case 64: new_type = t_u64; break;
-#endif
-			}
-
-			break;
-		}
-		}
-	} else if (build_context.ODIN_OS == "linux" || build_context.ODIN_OS == "darwin") {
-		if (build_context.ODIN_ARCH == "amd64") {
-
-		}
-	} else {
-		// IMPORTANT TODO(bill): figure out the ABI settings for Linux, OSX etc. for
-		// 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);
-		array_add(&variables, alloc_entity_param(original_type->Tuple.variables[0]->scope, empty_token, new_type, false, false));
-		tuple->Tuple.variables = variables;
-		new_type = tuple;
-	}
-
-	if (cc == ProcCC_None) {
-		for_array(i, new_type->Tuple.variables) {
-			Type **tp = &new_type->Tuple.variables[i]->type;
-			Type *t = core_type(*tp);
-			if (t == t_bool) {
-				*tp = t_llvm_bool;
-			}
-		}
-	}
-
-	new_type->cached_size = -1;
-	new_type->cached_align = -1;
-	return new_type;
-}
-
-bool abi_compat_return_by_pointer(gbAllocator a, ProcCallingConvention cc, Type *abi_return_type) {
-	if (abi_return_type == nullptr) {
-		return false;
-	}
-	if (is_calling_convention_none(cc)) {
-		return false;
-	}
-
-	Type *single_type = reduce_tuple_to_single_type(abi_return_type);
-
-	if (is_type_simd_vector(single_type)) {
-		return false;
-	}
-
-	if (build_context.word_size == 8) {
-		if (is_type_integer_128bit(single_type)) {
-			return false;
-		}
-	}
-
-	if (build_context.ODIN_OS == "windows" || build_context.ODIN_OS == "linux" ) {
-		i64 size = 8*type_size_of(abi_return_type);
-		switch (size) {
-		case 0:
-		case 8:
-		case 16:
-		case 32:
-		case 64:
-			return false;
-		default:
-			return true;
-		}
-	} else {
-		if (is_type_integer_128bit(single_type)) {
-			return build_context.word_size < 8;
-		}
-	}
-
-
-
-	return false;
-}
-
-void set_procedure_abi_types(Type *type) {
-	type = base_type(type);
-	if (type->kind != Type_Proc) {
-		return;
-	}
-
-	if (type->Proc.abi_types_set || type->flags & TypeFlag_InProcessOfCheckingABI) {
-		return;
-	}
-
-	gbAllocator allocator = permanent_allocator();
-
-	u32 flags = type->flags;
-	type->flags |= TypeFlag_InProcessOfCheckingABI;
-
-	type->Proc.abi_compat_params = array_make<Type *>(allocator, cast(isize)type->Proc.param_count);
-	for (i32 i = 0; i < type->Proc.param_count; i++) {
-		Entity *e = type->Proc.params->Tuple.variables[i];
-		if (e->kind == Entity_Variable) {
-			Type *original_type = e->type;
-			Type *new_type = type_to_abi_compat_param_type(allocator, original_type, type->Proc.calling_convention);
-			type->Proc.abi_compat_params[i] = new_type;
-			switch (type->Proc.calling_convention) {
-			case ProcCC_Odin:
-			case ProcCC_Contextless:
-				if (is_type_pointer(new_type) && !is_type_pointer(e->type) && !is_type_proc(e->type)) {
-					e->flags |= EntityFlag_ImplicitReference;
-				}
-				break;
-			}
-
-			if (build_context.ODIN_OS == "linux" ||
-			    build_context.ODIN_OS == "darwin") {
-				if (is_type_pointer(new_type) & !is_type_pointer(e->type) && !is_type_proc(e->type)) {
-					e->flags |= EntityFlag_ByVal;
-				}
-			}
-		}
-	}
-
-	for (i32 i = 0; i < type->Proc.param_count; i++) {
-		Entity *e = type->Proc.params->Tuple.variables[i];
-		if (e->kind == Entity_Variable) {
-			set_procedure_abi_types(e->type);
-		}
-	}
-	for (i32 i = 0; i < type->Proc.result_count; i++) {
-		Entity *e = type->Proc.results->Tuple.variables[i];
-		if (e->kind == Entity_Variable) {
-			set_procedure_abi_types(e->type);
-		}
-	}
-
-	// NOTE(bill): The types are the same
-	type->Proc.abi_compat_result_type = type_to_abi_compat_result_type(allocator, type->Proc.results, type->Proc.calling_convention);
-	type->Proc.return_by_pointer = abi_compat_return_by_pointer(allocator, type->Proc.calling_convention, type->Proc.abi_compat_result_type);
-
-	type->Proc.abi_types_set = true;
-	type->flags = flags;
-}
 
 // NOTE(bill): 'operands' is for generating non generic procedure type
 bool check_procedure_type(CheckerContext *ctx, Type *type, Ast *proc_type_node, Array<Operand> *operands) {

src/checker.cpp

@@ -732,15 +732,11 @@ void init_universal(void) {
 	add_global_type_entity(str_lit("byte"), &basic_types[Basic_u8]);
 
 	{
-		void set_procedure_abi_types(Type *type);
-
 		Type *equal_args[2] = {t_rawptr, t_rawptr};
 		t_equal_proc = alloc_type_proc_from_types(equal_args, 2, t_bool, false, ProcCC_Contextless);
-		set_procedure_abi_types(t_equal_proc);
 
 		Type *hasher_args[2] = {t_rawptr, t_uintptr};
 		t_hasher_proc = alloc_type_proc_from_types(hasher_args, 2, t_uintptr, false, ProcCC_Contextless);
-		set_procedure_abi_types(t_hasher_proc);
 	}
 
 // Constants

src/llvm_backend.cpp

@@ -2545,8 +2545,6 @@ lbProcedure *lb_create_procedure(lbModule *m, Entity *entity) {
 	Type *pt = base_type(entity->type);
 	GB_ASSERT(pt->kind == Type_Proc);
 
-	set_procedure_abi_types(entity->type);
-
 	p->type           = entity->type;
 	p->type_expr      = decl->type_expr;
 	p->body           = pl->body;
@@ -2845,6 +2843,14 @@ lbValue lb_value_param(lbProcedure *p, Entity *e, Type *abi_type, i32 index, lbP
 	return res;
 }
 
+Type *struct_type_from_systemv_distribute_struct_fields(Type *abi_type) {
+	GB_ASSERT(is_type_tuple(abi_type));
+	Type *final_type = alloc_type_struct();
+	final_type->Struct.fields = abi_type->Tuple.variables;
+	return final_type;
+}
+
+
 lbValue lb_add_param(lbProcedure *p, Entity *e, Ast *expr, Type *abi_type, i32 index) {
 	lbParamPasskind kind = lbParamPass_Value;
 	lbValue v = lb_value_param(p, e, abi_type, index, &kind);
@@ -3476,9 +3482,6 @@ void lb_build_nested_proc(lbProcedure *p, AstProcLit *pd, Entity *e) {
 	name_len = gb_snprintf(name_text, name_len, "%.*s.%.*s-%d", LIT(p->name), LIT(pd_name), guid);
 	String name = make_string(cast(u8 *)name_text, name_len-1);
 
-	set_procedure_abi_types(e->type);
-
-
 	e->Procedure.link_name = name;
 
 	lbProcedure *nested_proc = lb_create_procedure(p->module, e);
@@ -3613,7 +3616,6 @@ void lb_build_constant_value_decl(lbProcedure *p, AstValueDecl *vd) {
 				return;
 			}
 
-			set_procedure_abi_types(e->type);
 			e->Procedure.link_name = name;
 
 			lbProcedure *nested_proc = lb_create_procedure(p->module, e);
@@ -8201,8 +8203,6 @@ lbValue lb_emit_call(lbProcedure *p, lbValue value, Array<lbValue> const &args,
 		LLVMBuildUnreachable(p->builder);
 	});
 
-	set_procedure_abi_types(pt);
-
 	bool is_c_vararg = pt->Proc.c_vararg;
 	isize param_count = pt->Proc.param_count;
 	if (is_c_vararg) {
@@ -9584,7 +9584,6 @@ lbValue lb_build_call_expr(lbProcedure *p, Ast *expr) {
 	Type *proc_type_ = base_type(value.type);
 	GB_ASSERT(proc_type_->kind == Type_Proc);
 	TypeProc *pt = &proc_type_->Proc;
-	set_procedure_abi_types(proc_type_);
 
 	if (is_call_expr_field_value(ce)) {
 		auto args = array_make<lbValue>(permanent_allocator(), pt->param_count);
@@ -10765,8 +10764,6 @@ lbValue lb_generate_anonymous_proc_lit(lbModule *m, String const &prefix_name, A
 	String name = make_string((u8 *)name_text, name_len-1);
 
 	Type *type = type_of_expr(expr);
-	set_procedure_abi_types(type);
-
 
 	Token token = {};
 	token.pos = ast_token(expr).pos;

src/types.cpp

@@ -198,11 +198,8 @@ struct TypeProc {
 	isize    specialization_count;
 	ProcCallingConvention calling_convention;
 	i32      variadic_index;
-	Array<Type *> abi_compat_params;
-	Type *        abi_compat_result_type;
 	// TODO(bill): Make this a flag set rather than bools
 	bool     variadic;
-	bool     abi_types_set;
 	bool     require_results;
 	bool     c_vararg;
 	bool     is_polymorphic;
@@ -317,7 +314,6 @@ enum TypeFlag : u32 {
 	TypeFlag_Polymorphic     = 1<<1,
 	TypeFlag_PolySpecialized = 1<<2,
 	TypeFlag_InProcessOfCheckingPolymorphic = 1<<3,
-	TypeFlag_InProcessOfCheckingABI = 1<<4,
 };
 
 struct Type {