Cleanup.

src/compiler/llvm_codegen.c

@@ -424,7 +424,7 @@ void llvm_emit_global_variable_init(GenContext *c, Decl *decl)
 
 	if (init_value && LLVMTypeOf(init_value) != llvm_get_type(c, var_type))
 	{
-		decl->backend_ref = global_ref = llvm_emit_bitcast(c, global_ref, type_get_ptr(var_type));
+		decl->backend_ref = global_ref = llvm_emit_bitcast_ptr(c, global_ref, var_type);
 	}
 	LLVMReplaceAllUsesWith(old, global_ref);
 	LLVMDeleteGlobal(old);

src/compiler/llvm_codegen_debug_info.c

@@ -10,7 +10,17 @@ static inline LLVMMetadataRef llvm_get_debug_type_internal(GenContext *c, Type *
 static inline LLVMMetadataRef llvm_get_debug_member(GenContext *c, Type *type, const char *name, unsigned offset, SourceSpan *loc, LLVMMetadataRef scope, LLVMDIFlags flags);
 static inline LLVMMetadataRef llvm_get_debug_struct(GenContext *c, Type *type, const char *external_name, LLVMMetadataRef *elements, unsigned element_count, SourceSpan *loc, LLVMMetadataRef scope, LLVMDIFlags flags);
 static LLVMMetadataRef llvm_debug_forward_comp(GenContext *c, Type *type, const char *external_name, SourceSpan *loc, LLVMMetadataRef scope, LLVMDIFlags flags);
-
+static LLVMMetadataRef llvm_debug_simple_type(GenContext *context, Type *type, int dwarf_code);
+static LLVMMetadataRef llvm_debug_func_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_structlike_type(GenContext *c, Type *type, LLVMMetadataRef scope);
+static LLVMMetadataRef llvm_debug_pointer_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_vector_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_typedef_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_array_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_errunion_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_subarray_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_any_type(GenContext *c, Type *type);
+static LLVMMetadataRef llvm_debug_enum_type(GenContext *c, Type *type, LLVMMetadataRef scope);
 
 static inline LLVMMetadataRef llvm_get_debug_struct(GenContext *c, Type *type, const char *external_name, LLVMMetadataRef *elements, unsigned element_count, SourceSpan *loc, LLVMMetadataRef scope, LLVMDIFlags flags)
 {
@@ -206,22 +216,22 @@ void llvm_emit_debug_parameter(GenContext *c, Decl *parameter, unsigned index)
 
 }
 
-void llvm_emit_debug_location(GenContext *context, SourceSpan location)
+void llvm_emit_debug_location(GenContext *c, SourceSpan location)
 {
-	if (llvm_is_global_eval(context)) return;
+	if (llvm_is_global_eval(c)) return;
 	// Avoid re-emitting the same location.
-	LLVMMetadataRef oldloc = LLVMGetCurrentDebugLocation2(context->builder);
+	LLVMMetadataRef oldloc = LLVMGetCurrentDebugLocation2(c->builder);
-	if (oldloc && context->last_emitted_loc.a == location.a) return;
+	if (oldloc && c->last_emitted_loc.a == location.a) return;
-	LLVMMetadataRef scope = llvm_debug_current_scope(context);
+	LLVMMetadataRef scope = llvm_debug_current_scope(c);
 	unsigned row = location.row;
 	unsigned col = location.col;
-	context->last_emitted_loc.a = location.a;
+	c->last_emitted_loc.a = location.a;
-	LLVMMetadataRef loc = LLVMDIBuilderCreateDebugLocation(context->context,
+	LLVMMetadataRef loc = LLVMDIBuilderCreateDebugLocation(c->context,
 	                                                       row ? row : 1,
 	                                                       col ? col : 1,
 	                                                       scope, /* inlined at */ 0);
 
-	LLVMSetCurrentDebugLocation2(context->builder, loc);
+	LLVMSetCurrentDebugLocation2(c->builder, loc);
 }
 
 static LLVMMetadataRef llvm_debug_forward_comp(GenContext *c, Type *type, const char *external_name, SourceSpan *loc, LLVMMetadataRef scope, LLVMDIFlags flags)
@@ -273,7 +283,8 @@ static LLVMMetadataRef llvm_debug_simple_type(GenContext *context, Type *type, i
 	                                                               type->name,
 	                                                               strlen(type->name),
 	                                                               type->builtin.bitsize,
-	                                                               (LLVMDWARFTypeEncoding)dwarf_code, 0);
+	                                                               (LLVMDWARFTypeEncoding)dwarf_code,
+	                                                               LLVMDIFlagZero);
 
 }
 

src/compiler/llvm_codegen_expr.c

@@ -36,7 +36,7 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue
 		llvm_emit_expr(c, &result, expr->inner_expr);
 		LLVMValueRef err_val = result.value;
 		// Store it in the failable
-		llvm_store_value_dest_aligned(c, failable, &result);
+		llvm_store_to_ptr(c, failable, &result);
 		// Set the result to an undef value
 		llvm_value_set(&result, LLVMGetUndef(llvm_get_type(c, ref->type)), ref->type);
 
@@ -79,7 +79,7 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue
 	if (type_flat_is_vector(expr->type))
 	{
 		llvm_emit_expr(c, &value, expr);
-		llvm_store_value(c, ref, &value);
+		llvm_store(c, ref, &value);
 	}
 	else if (expr->expr_kind == EXPR_CONST && expr->const_expr.const_kind == CONST_LIST)
 	{
@@ -94,12 +94,12 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue
 	else
 	{
 		llvm_emit_expr(c, &value, expr);
-		llvm_store_value(c, ref, &value);
+		llvm_store(c, ref, &value);
 	}
 
 	if (failable)
 	{
-		llvm_store_raw_abi_alignment(c, failable, llvm_get_zero(c, type_anyerr), type_anyerr);
+		llvm_store_to_ptr_raw(c, failable, llvm_get_zero(c, type_anyerr), type_anyerr);
 	}
 	POP_ERROR();
 
@@ -110,7 +110,7 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue
 		{
 			llvm_emit_block(c, rejump_block);
 			LLVMValueRef error = llvm_load_natural_alignment(c, type_anyerr, failable, "reload_err");
-			llvm_store_raw_abi_alignment(c, c->error_var, error, type_anyerr);
+			llvm_store_to_ptr_raw(c, c->error_var, error, type_anyerr);
 			llvm_emit_br(c, c->catch_block);
 		}
 		llvm_emit_block(c, assign_block);
@@ -138,10 +138,10 @@ static inline LLVMValueRef llvm_zext_trunc(GenContext *c, LLVMValueRef data, LLV
 	assert(LLVMGetTypeKind(current_type) == LLVMIntegerTypeKind);
 	if (llvm_bitsize(c, current_type) < llvm_bitsize(c, type))
 	{
-		return LLVMBuildZExt(c->builder, data, type, "");
+		return LLVMBuildZExt(c->builder, data, type, "zext");
 	}
 	assert(llvm_bitsize(c, current_type) > llvm_bitsize(c, type));
-	return LLVMBuildTrunc(c->builder, data, type, "");
+	return LLVMBuildTrunc(c->builder, data, type, "ztrunc");
 }
 
 
@@ -160,7 +160,7 @@ LLVMValueRef llvm_emit_coerce_alignment(GenContext *c, BEValue *be_value, LLVMTy
 	{
 		LLVMValueRef cast = llvm_emit_alloca(c, llvm_get_type(c, be_value->type), target_alignment, "coerce");
 		LLVMValueRef target = LLVMBuildBitCast(c->builder, cast, LLVMPointerType(coerce_type, 0), "");
-		llvm_store_value_aligned(c, target, be_value, target_alignment);
+		llvm_store_to_ptr_aligned(c, target, be_value, target_alignment);
 		*resulting_alignment = target_alignment;
 		return target;
 	}
@@ -190,14 +190,14 @@ static inline LLVMValueRef llvm_const_low_bitmask(GenContext *c, LLVMTypeRef typ
 {
 	if (low_bits < 1) return LLVMConstNull(type);
 	if (type_bits <= low_bits) return LLVMConstAllOnes(type);
-	return LLVMBuildLShr(c->builder, LLVMConstAllOnes(type), LLVMConstInt(type, (unsigned long long)(type_bits - low_bits), 0), "");
+	return llvm_emit_lshr_fixed(c, LLVMConstAllOnes(type), (type_bits - low_bits));
 }
 
 static inline LLVMValueRef llvm_const_high_bitmask(GenContext *c, LLVMTypeRef type, int type_bits, int high_bits)
 {
 	if (high_bits < 1) return LLVMConstNull(type);
 	if (type_bits <= high_bits) return LLVMConstAllOnes(type);
-	return LLVMBuildNot(c->builder, LLVMBuildLShr(c->builder, LLVMConstAllOnes(type), LLVMConstInt(type, (unsigned long long)high_bits, 0), ""), "");
+	return LLVMBuildNot(c->builder, llvm_emit_lshr_fixed(c, LLVMConstAllOnes(type), high_bits), "");
 }
 
 LLVMValueRef llvm_mask_low_bits(GenContext *c, LLVMValueRef value, unsigned low_bits)
@@ -206,7 +206,7 @@ LLVMValueRef llvm_mask_low_bits(GenContext *c, LLVMValueRef value, unsigned low_
 	if (low_bits < 1) return LLVMConstNull(type);
 	BitSize type_bits = llvm_bitsize(c, type);
 	if (type_bits <= low_bits) return value;
-	LLVMValueRef mask = LLVMBuildLShr(c->builder, LLVMConstAllOnes(type), LLVMConstInt(type, type_bits - low_bits, 0), "");
+	LLVMValueRef mask = llvm_emit_lshr_fixed(c, LLVMConstAllOnes(type), type_bits - low_bits);
 	return LLVMBuildAnd(c->builder, mask, value, "");
 }
 
@@ -313,13 +313,13 @@ LLVMValueRef llvm_coerce_int_ptr(GenContext *c, LLVMValueRef value, LLVMTypeRef
 			ByteSize from_size = llvm_abi_size(c, from);
 			if (from_size > to_size)
 			{
-				value = LLVMBuildLShr(c->builder, value, LLVMConstInt(from, (from_size - to_size) * 8, false), "");
+				value = llvm_emit_lshr_fixed(c, value, (from_size - to_size) * 8);
 				value = LLVMBuildTrunc(c->builder, value, to_int_type, "");
 			}
 			else
 			{
 				value = LLVMBuildZExt(c->builder, value, to_int_type, "");
-				value = LLVMBuildShl(c->builder, value, LLVMConstInt(from, (to_size - from_size) * 8, false), "");
+				value = llvm_emit_shl_fixed(c, value, (to_size - from_size) * 8);
 			}
 		}
 		else
@@ -401,7 +401,7 @@ void llvm_emit_coerce_store(GenContext *c, LLVMValueRef addr, AlignSize alignmen
 	// 1. Simplest case, the underlying types match.
 	if (coerced == target_type)
 	{
-		llvm_store(c, addr, value, alignment);
+		llvm_store_to_ptr_raw_aligned(c, addr, value, alignment);
 		return;
 	}
 
@@ -420,7 +420,7 @@ void llvm_emit_coerce_store(GenContext *c, LLVMValueRef addr, AlignSize alignmen
 	    && (source_type_kind == LLVMPointerTypeKind || source_type_kind == LLVMIntegerTypeKind))
 	{
 		value = llvm_coerce_int_ptr(c, value, coerced, target_type);
-		llvm_store(c, addr, value, alignment);
+		llvm_store_to_ptr_raw_aligned(c, addr, value, alignment);
 		return;
 	}
 
@@ -429,14 +429,14 @@ void llvm_emit_coerce_store(GenContext *c, LLVMValueRef addr, AlignSize alignmen
 	if (src_size <= target_size)
 	{
 		LLVMValueRef val = LLVMBuildBitCast(c->builder, addr, LLVMPointerType(coerced, 0), "");
-		llvm_store(c, val, value, alignment);
+		llvm_store_to_ptr_raw_aligned(c, val, value, alignment);
 		return;
 	}
 
 	// Otherwise, do it through memory.
 	AlignSize coerce_align = llvm_abi_alignment(c, coerced);
 	LLVMValueRef temp = llvm_emit_alloca(c, coerced, coerce_align, "tempcoerce");
-	llvm_store(c, temp, value, coerce_align);
+	llvm_store_to_ptr_raw_aligned(c, temp, value, coerce_align);
 	llvm_emit_memcpy(c, addr, alignment, temp, coerce_align, target_size);
 }
 
@@ -614,7 +614,7 @@ static inline void gencontext_emit_subscript(GenContext *c, BEValue *value, Expr
 	if (!is_value)
 	{
 		assert(llvm_value_is_addr(value));
-		llvm_value_fold_failable(c, value);
+		llvm_value_fold_optional(c, value);
 		value->kind = BE_VALUE;
 		value->type = type_get_ptr(value->type);
 	}
@@ -652,10 +652,7 @@ static void gencontext_emit_member_addr(GenContext *c, BEValue *value, Decl *par
 		{
 			case TYPE_UNION:
 				llvm_value_addr(c, value);
-				llvm_value_set_address(value,
+				llvm_value_bitcast(c, value, found->type);
-				                       llvm_emit_bitcast(c, value->value, type_get_ptr(found->type)),
-				                       found->type,
-				                       value->alignment);
 				break;
 			case TYPE_STRUCT:
 				llvm_value_struct_gep(c, value, value, (unsigned)index);
@@ -680,10 +677,7 @@ static void llvm_emit_bitstruct_member(GenContext *c, BEValue *value, Decl *pare
 		{
 			case TYPE_UNION:
 				llvm_value_addr(c, value);
-				llvm_value_set_address(value,
+				llvm_value_bitcast(c, value, found->type);
-				                       llvm_emit_bitcast(c, value->value, type_get_ptr(found->type)),
-				                       found->type,
-				                       value->alignment);
 				break;
 			case TYPE_STRUCT:
 				llvm_value_struct_gep(c, value, value, (unsigned)index);
@@ -798,8 +792,8 @@ static inline void llvm_extract_bitvalue_from_array(GenContext *c, BEValue *be_v
 		if (top_bits_to_clear)
 		{
 			LLVMValueRef shift = LLVMConstInt(llvm_member_type, top_bits_to_clear, false);
-			res = LLVMBuildShl(c->builder, res, shift, "");
+			res = llvm_emit_shl(c, res, shift);
-			res = LLVMBuildAShr(c->builder, res, shift, "");
+			res = llvm_emit_ashr(c, res, shift);
 		}
 	}
 	else
@@ -836,12 +830,12 @@ static inline void llvm_extract_bitvalue(GenContext *c, BEValue *be_value, Expr
 		uint64_t left_shift = container_bit_size - end - 1;
 		if (left_shift)
 		{
-			value = LLVMBuildShl(c->builder, value, LLVMConstInt(container_type, left_shift, 0), "");
+			value = llvm_emit_shl_fixed(c, value, left_shift);
 		}
 		uint64_t right_shift = left_shift + start;
 		if (right_shift)
 		{
-			value = LLVMBuildAShr(c->builder, value, LLVMConstInt(container_type, right_shift, 0), "");
+			value = llvm_emit_ashr_fixed(c, value, right_shift);
 		}
 		if (member_type_size < container_bit_size)
 		{
@@ -857,7 +851,7 @@ static inline void llvm_extract_bitvalue(GenContext *c, BEValue *be_value, Expr
 		// Shift away bottom:
 		if (start)
 		{
-			value = LLVMBuildLShr(c->builder, value, LLVMConstInt(container_type, start, 0), "");
+			value = llvm_emit_lshr_fixed(c, value, start);
 		}
 		TypeSize bits_needed = end - start + 1;
 		value = llvm_mask_low_bits(c, value, bits_needed);
@@ -890,7 +884,7 @@ static inline void llvm_emit_bitassign_array(GenContext *c, BEValue *result, BEV
 		LLVMValueRef bit = llvm_emit_shl_fixed(c, LLVMConstInt(c->byte_type, 1, 0), start_bit % 8);
 		current = LLVMBuildAnd(c->builder, current, LLVMBuildNot(c->builder, bit, ""), "");
 		if (!LLVMIsNull(value)) current = LLVMBuildOr(c->builder, current, value, "");
-		llvm_store(c, byte_ptr, current, alignment);
+		llvm_store_to_ptr_raw_aligned(c, byte_ptr, current, alignment);
 		return;
 	}
 
@@ -940,7 +934,7 @@ static inline void llvm_emit_bitassign_array(GenContext *c, BEValue *result, BEV
 			// Use *or* with the top bits from "res":
 			if (!LLVMIsNull(res)) current = LLVMBuildOr(c->builder, current, res, "");
 			// And store it back.
-			llvm_store(c, byte_ptr, current, alignment);
+			llvm_store_to_ptr_raw_aligned(c, byte_ptr, current, alignment);
 			// We now shift the value by the number of bits we used.
 			value = llvm_emit_lshr_fixed(c, value, 8 - skipped_bits);
 			// ... and we're done with the first byte.
@@ -960,11 +954,11 @@ static inline void llvm_emit_bitassign_array(GenContext *c, BEValue *result, BEV
 			// Use *or* with the bottom bits from "value":
 			if (!LLVMIsNull(value)) current = LLVMBuildOr(c->builder, current, value, "");
 			// And store it back.
-			llvm_store(c, byte_ptr, current, alignment);
+			llvm_store_to_ptr_raw_aligned(c, byte_ptr, current, alignment);
 			continue;
 		}
 		// All others are simple: truncate & store
-		llvm_store(c, byte_ptr, llvm_zext_trunc(c, value, c->byte_type), alignment);
+		llvm_store_to_ptr_raw_aligned(c, byte_ptr, llvm_zext_trunc(c, value, c->byte_type), alignment);
 		// Then shift
 		value = llvm_emit_lshr_fixed(c, value, 8);
 	}
@@ -1031,7 +1025,7 @@ static inline void llvm_emit_bitassign_expr(GenContext *c, BEValue *be_value, Ex
 	current_value = LLVMBuildAnd(c->builder, current_value, LLVMBuildNot(c->builder, mask, ""), "");
 	// Skip this op for LLVM14 if zero.
 	if (!LLVMIsNull(value)) current_value = LLVMBuildOr(c->builder, current_value, value, "");
-	llvm_store_value_raw(c, &parent, current_value);
+	llvm_store_raw(c, &parent, current_value);
 }
 static inline void llvm_emit_bitaccess(GenContext *c, BEValue *be_value, Expr *expr)
 {
@@ -1086,7 +1080,7 @@ static void llvm_emit_arr_to_subarray_cast(GenContext *c, BEValue *value, Type *
 	{
 		llvm_value_rvalue(c, value);
 		LLVMTypeRef subarray_type = llvm_get_type(c, to_type);
-		pointer = llvm_emit_bitcast(c, value->value, type_get_ptr(array_type));
+		pointer = llvm_emit_bitcast_ptr(c, value->value, array_type);
 	}
 	else
 	{
@@ -1146,14 +1140,12 @@ void llvm_emit_cast(GenContext *c, CastKind cast_kind, BEValue *value, Type *to_
 		}
 		case CAST_BSARRY:
 			llvm_value_addr(c, value);
-			value->value = llvm_emit_bitcast(c, value->value, type_get_ptr(to_type));
+			llvm_value_bitcast(c, value, to_type);
-			value->type = to_type;
 			llvm_value_rvalue(c, value);
 			return;
 		case CAST_BSINT:
 			llvm_value_addr(c, value);
-			value->value = llvm_emit_bitcast(c, value->value, type_get_ptr(to_type));
+			llvm_value_bitcast(c, value, to_type);
-			value->type = to_type;
 			llvm_value_rvalue(c, value);
 			return;
 		case CAST_EUINT:
@@ -1294,9 +1286,7 @@ void llvm_emit_cast(GenContext *c, CastKind cast_kind, BEValue *value, Type *to_
 			break;
 		case CAST_UIUI:
 			llvm_value_rvalue(c, value);
-			value->value = type_convert_will_trunc(to_type, from_type)
+			value->value = llvm_zext_trunc(c, value->value, llvm_get_type(c, to_type));
-			       ? LLVMBuildTrunc(c->builder, value->value, llvm_get_type(c, to_type), "uiuitrunc")
-			       : LLVMBuildZExt(c->builder, value->value, llvm_get_type(c, to_type), "uiuiext");
 			break;
 		case CAST_UIFP:
 			llvm_value_rvalue(c, value);
@@ -1311,7 +1301,7 @@ void llvm_emit_cast(GenContext *c, CastKind cast_kind, BEValue *value, Type *to_
 			value->type = to_type;
 			return;
 		case CAST_SABOOL:
-			llvm_value_fold_failable(c, value);
+			llvm_value_fold_optional(c, value);
 			if (llvm_value_is_addr(value))
 			{
 				value->value = llvm_emit_struct_gep_raw(c,
@@ -1436,7 +1426,7 @@ static void llvm_emit_inititialize_reference_const(GenContext *c, BEValue *ref,
 		case CONST_INIT_ZERO:
 			if (type_is_builtin(ref->type->type_kind) || ref->type->type_kind == TYPE_ARRAY)
 			{
-				llvm_store_value_raw(c, ref, llvm_get_zero(c, ref->type));
+				llvm_store_raw(c, ref, llvm_get_zero(c, ref->type));
 				return;
 			}
 			llvm_store_zero(c, ref);
@@ -1491,7 +1481,8 @@ static void llvm_emit_inititialize_reference_const(GenContext *c, BEValue *ref,
 			Type *type = decl->strukt.members[index]->type->canonical;
 			// Bitcast.
 			BEValue value = *ref;
-			llvm_value_set_address_abi_aligned(&value, llvm_emit_bitcast(c, ref->value, type_get_ptr(type)), type);
+			llvm_value_bitcast(c, &value, type);
+//			llvm_value_set_address_abi_aligned(&value, llvm_emit_bitcast_ptr(c, ref->value, type), type);
 			// Emit our value.
 			llvm_emit_inititialize_reference_const(c, &value, const_init->init_union.element);
 			return;
@@ -1513,7 +1504,7 @@ static void llvm_emit_inititialize_reference_const(GenContext *c, BEValue *ref,
 		{
 			BEValue value;
 			llvm_emit_expr(c, &value, const_init->init_value);
-			llvm_store_value(c, ref, &value);
+			llvm_store(c, ref, &value);
 			return;
 		}
 	}
@@ -1586,7 +1577,7 @@ static inline void llvm_emit_initialize_reference_list(GenContext *c, BEValue *r
 		}
 		BEValue init_value;
 		llvm_emit_expr(c, &init_value, element);
-		llvm_store_value(c, &pointer, &init_value);
+		llvm_store(c, &pointer, &init_value);
 	}
 }
 
@@ -1622,7 +1613,7 @@ static void llvm_emit_initialize_designated(GenContext *c, BEValue *ref, AlignSi
 	{
 		if (emitted_value)
 		{
-			llvm_store_value(c, ref, emitted_value);
+			llvm_store(c, ref, emitted_value);
 			return;
 		}
 		if (expr->expr_kind == EXPR_CONST && expr->const_expr.const_kind == CONST_LIST)
@@ -1637,7 +1628,7 @@ static void llvm_emit_initialize_designated(GenContext *c, BEValue *ref, AlignSi
 		}
 		BEValue val;
 		llvm_emit_expr(c, &val, expr);
-		llvm_store_value(c, ref, &val);
+		llvm_store(c, ref, &val);
 		return;
 	}
 	DesignatorElement *curr = current[0];
@@ -1652,7 +1643,7 @@ static void llvm_emit_initialize_designated(GenContext *c, BEValue *ref, AlignSi
 			if (ref->type->type_kind == TYPE_UNION)
 			{
 				llvm_value_set_address(&value,
-				                       llvm_emit_bitcast(c, ref->value, type_get_ptr(type)),
+				                       llvm_emit_bitcast_ptr(c, ref->value, type),
 				                       type,
 				                       type_min_alignment(offset, decl_alignment));
 			}
@@ -1822,13 +1813,12 @@ LLVMValueRef llvm_emit_const_bitstruct(GenContext *c, ConstInitializer *initiali
 		value = llvm_zext_trunc(c, value, llvm_base_type);
 		if (bit_size < base_type_bitsize)
 		{
-			LLVMValueRef mask = LLVMConstAllOnes(llvm_base_type);
+			LLVMValueRef mask = llvm_emit_lshr_fixed(c, LLVMConstAllOnes(llvm_base_type), base_type_bitsize - bit_size);
-			mask = LLVMBuildLShr(c->builder, mask, LLVMConstInt(llvm_base_type, base_type_bitsize - bit_size, 0), "");
 			value = LLVMBuildAnd(c->builder, mask, value, "");
 		}
 		if (start_bit > 0)
 		{
-			value = LLVMBuildShl(c->builder, value, LLVMConstInt(llvm_base_type, start_bit, 0), "");
+			value = llvm_emit_shl_fixed(c, value, start_bit);
 		}
 		result = LLVMBuildOr(c->builder, value, result, "");
 	}
@@ -1851,7 +1841,7 @@ static inline void llvm_emit_const_initialize_bitstruct_ref(GenContext *c, BEVal
 		return;
 	}
 	assert(initializer->kind == CONST_INIT_STRUCT);
-	llvm_store_value_raw(c, ref, llvm_emit_const_bitstruct(c, initializer));
+	llvm_store_raw(c, ref, llvm_emit_const_bitstruct(c, initializer));
 }
 
 /**
@@ -1984,7 +1974,7 @@ static inline void llvm_emit_inc_dec_change(GenContext *c, bool use_mod, BEValue
 	}
 
 	// Store the result aligned.
-	llvm_store_value_raw(c, addr, after_value);
+	llvm_store_raw(c, addr, after_value);
 	if (after) llvm_value_set(after, after_value, addr->type);
 }
 
@@ -2156,7 +2146,7 @@ void llvm_emit_len_for_expr(GenContext *c, BEValue *be_value, BEValue *expr_to_l
 	switch (expr_to_len->type->type_kind)
 	{
 		case TYPE_SUBARRAY:
-			llvm_value_fold_failable(c, be_value);
+			llvm_value_fold_optional(c, be_value);
 			if (expr_to_len->kind == BE_VALUE)
 			{
 				llvm_value_set(be_value, llvm_emit_extract_value(c, expr_to_len->value, 1), type_usize);
@@ -2429,11 +2419,10 @@ static void gencontext_emit_slice(GenContext *c, BEValue *be_value, Expr *expr)
 		case TYPE_ARRAY:
 		case TYPE_FLEXIBLE_ARRAY:
 		{
-			Type *pointer_type = type_get_ptr(parent.type->array.base);
 			// Move pointer
 			AlignSize alignment;
 			start_pointer = llvm_emit_array_gep_raw_index(c, parent.value, llvm_get_type(c, parent.type), start.value, type_abi_alignment(parent.type), &alignment);
-			start_pointer = llvm_emit_bitcast(c, start_pointer, pointer_type);
+			start_pointer = llvm_emit_bitcast_ptr(c, start_pointer, parent.type->array.base);
 			break;
 		}
 		case TYPE_SUBARRAY:
@@ -2499,7 +2488,7 @@ static void llvm_emit_slice_assign(GenContext *c, BEValue *be_value, Expr *expr)
 				llvm_emit_subscript_addr_with_base(c, &addr, &parent, &offset_val, expr->span);
 
 				// And store the value.
-				llvm_store_value(c, &addr, be_value);
+				llvm_store(c, &addr, be_value);
 			}
 			return;
 		}
@@ -2538,7 +2527,7 @@ static void llvm_emit_slice_assign(GenContext *c, BEValue *be_value, Expr *expr)
 	llvm_emit_subscript_addr_with_base(c, &addr, &parent, &offset_val, expr->span);
 
 	// And store the value.
-	llvm_store_value(c, &addr, be_value);
+	llvm_store(c, &addr, be_value);
 
 	// Create the new offset
 	LLVMValueRef next_offset = llvm_emit_add_int(c, start.type, offset, llvm_const_int(c, start.type, 1), expr->span);
@@ -2849,18 +2838,6 @@ static void llvm_emit_ptr_comparison(GenContext *c, BEValue *result, BEValue *lh
 	llvm_value_set_bool(result, val);
 }
 
-static inline LLVMValueRef llvm_fixup_shift_rhs(GenContext *c, LLVMValueRef left, LLVMValueRef right)
-{
-	LLVMTypeRef left_type = LLVMTypeOf(left);
-	LLVMTypeRef right_type = LLVMTypeOf(right);
-	if (left_type == right_type) return right;
-	if (LLVMStoreSizeOfType(c->target_data, left_type) < LLVMStoreSizeOfType(c->target_data, right_type))
-	{
-		return LLVMBuildTrunc(c->builder, right, left_type, "");
-	}
-	return LLVMBuildZExt(c->builder, right, left_type, "");
-}
-
 static inline LLVMValueRef llvm_emit_mult_int(GenContext *c, Type *type, LLVMValueRef left, LLVMValueRef right, SourceSpan loc)
 {
 	if (active_target.feature.trap_on_wrap)
@@ -2920,7 +2897,7 @@ static void llvm_emit_subarray_comp(GenContext *c, BEValue *be_value, BEValue *l
 	BEValue index_var;
 	llvm_value_set_address_abi_aligned(&index_var, llvm_emit_alloca_aligned(c, type_usize, "cmp.idx"), type_usize);
 	LLVMValueRef one = llvm_const_int(c, type_usize, 1);
-	llvm_store_value_raw(c, &index_var, llvm_get_zero(c, type_usize));
+	llvm_store_raw(c, &index_var, llvm_get_zero(c, type_usize));
 	llvm_emit_br(c, loop_begin);
 
 	llvm_emit_block(c, loop_begin);
@@ -2948,7 +2925,7 @@ static void llvm_emit_subarray_comp(GenContext *c, BEValue *be_value, BEValue *l
 	                                   array_base_type);
 	llvm_emit_comparison(c, &cmp, &lhs_to_compare, &rhs_to_compare, BINARYOP_EQ);
 	match_fail_block = c->current_block;
-	llvm_store_value_raw(c, &index_var, LLVMBuildAdd(c->builder, current_index.value, one, ""));
+	llvm_store_raw(c, &index_var, LLVMBuildAdd(c->builder, current_index.value, one, ""));
 	llvm_emit_cond_br(c, &cmp, loop_begin, exit);
 	llvm_emit_block(c, exit);
 
@@ -3230,7 +3207,7 @@ void gencontext_emit_binary(GenContext *c, BEValue *be_value, Expr *expr, BEValu
 			      : LLVMBuildSRem(c->builder, lhs_value, rhs_value, "smod");
 			break;
 		case BINARYOP_SHR:
-			rhs_value = llvm_fixup_shift_rhs(c, lhs_value, rhs_value);
+			rhs_value = llvm_zext_trunc(c, rhs_value, LLVMTypeOf(lhs_value));
 			llvm_emit_trap_invalid_shift(c, rhs_value, lhs_type, "Shift amount out of range.", expr->span);
 			val = type_is_unsigned(lhs_type)
 			      ? LLVMBuildLShr(c->builder, lhs_value, rhs_value, "lshr")
@@ -3238,7 +3215,7 @@ void gencontext_emit_binary(GenContext *c, BEValue *be_value, Expr *expr, BEValu
 			val = LLVMBuildFreeze(c->builder, val, "");
 			break;
 		case BINARYOP_SHL:
-			rhs_value = llvm_fixup_shift_rhs(c, lhs_value, rhs_value);
+			rhs_value = llvm_zext_trunc(c, rhs_value, LLVMTypeOf(lhs_value));
 			llvm_emit_trap_invalid_shift(c, rhs_value, lhs_type, "Shift amount out of range.", expr->span);
 			val = LLVMBuildShl(c->builder, lhs_value, rhs_value, "shl");
 			val = LLVMBuildFreeze(c->builder, val, "");
@@ -3322,13 +3299,13 @@ void llvm_emit_try_assign_try_catch(GenContext *c, bool is_try, BEValue *be_valu
 	llvm_emit_expr(c, be_value, rhs);
 
 	// 6. If we haven't jumped yet, do it here (on error) to the catch block.
-	llvm_value_fold_failable(c, be_value);
+	llvm_value_fold_optional(c, be_value);
 
 	// 7. If we have a variable, then we make the store.
 	if (var_addr)
 	{
 		assert(is_try && "Storing will only happen on try.");
-		llvm_store_value(c, var_addr, be_value);
+		llvm_store(c, var_addr, be_value);
 	}
 
 	// 8. Restore the error stack.
@@ -3385,13 +3362,13 @@ static inline void llvm_emit_catch_expr(GenContext *c, BEValue *value, Expr *exp
 
 	LLVMValueRef error_var = llvm_emit_alloca_aligned(c, type_anyerr, "error_var");
 	llvm_value_set_address_abi_aligned(value, error_var, type_anyerr);
-	llvm_store_value_raw(c, value, llvm_get_zero(c, type_anyerr));
+	llvm_store_raw(c, value, llvm_get_zero(c, type_anyerr));
 	c->error_var = error_var;
 	c->catch_block = end_block;
 
 	BEValue expr_value;
 	llvm_emit_expr(c, &expr_value, inner);
-	llvm_value_fold_failable(c, &expr_value);
+	llvm_value_fold_optional(c, &expr_value);
 
 	// Restore.
 	POP_ERROR();
@@ -3417,7 +3394,7 @@ void llvm_emit_try_expr(GenContext *c, BEValue *value, Expr *expr)
 	c->catch_block = error_block;
 
 	llvm_emit_expr(c, value, expr->inner_expr);
-	llvm_value_fold_failable(c, value);
+	llvm_value_fold_optional(c, value);
 
 	// Restore.
 	POP_ERROR();
@@ -3465,7 +3442,7 @@ static inline void llvm_emit_rethrow_expr(GenContext *c, BEValue *be_value, Expr
 
 	llvm_emit_expr(c, be_value, expr->rethrow_expr.inner);
 	// Fold the failable.
-	llvm_value_fold_failable(c, be_value);
+	llvm_value_fold_optional(c, be_value);
 
 	// Restore.
 	POP_ERROR();
@@ -3575,7 +3552,7 @@ static void llvm_emit_vector_assign_expr(GenContext *c, BEValue *be_value, Expr
 	}
 
 	LLVMValueRef new_value = LLVMBuildInsertElement(c->builder, vector_value, llvm_load_value_store(c, be_value), index_val, "elemset");
-	llvm_store_value_raw(c, &addr, new_value);
+	llvm_store_raw(c, &addr, new_value);
 }
 
 static void llvm_emit_binary_expr(GenContext *c, BEValue *be_value, Expr *expr)
@@ -3594,7 +3571,7 @@ static void llvm_emit_binary_expr(GenContext *c, BEValue *be_value, Expr *expr)
 		llvm_emit_expr(c, &addr, exprptr(expr->binary_expr.left));
 		llvm_value_addr(c, &addr);
 		gencontext_emit_binary(c, be_value, expr, &addr, base_op);
-		llvm_store_value(c, &addr, be_value);
+		llvm_store(c, &addr, be_value);
 		return;
 	}
 	if (binary_op == BINARYOP_ASSIGN)
@@ -3805,7 +3782,7 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr)
 																		 expr->const_expr.bytes.ptr,
 																		 expr->const_expr.bytes.len,
 																		 1));
-				global_name = llvm_emit_bitcast(c, global_name, type_get_ptr(type_char));
+				global_name = llvm_emit_bitcast_ptr(c, global_name, type_char);
 				llvm_value_set_address_abi_aligned(be_value, global_name, type);
 				return;
 			}
@@ -3874,7 +3851,7 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr)
 				LLVMSetInitializer(global_name, string);
 				if (is_array)
 				{
-					global_name = llvm_emit_bitcast(c, global_name, type_get_ptr(type));
+					global_name = llvm_emit_bitcast_ptr(c, global_name, type);
 					llvm_value_set_address(be_value, global_name, type, 1);
 				}
 				else
@@ -4015,7 +3992,7 @@ static void llvm_expand_type_to_args(GenContext *context, Type *param_type, LLVM
 void llvm_emit_struct_member_ref(GenContext *c, BEValue *struct_ref, BEValue *member_ref, unsigned member_id)
 {
 	assert(llvm_value_is_addr(struct_ref));
-	llvm_value_fold_failable(c, struct_ref);
+	llvm_value_fold_optional(c, struct_ref);
 	assert(struct_ref->type->type_kind == TYPE_STRUCT);
 	AlignSize align;
 	LLVMValueRef ptr = llvm_emit_struct_gep_raw(c, struct_ref->value, llvm_get_type(c, struct_ref->type), member_id, struct_ref->alignment, &align);
@@ -4087,7 +4064,7 @@ void llvm_emit_subarray_pointer(GenContext *c, BEValue *value, BEValue *pointer)
 
 static void llvm_emit_any_pointer(GenContext *c, BEValue *value, BEValue *pointer)
 {
-	llvm_value_fold_failable(c, value);
+	llvm_value_fold_optional(c, value);
 	if (value->kind == BE_ADDRESS)
 	{
 		AlignSize alignment;
@@ -4101,7 +4078,7 @@ static void llvm_emit_any_pointer(GenContext *c, BEValue *value, BEValue *pointe
 
 void llvm_value_struct_gep(GenContext *c, BEValue *element, BEValue *struct_pointer, unsigned index)
 {
-	llvm_value_fold_failable(c, struct_pointer);
+	llvm_value_fold_optional(c, struct_pointer);
 	MemberIndex actual_index = -1;
 	Decl *member;
 	for (MemberIndex i = 0; i <= index; i++)
@@ -4193,7 +4170,7 @@ void llvm_emit_parameter(GenContext *c, LLVMValueRef **args, ABIArgInfo *info, B
 			// If we want we could optimize for structs by doing it by reference here.
 			assert(info->indirect.alignment == type_abi_alignment(type) || info->attributes.realign);
 			LLVMValueRef indirect = llvm_emit_alloca(c, llvm_get_type(c, type), info->indirect.alignment, "indirectarg");
-			llvm_store_value_aligned(c, indirect, be_value, info->indirect.alignment);
+			llvm_store_to_ptr_aligned(c, indirect, be_value, info->indirect.alignment);
 			vec_add(*args, indirect);
 			return;
 		}
@@ -4307,18 +4284,17 @@ static void llvm_emit_unpacked_variadic_arg(GenContext *c, Expr *expr, BEValue *
 	{
 		case TYPE_ARRAY:
 		{
-			llvm_store_value_raw(c, &len_addr, llvm_const_int(c, type_usize, type->array.len));
+			llvm_store_raw(c, &len_addr, llvm_const_int(c, type_usize, type->array.len));
 			llvm_value_addr(c, &value);
-			llvm_store_value_raw(c, &pointer_addr, llvm_emit_bitcast(c, value.value, type_get_ptr(type->array.base)));
+			llvm_value_bitcast(c, &value, type->array.base);
+			llvm_store_raw(c, &pointer_addr, value.value);
 			return;
 		}
 		case TYPE_POINTER:
 			// Load the pointer
 			llvm_value_rvalue(c, &value);
-			llvm_store_value_raw(c, &len_addr, llvm_const_int(c, type_usize, type->pointer->array.len));
+			llvm_store_raw(c, &len_addr, llvm_const_int(c, type_usize, type->pointer->array.len));
-			llvm_store_value_raw(c,
+			llvm_store_raw(c, &pointer_addr, llvm_emit_bitcast_ptr(c, value.value, type->pointer->array.base));
-			                     &pointer_addr,
-			                     llvm_emit_bitcast(c, value.value, type_get_ptr(type->pointer->array.base)));
 			return;
 		case TYPE_SUBARRAY:
 			*subarray = value;
@@ -4516,7 +4492,7 @@ void llvm_emit_builtin_call(GenContext *c, BEValue *result_value, Expr *expr)
 		llvm_value_rvalue(c, &value);
 		value.kind = BE_ADDRESS;
 		BEValue store_value = *result_value;
-		LLVMValueRef store = llvm_store_value(c, &value, &store_value);
+		LLVMValueRef store = llvm_store(c, &value, &store_value);
 		if (store) LLVMSetVolatile(store, true);
 		return;
 	}
@@ -4573,7 +4549,10 @@ void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr)
 
 	if (c->debug.stack_slot_row)
 	{
-		llvm_store(c, c->debug.stack_slot_row, llvm_const_int(c, type_uint, expr->span.row), type_abi_alignment(type_uint));
+		llvm_store_to_ptr_raw_aligned(c,
+		                              c->debug.stack_slot_row,
+		                              llvm_const_int(c, type_uint, expr->span.row),
+		                              type_abi_alignment(type_uint));
 	}
 
 	LLVMTypeRef func_type;
@@ -4735,7 +4714,7 @@ void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr)
 			// Just set the size to zero.
 			BEValue len_addr;
 			llvm_emit_subarray_len(c, &subarray, &len_addr);
-			llvm_store_value_raw(c, &len_addr, llvm_get_zero(c, type_usize));
+			llvm_store_raw(c, &len_addr, llvm_get_zero(c, type_usize));
 		}
 		else if (arguments == non_variadic_params + 1 && expr->call_expr.unsplat_last)
 		{
@@ -4756,15 +4735,14 @@ void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr)
 				llvm_emit_expr(c, &temp_value, arg_expr);
 				AlignSize store_alignment;
 				LLVMValueRef slot = llvm_emit_array_gep_raw(c, array_ref, llvm_array_type, i - non_variadic_params, alignment, &store_alignment);
-				llvm_store_value_aligned(c, slot, &temp_value, store_alignment);
+				llvm_store_to_ptr_aligned(c, slot, &temp_value, store_alignment);
 			}
 			BEValue len_addr;
 			llvm_emit_subarray_len(c, &subarray, &len_addr);
-			llvm_store_value_raw(c, &len_addr, llvm_const_int(c, type_usize, arguments - non_variadic_params));
+			llvm_store_raw(c, &len_addr, llvm_const_int(c, type_usize, arguments - non_variadic_params));
 			BEValue pointer_addr;
 			llvm_emit_subarray_pointer(c, &subarray, &pointer_addr);
-			Type *array_as_pointer_type = type_get_ptr(pointee_type);
+			llvm_store_raw(c, &pointer_addr, llvm_emit_bitcast_ptr(c, array_ref, pointee_type));
-			llvm_store_value_raw(c, &pointer_addr, llvm_emit_bitcast(c, array_ref, array_as_pointer_type));
 		}
 		llvm_emit_parameter(c, &values, vararg_info, &subarray, vararg_param);
 	}
@@ -4893,7 +4871,7 @@ void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr)
 			if (!abi_type_is_valid(ret_info->coerce_expand.hi))
 			{
 				// Here we do a store to call -> lo (leaving the rest undefined)
-				llvm_store(c, lo, call_value, alignment);
+				llvm_store_to_ptr_raw_aligned(c, lo, call_value, alignment);
 				break;
 			}
 
@@ -4902,14 +4880,14 @@ void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr)
 			LLVMValueRef hi_value = llvm_emit_extract_value(c, call_value, 1);
 
 			// 15h. Store lo_value into the { pad, lo, pad, hi } struct.
-			llvm_store(c, lo, lo_value, alignment);
+			llvm_store_to_ptr_raw_aligned(c, lo, lo_value, alignment);
 
 			// 15i. Calculate the address to the high value (like for the low in 15d.
 			LLVMValueRef hi = llvm_emit_struct_gep_raw(c, coerce, coerce_type, ret_info->coerce_expand.hi_index,
 													   type_abi_alignment(call_return_type), &alignment);
 
 			// 15h. Store the high value.
-			llvm_store(c, hi, hi_value, alignment);
+			llvm_store_to_ptr_raw_aligned(c, hi, hi_value, alignment);
 
 			break;
 		}
@@ -4960,7 +4938,11 @@ void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr)
 		BEValue no_err;
 
 		// Emit the current stack into the thread local or things will get messed up.
-		if (c->debug.last_ptr) llvm_store(c, c->debug.last_ptr, c->debug.stack_slot, type_alloca_alignment(type_voidptr));
+		if (c->debug.last_ptr)
+			llvm_store_to_ptr_raw_aligned(c,
+			                              c->debug.last_ptr,
+			                              c->debug.stack_slot,
+			                              type_alloca_alignment(type_voidptr));
 
 		// 17a. If we used the error var as the indirect recipient, then that will hold the error.
 		//      otherwise it's whatever value in be_value.
@@ -4997,7 +4979,11 @@ void llvm_emit_call_expr(GenContext *c, BEValue *result_value, Expr *expr)
 	}
 
 	// Emit the current stack into the thread local or things will get messed up.
-	if (c->debug.last_ptr) llvm_store(c, c->debug.last_ptr, c->debug.stack_slot, type_alloca_alignment(type_voidptr));
+	if (c->debug.last_ptr)
+		llvm_store_to_ptr_raw_aligned(c,
+		                              c->debug.last_ptr,
+		                              c->debug.stack_slot,
+		                              type_alloca_alignment(type_voidptr));
 
 	// 17i. The simple case here is where there is a normal return.
 	//      In this case be_value already holds the result
@@ -5166,7 +5152,7 @@ static inline void llvm_emit_macro_block(GenContext *context, BEValue *be_value,
 		BEValue value;
 
 		llvm_emit_expr(context, &value, expr->macro_block.args[i]);
-		llvm_store_decl_raw(context, decl, llvm_load_value_store(context, &value));
+		llvm_store_decl(context, decl, &value);
 	}
 
 	llvm_emit_return_block(context, be_value, expr->type, expr->macro_block.first_stmt, expr->macro_block.block_exit);
@@ -5188,7 +5174,7 @@ static inline void llvm_emit_failable(GenContext *c, BEValue *be_value, Expr *ex
 	{
 		assert(c->error_var);
 		llvm_emit_expr(c, be_value, fail);
-		llvm_store_value_dest_aligned(c, c->error_var, be_value);
+		llvm_store_to_ptr(c, c->error_var, be_value);
 	}
 	// Branch to the catch
 	llvm_emit_br(c, c->catch_block);
@@ -5299,7 +5285,7 @@ static void llvm_emit_macro_body_expansion(GenContext *c, BEValue *value, Expr *
 	{
 		Expr *expr = values[i];
 		llvm_emit_expr(c, value, expr);
-		llvm_store_value_aligned(c, declarations[i]->backend_ref, value, declarations[i]->alignment);
+		llvm_store_to_ptr_aligned(c, declarations[i]->backend_ref, value, declarations[i]->alignment);
 	}
 	llvm_emit_stmt(c, body_expr->body_expansion_expr.ast);
 }
@@ -5360,12 +5346,12 @@ void llvm_emit_catch_unwrap(GenContext *c, BEValue *value, Expr *expr)
 		llvm_emit_br(c, block);
 		llvm_emit_block(c, block);
 		llvm_emit_expr(c, &val, expr->catch_unwrap_expr.exprs[i]);
-		llvm_value_fold_failable(c, &val);
+		llvm_value_fold_optional(c, &val);
 	}
 
 	POP_ERROR();
 
-	llvm_store_value_raw(c, &addr, llvm_get_zero(c, type_anyerr));
+	llvm_store_raw(c, &addr, llvm_get_zero(c, type_anyerr));
 	llvm_emit_br(c, catch_block);
 	llvm_emit_block(c, catch_block);
 	llvm_value_rvalue(c, &addr);
@@ -5447,7 +5433,7 @@ static inline void llvm_emit_typeid_info(GenContext *c, BEValue *value, Expr *ex
 				LLVMValueRef len = llvm_emit_struct_gep_raw(c, ref, c->introspect_type, INTROSPECT_INDEX_LEN, align, &alignment);
 				len = llvm_load(c, c->size_type, len, alignment, "namelen");
 				LLVMValueRef val = llvm_emit_struct_gep_raw(c, ref, c->introspect_type, INTROSPECT_INDEX_ADDITIONAL, align, &alignment);
-				LLVMValueRef ptr_to_first = llvm_emit_bitcast(c, val, type_get_ptr(type_chars));
+				LLVMValueRef ptr_to_first = llvm_emit_bitcast_ptr(c, val, type_chars);
 				Type *subarray = type_get_subarray(type_chars);
 				llvm_value_set(value, llvm_emit_aggregate_two(c, subarray, ptr_to_first, len), subarray);
 			}
@@ -5625,10 +5611,10 @@ static inline void llvm_emit_argv_to_subarray(GenContext *c, BEValue *value, Exp
 	// We first set the pointer
 	AlignSize align = type_abi_alignment(arg_array_type);
 	LLVMValueRef ptr_loc = llvm_emit_struct_gep_raw(c, index, arg_array_elem_type, 0, align, &index_align);
-	llvm_store(c, ptr_loc, pointer_value, index_align);
+	llvm_store_to_ptr_raw_aligned(c, ptr_loc, pointer_value, index_align);
 	// Then the length
 	LLVMValueRef len_loc = llvm_emit_struct_gep_raw(c, index, arg_array_elem_type, 1, align, &index_align);
-	llvm_store(c, len_loc, len, index_align);
+	llvm_store_to_ptr_raw_aligned(c, len_loc, len, index_align);
 
 	// Add index
 	LLVMValueRef index_plus = LLVMBuildNUWAdd(c->builder, index_var, llvm_const_int(c, type_usize, 1), "");
@@ -5645,7 +5631,7 @@ static inline void llvm_emit_builtin_access(GenContext *c, BEValue *be_value, Ex
 {
 	Expr *inner = exprptr(expr->builtin_access_expr.inner);
 	llvm_emit_expr(c, be_value, inner);
-	llvm_value_fold_failable(c, be_value);
+	llvm_value_fold_optional(c, be_value);
 	switch (expr->builtin_access_expr.kind)
 	{
 		case ACCESS_LEN:
@@ -5702,7 +5688,7 @@ static inline void llvm_emit_builtin_access(GenContext *c, BEValue *be_value, Ex
 			LLVMValueRef to_introspect = LLVMBuildIntToPtr(c->builder, inner_type->backend_typeid,
 			                                              LLVMPointerType(c->introspect_type, 0), "");
 			LLVMValueRef ptr = LLVMBuildStructGEP2(c->builder, c->introspect_type, to_introspect, INTROSPECT_INDEX_ADDITIONAL, "");
-			LLVMValueRef ptr_to_first = llvm_emit_bitcast(c, ptr, type_get_ptr(type_chars));
+			LLVMValueRef ptr_to_first = llvm_emit_bitcast_ptr(c, ptr, type_chars);
 			LLVMValueRef val = llvm_zext_trunc(c, be_value->value, llvm_get_type(c, type_usize));
 			llvm_value_set_address(be_value, llvm_emit_pointer_gep_raw(c, subarray, ptr_to_first, val),
 			                       type_chars, llvm_abi_alignment(c, subarray));

src/compiler/llvm_codegen_function.c

@@ -94,12 +94,12 @@ static void llvm_expand_from_args(GenContext *c, Type *type, LLVMValueRef ref, u
 		case TYPE_UNION:
 		{
 			Type *largest_type = type_find_largest_union_element(type);
-			LLVMValueRef cast_addr = llvm_emit_bitcast(c, ref, type_get_ptr(largest_type));
+			LLVMValueRef cast_addr = llvm_emit_bitcast_ptr(c, ref, largest_type);
 			llvm_expand_from_args(c, largest_type, cast_addr, index, alignment);
 			return;
 		}
 		default:
-			llvm_store(c, ref, llvm_get_next_param(c, index), alignment);
+			llvm_store_to_ptr_raw_aligned(c, ref, llvm_get_next_param(c, index), alignment);
 			return;
 	}
 }
@@ -134,11 +134,11 @@ static inline void llvm_process_parameter_value(GenContext *c, Decl *decl, ABIAr
 			AlignSize alignment = decl->alignment;
 			AlignSize element_align;
 			LLVMValueRef gep_first = llvm_emit_struct_gep_raw(c, temp, coerce_type, info->coerce_expand.lo_index, alignment, &element_align);
-			llvm_store(c, gep_first, llvm_get_next_param(c, index), element_align);
+			llvm_store_to_ptr_raw_aligned(c, gep_first, llvm_get_next_param(c, index), element_align);
 			if (abi_type_is_valid(info->coerce_expand.hi))
 			{
 				LLVMValueRef gep_second = llvm_emit_struct_gep_raw(c, temp, coerce_type, info->coerce_expand.hi_index, alignment, &element_align);
-				llvm_store(c, gep_second, llvm_get_next_param(c, index), element_align);
+				llvm_store_to_ptr_raw_aligned(c, gep_second, llvm_get_next_param(c, index), element_align);
 			}
 			break;
 		}
@@ -168,11 +168,11 @@ static inline void llvm_process_parameter_value(GenContext *c, Decl *decl, ABIAr
 			AlignSize element_align;
 			LLVMValueRef lo_ptr = llvm_emit_struct_gep_raw(c, coerce, struct_type, 0, decl_alignment, &element_align);
 			// Store it in the struct.
-			llvm_store(c, lo_ptr, llvm_get_next_param(c, index), element_align);
+			llvm_store_to_ptr_raw_aligned(c, lo_ptr, llvm_get_next_param(c, index), element_align);
 			// Point to the hi value.
 			LLVMValueRef hi_ptr = llvm_emit_struct_gep_raw(c, coerce, struct_type, 1, decl_alignment, &element_align);
 			// Store it in the struct.
-			llvm_store(c, hi_ptr, llvm_get_next_param(c, index), element_align);
+			llvm_store_to_ptr_raw_aligned(c, hi_ptr, llvm_get_next_param(c, index), element_align);
 			return;
 		}
 		case ABI_ARG_DIRECT:
@@ -204,7 +204,7 @@ static inline void llvm_process_parameter_value(GenContext *c, Decl *decl, ABIAr
 				AlignSize align;
 				LLVMValueRef element_ptr = llvm_emit_struct_gep_raw(c, cast, coerce_type, idx, decl_alignment, &align);
 				LLVMValueRef value = llvm_get_next_param(c, index);
-				llvm_store(c, element_ptr, value, align);
+				llvm_store_to_ptr_raw_aligned(c, element_ptr, value, align);
 			}
 			return;
 		}
@@ -291,7 +291,7 @@ void llvm_emit_return_abi(GenContext *c, BEValue *return_value, BEValue *failabl
 	{
 		if (return_value && return_value->value)
 		{
-			llvm_store_value_aligned(c, c->return_out, return_value, type_alloca_alignment(return_value->type));
+			llvm_store_to_ptr_aligned(c, c->return_out, return_value, type_alloca_alignment(return_value->type));
 		}
 		return_out = c->failable_out;
 		if (!failable)
@@ -305,7 +305,7 @@ void llvm_emit_return_abi(GenContext *c, BEValue *return_value, BEValue *failabl
 	switch (info->kind)
 	{
 		case ABI_ARG_INDIRECT:
-			llvm_store_value_aligned(c, return_out, return_value, info->indirect.alignment);
+			llvm_store_to_ptr_aligned(c, return_out, return_value, info->indirect.alignment);
 			llvm_emit_return_value(c, NULL);
 			return;
 		case ABI_ARG_IGNORE:
@@ -466,13 +466,19 @@ void llvm_emit_function_body(GenContext *c, Decl *decl)
 			c->debug.stack_slot = llvm_emit_alloca(c, slot_type, alignment, ".$stackslot");
 			AlignSize align_to_use;
 			LLVMValueRef prev_ptr = llvm_emit_struct_gep_raw(c, c->debug.stack_slot, slot_type, 0, alignment, &align_to_use);
-			llvm_store(c, prev_ptr, LLVMBuildLoad2(c->builder, ptr_to_slot_type, c->debug.last_ptr, ""), align_to_use);
+			llvm_store_to_ptr_raw_aligned(c,
+			                              prev_ptr,
+			                              LLVMBuildLoad2(c->builder, ptr_to_slot_type, c->debug.last_ptr, ""),
+			                              align_to_use);
 			LLVMValueRef func_name = llvm_emit_struct_gep_raw(c, c->debug.stack_slot, slot_type, 1, alignment, &align_to_use);
-			llvm_store(c, func_name, c->debug.func_name, align_to_use);
+			llvm_store_to_ptr_raw_aligned(c, func_name, c->debug.func_name, align_to_use);
 			LLVMValueRef file_name = llvm_emit_struct_gep_raw(c, c->debug.stack_slot, slot_type, 2, alignment, &align_to_use);
-			llvm_store(c, file_name, c->debug.file_name, align_to_use);
+			llvm_store_to_ptr_raw_aligned(c, file_name, c->debug.file_name, align_to_use);
 			c->debug.stack_slot_row = llvm_emit_struct_gep_raw(c, c->debug.stack_slot, slot_type, 3, alignment, &align_to_use);
-			llvm_store(c, c->debug.last_ptr, c->debug.stack_slot, type_alloca_alignment(type_voidptr));
+			llvm_store_to_ptr_raw_aligned(c,
+			                              c->debug.last_ptr,
+			                              c->debug.stack_slot,
+			                              type_alloca_alignment(type_voidptr));
 		}
 	}
 

src/compiler/llvm_codegen_instr.c

@@ -30,11 +30,17 @@ LLVMValueRef llvm_emit_lshr_fixed(GenContext *c, LLVMValueRef data, int shift)
 	LLVMTypeRef type = LLVMTypeOf(data);
 	BitSize bit_width = llvm_bitsize(c, type);
 	if (shift >= bit_width) return LLVMConstNull(type);
-	if (LLVMIsAConstant(data))
+	return llvm_emit_lshr(c, data, LLVMConstInt(type, (unsigned)shift, false));
-	{
+}
-		return LLVMBuildLShr(c->builder, data, LLVMConstInt(type, (unsigned)shift, false), "");
+
-	}
+LLVMValueRef llvm_emit_ashr_fixed(GenContext *c, LLVMValueRef data, int shift)
-	return LLVMBuildLShr(c->builder, data, LLVMConstInt(type, (unsigned)shift, false), "");
+{
+	assert(shift >= 0);
+	if (shift == 0) return data;
+	LLVMTypeRef type = LLVMTypeOf(data);
+	BitSize bit_width = llvm_bitsize(c, type);
+	if (shift >= bit_width) shift = (int)bit_width;
+	return llvm_emit_ashr(c, data, LLVMConstInt(type, (unsigned)shift, false));
 }
 
 LLVMValueRef llvm_emit_shl_fixed(GenContext *c, LLVMValueRef data, int shift)
@@ -44,5 +50,5 @@ LLVMValueRef llvm_emit_shl_fixed(GenContext *c, LLVMValueRef data, int shift)
 	LLVMTypeRef type = LLVMTypeOf(data);
 	BitSize bit_width = llvm_bitsize(c, type);
 	if (shift >= bit_width) return LLVMConstNull(type);
-	return LLVMBuildShl(c->builder, data, LLVMConstInt(type, (unsigned)shift, false), "");
+	return llvm_emit_shl(c, data, LLVMConstInt(type, (unsigned)shift, false));
 }

src/compiler/llvm_codegen_internal.h

@@ -214,15 +214,16 @@ void gencontext_init_file_emit(GenContext *c, CompilationUnit *unit);
 void gencontext_end_file_emit(GenContext *c, CompilationUnit *ast);
 void gencontext_end_module(GenContext *context);
 
-INLINE bool llvm_is_global_eval(GenContext *c);
+// Patched functions
-INLINE bool llvm_is_local_eval(GenContext *c);
-void LLVMEnableOpaquePointers(LLVMContextRef ctx);
 LLVMValueRef LLVMConstBswap(LLVMValueRef ConstantVal);
 #ifndef LLVMCreateTypeAttribute
 LLVMAttributeRef LLVMCreateTypeAttribute(LLVMContextRef C, unsigned KindID,
-										 LLVMTypeRef type_ref);
+                                         LLVMTypeRef type_ref);
 #endif
 
+INLINE bool llvm_is_global_eval(GenContext *c);
+INLINE bool llvm_is_local_eval(GenContext *c);
+
 
 // BE value
 void llvm_value_addr(GenContext *c, BEValue *value);
@@ -237,8 +238,9 @@ void llvm_value_set_address(BEValue *value, LLVMValueRef llvm_value, Type *type,
 void llvm_value_set_address_abi_aligned(BEValue *value, LLVMValueRef llvm_value, Type *type);
 void llvm_value_set_decl_address(GenContext *c, BEValue *value, Decl *decl);
 void llvm_value_set_decl(GenContext *c, BEValue *value, Decl *decl);
-void llvm_value_fold_failable(GenContext *c, BEValue *value);
+void llvm_value_fold_optional(GenContext *c, BEValue *value);
 void llvm_value_struct_gep(GenContext *c, BEValue *element, BEValue *struct_pointer, unsigned index);
+INLINE void llvm_value_bitcast(GenContext *c, BEValue *value, Type *type);
 
 LLVMValueRef llvm_get_typeid(GenContext *context, Type *type);
 LLVMTypeRef llvm_abi_type(GenContext *c, AbiType type);
@@ -261,6 +263,8 @@ LLVMValueRef llvm_emit_alloca_aligned(GenContext *c, Type *type, const char *nam
 void llvm_emit_and_set_decl_alloca(GenContext *c, Decl *decl);
 BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValueRef failable);
 static inline LLVMValueRef llvm_emit_bitcast(GenContext *c, LLVMValueRef value, Type *type);
+INLINE LLVMValueRef llvm_emit_bitcast_ptr(GenContext *c, LLVMValueRef value, Type *type);
+
 void llvm_emit_block(GenContext *c, LLVMBasicBlockRef next_block);
 void llvm_emit_br(GenContext *c, LLVMBasicBlockRef next_block);
 void llvm_emit_jump_to_optional_exit(GenContext *c, LLVMValueRef err_value);
@@ -277,7 +281,7 @@ LLVMValueRef llvm_emit_call_intrinsic(GenContext *c, unsigned intrinsic, LLVMTyp
 void llvm_emit_cast(GenContext *c, CastKind cast_kind, BEValue *value, Type *to_type, Type *from_type);
 
 void llvm_emit_debug_function(GenContext *c, Decl *decl);
-void llvm_emit_debug_location(GenContext *context, SourceSpan location);
+void llvm_emit_debug_location(GenContext *c, SourceSpan location);
 void llvm_emit_debug_parameter(GenContext *c, Decl *parameter, unsigned index);
 void llvm_emit_debug_local_var(GenContext *c, Decl *var);
 void llvm_emit_debug_global_var(GenContext *c, Decl *global);
@@ -315,17 +319,35 @@ void llvm_emit_cond_br_raw(GenContext *context, LLVMValueRef b, LLVMBasicBlockRe
 // -- general --
 LLVMValueRef llvm_emit_is_no_error(GenContext *c, LLVMValueRef error_value);
 
-
 // -- load ---
 LLVMValueRef llvm_load(GenContext *c, LLVMTypeRef type, LLVMValueRef pointer, AlignSize alignment, const char *name);
 LLVMValueRef llvm_load_natural_alignment(GenContext *c, Type *type, LLVMValueRef pointer, const char *name);
 LLVMValueRef llvm_load_value(GenContext *c, BEValue *value);
 LLVMValueRef llvm_load_value_store(GenContext *c, BEValue *value);
 
+// -- store ---
+LLVMValueRef llvm_store(GenContext *c, BEValue *destination, BEValue *value);
+LLVMValueRef llvm_store_zero(GenContext *c, BEValue *ref);
+INLINE LLVMValueRef llvm_store_raw(GenContext *c, BEValue *destination, LLVMValueRef raw_value);
+INLINE LLVMValueRef llvm_store_decl(GenContext *c, Decl *decl, BEValue *value);
+INLINE LLVMValueRef llvm_store_decl_raw(GenContext *context, Decl *decl, LLVMValueRef value);
+INLINE LLVMValueRef llvm_store_to_ptr(GenContext *c, LLVMValueRef destination, BEValue *value);
+INLINE LLVMValueRef llvm_store_to_ptr_raw(GenContext *context, LLVMValueRef pointer, LLVMValueRef value, Type *type);
+LLVMValueRef llvm_store_to_ptr_aligned(GenContext *c, LLVMValueRef destination, BEValue *value, AlignSize alignment);
+LLVMValueRef llvm_store_to_ptr_raw_aligned(GenContext *context, LLVMValueRef pointer, LLVMValueRef value, AlignSize alignment);
+void llvm_store_to_ptr_zero(GenContext *context, LLVMValueRef pointer, Type *type);
+static inline LLVMValueRef llvm_emit_insert_value(GenContext *c, LLVMValueRef agg, LLVMValueRef new_value, ArraySize index);
+TypeSize llvm_store_size(GenContext *c, LLVMTypeRef type);
+
 // -- expr ---
 LLVMValueRef llvm_emit_shl_fixed(GenContext *c, LLVMValueRef data, int shift);
 LLVMValueRef llvm_emit_lshr_fixed(GenContext *c, LLVMValueRef data, int shift);
-
+LLVMValueRef llvm_emit_ashr_fixed(GenContext *c, LLVMValueRef data, int shift);
+INLINE LLVMValueRef llvm_emit_ashr(GenContext *c, LLVMValueRef value, LLVMValueRef shift);
+INLINE LLVMValueRef llvm_emit_shl(GenContext *c, LLVMValueRef value, LLVMValueRef shift);
+INLINE LLVMValueRef llvm_emit_lshr(GenContext *c, LLVMValueRef value, LLVMValueRef shift);
+INLINE LLVMValueRef llvm_emit_trunc(GenContext *c, LLVMValueRef value, Type *type);
+INLINE LLVMValueRef llvm_emit_trunc_bool(GenContext *c, LLVMValueRef value);
 // -- general --
 void llvm_emit_local_var_alloca(GenContext *c, Decl *decl);
 void llvm_emit_local_decl(GenContext *c, Decl *decl, BEValue *value);
@@ -334,13 +356,11 @@ void llvm_set_aggregate_two(GenContext *c, BEValue *value, Type *type, LLVMValue
 LLVMValueRef llvm_emit_aggregate_two(GenContext *c, Type *type, LLVMValueRef value1, LLVMValueRef value2);
 
 LLVMValueRef llvm_emit_memclear_size_align(GenContext *c, LLVMValueRef ptr, uint64_t size, AlignSize align);
-void llvm_store_zero(GenContext *c, BEValue *ref);
 void llvm_emit_memcpy(GenContext *c, LLVMValueRef dest, unsigned dest_align, LLVMValueRef source, unsigned src_align, uint64_t len);
 void llvm_emit_memcpy_to_decl(GenContext *c, Decl *decl, LLVMValueRef source, unsigned source_alignment);
 void llvm_emit_stmt(GenContext *c, Ast *ast);
 LLVMValueRef llvm_emit_zstring(GenContext *c, const char *str);
 LLVMValueRef llvm_emit_zstring_named(GenContext *c, const char *str, const char *extname);
-static inline LLVMValueRef llvm_emit_store(GenContext *c, Decl *decl, LLVMValueRef value);
 void llvm_emit_panic_on_true(GenContext *c, LLVMValueRef value, const char *panic_name, SourceSpan loc);
 void llvm_emit_panic_if_true(GenContext *c, BEValue *value, const char *panic_name, SourceSpan loc);
 void llvm_emit_ptr_from_array(GenContext *c, BEValue *value);
@@ -366,8 +386,13 @@ LLVMMetadataRef llvm_get_debug_type(GenContext *c, Type *type);
 static inline LLVMTypeRef llvm_get_ptr_type(GenContext *c, Type *type);
 LLVMTypeRef llvm_get_type(GenContext *c, Type *any_type);
 LLVMTypeRef llvm_get_pointee_type(GenContext *c, Type *any_type);
-static inline LLVMValueRef llvm_get_zero(GenContext *c, Type *type);
+INLINE LLVMValueRef llvm_get_zero(GenContext *c, Type *type);
+INLINE LLVMValueRef llvm_get_undef(GenContext *c, Type *type);
+
 void llvm_set_linkage(GenContext *c, Decl *decl, LLVMValueRef value);
+
+// -- debug
+INLINE bool llvm_use_debug(GenContext *context);
 void llvm_debug_scope_push(GenContext *context, LLVMMetadataRef debug_scope);
 void llvm_debug_scope_pop(GenContext *context);
 void llvm_debug_push_lexical_scope(GenContext *context, SourceSpan location);
@@ -377,14 +402,6 @@ LLVMMetadataRef llvm_debug_current_scope(GenContext *context);
 bool llvm_emit_check_block_branch(GenContext *context);
 
 
-TypeSize llvm_store_size(GenContext *c, LLVMTypeRef type);
-LLVMValueRef llvm_store_value(GenContext *c, BEValue *destination, BEValue *value);
-void llvm_store_value_raw(GenContext *c, BEValue *destination, LLVMValueRef raw_value);
-void llvm_store_value_dest_aligned(GenContext *c, LLVMValueRef destination, BEValue *value);
-LLVMValueRef llvm_store_value_aligned(GenContext *c, LLVMValueRef destination, BEValue *value, AlignSize alignment);
-void llvm_store_raw_abi_alignment(GenContext *context, LLVMValueRef pointer, LLVMValueRef value, Type *type);
-LLVMValueRef llvm_store(GenContext *context, LLVMValueRef pointer, LLVMValueRef value, AlignSize alignment);
-void llvm_store_decl_raw(GenContext *context, Decl *decl, LLVMValueRef value);
 
 LLVMTypeRef llvm_get_twostruct(GenContext *context, LLVMTypeRef lo, LLVMTypeRef hi);
 LLVMValueRef llvm_emit_coerce(GenContext *c, LLVMTypeRef coerced, BEValue *value, Type *original_type);
@@ -408,9 +425,44 @@ static inline LLVMValueRef llvm_emit_insert_value(GenContext *c, LLVMValueRef ag
 	return LLVMBuildInsertValue(c->builder, agg, new_value, index, "");
 }
 
-static inline LLVMValueRef llvm_emit_store(GenContext *c, Decl *decl, LLVMValueRef value)
+INLINE LLVMValueRef llvm_store_decl(GenContext *c, Decl *decl, BEValue *value)
 {
-	return LLVMBuildStore(c->builder, value, llvm_get_ref(c, decl));
+	BEValue ref;
+	llvm_value_set_decl(c, &ref, decl);
+	assert(llvm_value_is_addr(&ref));
+	return llvm_store(c, &ref, value);
+}
+
+INLINE LLVMValueRef llvm_store_raw(GenContext *c, BEValue *destination, LLVMValueRef raw_value)
+{
+	assert(llvm_value_is_addr(destination));
+	return llvm_store_to_ptr_raw_aligned(c, destination->value, raw_value, destination->alignment);
+}
+
+
+INLINE LLVMValueRef llvm_store_decl_raw(GenContext *context, Decl *decl, LLVMValueRef value)
+{
+	assert(!decl->is_value);
+	return llvm_store_to_ptr_raw_aligned(context, decl->backend_ref, value, decl->alignment);
+}
+
+INLINE AlignSize llvm_type_or_alloca_align(GenContext *c, LLVMValueRef dest, Type *type)
+{
+	if (LLVMIsAAllocaInst(dest) || LLVMIsAGlobalVariable(dest))
+	{
+		return LLVMGetAlignment(dest);
+	}
+	return type_abi_alignment(type);
+}
+
+INLINE LLVMValueRef llvm_store_to_ptr(GenContext *c, LLVMValueRef destination, BEValue *value)
+{
+	return llvm_store_to_ptr_aligned(c, destination, value, llvm_type_or_alloca_align(c, destination, value->type));
+}
+
+INLINE LLVMValueRef llvm_store_to_ptr_raw(GenContext *c, LLVMValueRef pointer, LLVMValueRef value, Type *type)
+{
+	return llvm_store_to_ptr_raw_aligned(c, pointer, value, llvm_type_or_alloca_align(c, pointer, type));
 }
 
 static inline LLVMValueRef llvm_emit_bitcast(GenContext *c, LLVMValueRef value, Type *type)
@@ -421,7 +473,45 @@ static inline LLVMValueRef llvm_emit_bitcast(GenContext *c, LLVMValueRef value,
 	return LLVMBuildBitCast(c->builder, value, result_type, "");
 }
 
-static inline bool llvm_use_debug(GenContext *context) { return context->debug.builder != NULL; }
+INLINE void llvm_value_bitcast(GenContext *c, BEValue *value, Type *type)
+{
+	assert(llvm_value_is_addr(value));
+	type = type_lowering(type);
+	value->value = llvm_emit_bitcast(c, value->value, type_get_ptr(type));
+	value->type = type;
+}
+
+INLINE LLVMValueRef llvm_emit_bitcast_ptr(GenContext *c, LLVMValueRef value, Type *type)
+{
+	return llvm_emit_bitcast(c, value, type_get_ptr(type));
+}
+
+INLINE LLVMValueRef llvm_emit_shl(GenContext *c, LLVMValueRef value, LLVMValueRef shift)
+{
+	return LLVMBuildShl(c->builder, value, shift, "shl");
+}
+
+INLINE LLVMValueRef llvm_emit_ashr(GenContext *c, LLVMValueRef value, LLVMValueRef shift)
+{
+	return LLVMBuildAShr(c->builder, value, shift, "ashr");
+}
+
+INLINE LLVMValueRef llvm_emit_lshr(GenContext *c, LLVMValueRef value, LLVMValueRef shift)
+{
+	return LLVMBuildLShr(c->builder, value, shift, "lshrl");
+}
+
+INLINE LLVMValueRef llvm_emit_trunc_bool(GenContext *c, LLVMValueRef value)
+{
+	return LLVMBuildTrunc(c->builder, value, c->bool_type, "");
+}
+
+INLINE LLVMValueRef llvm_emit_trunc(GenContext *c, LLVMValueRef value, Type *type)
+{
+	return LLVMBuildTrunc(c->builder, value, llvm_get_type(c, type), "");
+}
+
+INLINE bool llvm_use_debug(GenContext *context) { return context->debug.builder != NULL; }
 
 static inline bool llvm_basic_block_is_unused(LLVMBasicBlockRef block)
 {
@@ -499,11 +589,21 @@ static inline LLVMTypeRef llvm_get_ptr_type(GenContext *c, Type *type)
 	return llvm_get_type(c, type_get_ptr(type));
 }
 
-static inline LLVMValueRef llvm_get_zero(GenContext *c, Type *type)
+INLINE LLVMValueRef llvm_and(GenContext *c, BEValue *lhs, BEValue *rhs)
+{
+	return LLVMBuildAnd(c->builder, lhs->value, rhs->value, "");
+}
+
+INLINE LLVMValueRef llvm_get_zero(GenContext *c, Type *type)
 {
 	return LLVMConstNull(llvm_get_type(c, type));
 }
 
+INLINE LLVMValueRef llvm_get_undef(GenContext *c, Type *type)
+{
+	return LLVMGetUndef(llvm_get_type(c, type));
+}
+
 static inline LLVMValueRef llvm_const_int(GenContext *c, Type *type, uint64_t val)
 {
 	type = type_lowering(type);

src/compiler/llvm_codegen_stmt.c

@@ -83,22 +83,23 @@ void llvm_emit_local_decl(GenContext *c, Decl *decl, BEValue *value)
 		llvm_value_set(value, LLVMGetUndef(alloc_type), decl->type);
 		if (decl->var.failable_ref)
 		{
-			LLVMBuildStore(c->builder, LLVMGetUndef(llvm_get_type(c, type_anyerr)), decl->var.failable_ref);
+			llvm_store_to_ptr_raw(c, decl->var.failable_ref, llvm_get_undef(c, type_anyerr), type_anyerr);
 		}
 	}
 	else
 	{
 		if (decl->var.failable_ref)
 		{
-			LLVMBuildStore(c->builder, LLVMConstNull(llvm_get_type(c, type_anyerr)), decl->var.failable_ref);
+			llvm_store_to_ptr_zero(c, decl->var.failable_ref, type_anyerr);
 		}
 
 		Type *type = type_lowering(decl->type);
 		// Normal case, zero init.
 		if (type_is_builtin(type->type_kind) || type->type_kind == TYPE_POINTER)
 		{
-			llvm_emit_store(c, decl, LLVMConstNull(alloc_type));
+			LLVMValueRef zero = llvm_get_zero(c, var_type);
-			llvm_value_set(value, LLVMConstNull(alloc_type), type);
+			llvm_value_set(value, zero, type);
+			llvm_store_decl(c, decl, value);
 		}
 		else
 		{
@@ -193,7 +194,7 @@ static inline void llvm_emit_return(GenContext *c, Ast *ast)
 	if (has_return_value)
 	{
 		llvm_emit_expr(c, &return_value, ast->return_stmt.expr);
-		llvm_value_fold_failable(c, &return_value);
+		llvm_value_fold_optional(c, &return_value);
 		c->retval = return_value;
 	}
 
@@ -248,7 +249,7 @@ static inline void llvm_emit_block_exit_return(GenContext *c, Ast *ast)
 			c->catch_block = err_cleanup_block;
 		}
 		llvm_emit_expr(c, &return_value, ast->return_stmt.expr);
-		llvm_value_fold_failable(c, &return_value);
+		llvm_value_fold_optional(c, &return_value);
 	}
 
 	POP_ERROR();
@@ -256,7 +257,7 @@ static inline void llvm_emit_block_exit_return(GenContext *c, Ast *ast)
 	llvm_emit_statement_chain(c, ast->return_stmt.cleanup);
 	if (exit->block_return_out && return_value.value)
 	{
-		llvm_store_value_aligned(c, exit->block_return_out, &return_value, type_alloca_alignment(return_value.type));
+		llvm_store_to_ptr_aligned(c, exit->block_return_out, &return_value, type_alloca_alignment(return_value.type));
 	}
 
 	if (err_cleanup_block)
@@ -635,7 +636,7 @@ static void llvm_emit_switch_body_if_chain(GenContext *c,
 			llvm_emit_comparison(c, &le, &be_value, switch_value, BINARYOP_LE);
 			BEValue ge;
 			llvm_emit_comparison(c, &ge, &to_value, switch_value, BINARYOP_GE);
-			llvm_value_set_bool(&equals, LLVMBuildAnd(c->builder, le.value, ge.value, ""));
+			llvm_value_set_bool(&equals, llvm_and(c, &le, &ge));
 		}
 		else
 		{
@@ -801,7 +802,7 @@ static void llvm_emit_switch_body(GenContext *c, BEValue *switch_value, Ast *swi
 	BEValue switch_var;
 	llvm_value_set_address_abi_aligned(&switch_var, llvm_emit_alloca_aligned(c, switch_type, "switch"), switch_type);
 	switch_ast->switch_stmt.codegen.retry_var = &switch_var;
-	llvm_store_value(c, &switch_var, switch_value);
+	llvm_store(c, &switch_var, switch_value);
 
 	llvm_emit_br(c, switch_block);
 	llvm_emit_block(c, switch_block);
@@ -925,7 +926,7 @@ void gencontext_emit_next_stmt(GenContext *context, Ast *ast)
 	}
 	BEValue be_value;
 	llvm_emit_expr(context, &be_value, ast->nextcase_stmt.switch_expr);
-	llvm_store_value(context, jump_target->switch_stmt.codegen.retry_var, &be_value);
+	llvm_store(context, jump_target->switch_stmt.codegen.retry_var, &be_value);
 	llvm_emit_statement_chain(context, ast->nextcase_stmt.defer_id);
 	llvm_emit_jmp(context, jump_target->switch_stmt.codegen.retry_block);
 }
@@ -1056,7 +1057,7 @@ void gencontext_emit_expr_stmt(GenContext *c, Ast *ast)
 		c->catch_block = discard_fail;
 		c->error_var = NULL;
 		llvm_emit_expr(c, &value, ast->expr_stmt);
-		llvm_value_fold_failable(c, &value);
+		llvm_value_fold_optional(c, &value);
 		EMIT_LOC(c, ast);
 		llvm_emit_br(c, discard_fail);
 		llvm_emit_block(c, discard_fail);
@@ -1084,7 +1085,7 @@ LLVMValueRef llvm_emit_zstring_named(GenContext *c, const char *str, const char
 	// TODO alignment
 	LLVMValueRef string = llvm_emit_array_gep_raw(c, global_string, char_array_type, 0,
 	                                              1, &alignment);
-	return LLVMBuildBitCast(c->builder, string, LLVMPointerType(char_type, 0), "");
+	return llvm_emit_bitcast_ptr(c, string, type_char);
 }
 
 
@@ -1092,7 +1093,10 @@ void llvm_emit_panic(GenContext *c, const char *message, const char *file, const
 {
 	if (c->debug.stack_slot_row)
 	{
-		llvm_store(c, c->debug.stack_slot_row, llvm_const_int(c, type_uint, line), type_abi_alignment(type_uint));
+		llvm_store_to_ptr_raw_aligned(c,
+		                              c->debug.stack_slot_row,
+		                              llvm_const_int(c, type_uint, line),
+		                              type_abi_alignment(type_uint));
 	}
 
 	Decl *panicfn = c->panicfn;
@@ -1101,11 +1105,10 @@ void llvm_emit_panic(GenContext *c, const char *message, const char *file, const
 		llvm_emit_call_intrinsic(c, intrinsic_id.trap, NULL, 0, NULL, 0);
 		return;
 	}
-	LLVMTypeRef char_ptr_type = llvm_get_ptr_type(c, type_char);
 	LLVMValueRef args[4] = {
 			llvm_emit_zstring(c, message),
 			llvm_emit_zstring(c, file),
-			func ? llvm_emit_zstring(c, func) : LLVMConstNull(char_ptr_type),
+			func ? llvm_emit_zstring(c, func) : llvm_get_zero(c, type_get_ptr(type_char)),
 			llvm_const_int(c, type_uint, line)
 	};
 

src/compiler/llvm_codegen_storeload.c

@@ -4,7 +4,7 @@
 
 #include "llvm_codegen_internal.h"
 
-LLVMValueRef llvm_store(GenContext *context, LLVMValueRef pointer, LLVMValueRef value, AlignSize alignment)
+LLVMValueRef llvm_store_to_ptr_raw_aligned(GenContext *context, LLVMValueRef pointer, LLVMValueRef value, AlignSize alignment)
 {
 	assert(alignment > 0);
 	LLVMValueRef ref = LLVMBuildStore(context->builder, value, pointer);
@@ -12,33 +12,17 @@ LLVMValueRef llvm_store(GenContext *context, LLVMValueRef pointer, LLVMValueRef
 	return ref;
 }
 
-void llvm_store_raw_abi_alignment(GenContext *context, LLVMValueRef pointer, LLVMValueRef value, Type *type)
+
+void llvm_store_to_ptr_zero(GenContext *context, LLVMValueRef pointer, Type *type)
 {
-	llvm_store(context, pointer, value, type_abi_alignment(type));
+	llvm_store_to_ptr_raw_aligned(context, pointer, llvm_get_zero(context, type), type_abi_alignment(type));
 }
 
-void llvm_store_value_raw(GenContext *c, BEValue *destination, LLVMValueRef raw_value)
+LLVMValueRef llvm_store_to_ptr_aligned(GenContext *c, LLVMValueRef destination, BEValue *value, AlignSize alignment)
-{
-	assert(llvm_value_is_addr(destination));
-	llvm_store(c, destination->value, raw_value, destination->alignment);
-}
-
-void llvm_store_decl_raw(GenContext *context, Decl *decl, LLVMValueRef value)
-{
-	assert(!decl->is_value);
-	llvm_store(context, decl->backend_ref, value, decl->alignment);
-}
-
-void llvm_store_value_dest_aligned(GenContext *c, LLVMValueRef destination, BEValue *value)
-{
-	llvm_store_value_aligned(c, destination, value, LLVMGetAlignment(destination));
-}
-
-LLVMValueRef llvm_store_value_aligned(GenContext *c, LLVMValueRef destination, BEValue *value, AlignSize alignment)
 {
 	// If we have an address but not an aggregate, do a load.
 	assert(alignment);
-	llvm_value_fold_failable(c, value);
+	llvm_value_fold_optional(c, value);
 	if (value->kind == BE_ADDRESS && !type_is_abi_aggregate(value->type))
 	{
 		value->value = llvm_load_value_store(c, value);
@@ -51,7 +35,7 @@ LLVMValueRef llvm_store_value_aligned(GenContext *c, LLVMValueRef destination, B
 			value->kind = BE_VALUE;
 			FALLTHROUGH;
 		case BE_VALUE:
-			return llvm_store(c, destination, value->value, alignment);
+			return llvm_store_to_ptr_raw_aligned(c, destination, value->value, alignment);
 		case BE_ADDRESS_FAILABLE:
 			UNREACHABLE
 		case BE_ADDRESS:
@@ -73,11 +57,11 @@ LLVMValueRef llvm_store_value_aligned(GenContext *c, LLVMValueRef destination, B
 	UNREACHABLE
 }
 
-LLVMValueRef llvm_store_value(GenContext *c, BEValue *destination, BEValue *value)
+LLVMValueRef llvm_store(GenContext *c, BEValue *destination, BEValue *value)
 {
 	if (value->type == type_void) return NULL;
 	assert(llvm_value_is_addr(destination));
-	return llvm_store_value_aligned(c, destination->value, value, destination->alignment);
+	return llvm_store_to_ptr_aligned(c, destination->value, value, destination->alignment);
 }
 
 LLVMValueRef llvm_load(GenContext *c, LLVMTypeRef type, LLVMValueRef pointer, AlignSize alignment, const char *name)
@@ -98,7 +82,7 @@ LLVMValueRef llvm_load_natural_alignment(GenContext *c, Type *type, LLVMValueRef
 
 LLVMValueRef llvm_load_value(GenContext *c, BEValue *value)
 {
-	llvm_value_fold_failable(c, value);
+	llvm_value_fold_optional(c, value);
 	switch (value->kind)
 	{
 		case BE_BOOLEAN:
@@ -120,26 +104,21 @@ LLVMValueRef llvm_load_value_store(GenContext *c, BEValue *value)
 }
 
 
-void llvm_store_zero(GenContext *c, BEValue *ref)
+LLVMValueRef llvm_store_zero(GenContext *c, BEValue *ref)
 {
 	llvm_value_addr(c, ref);
 	Type *type = ref->type;
 	if (!type_is_abi_aggregate(type))
 	{
-		llvm_store_value_raw(c, ref, llvm_get_zero(c, type));
+		return llvm_store_raw(c, ref, llvm_get_zero(c, type));
-		return;
 	}
 	Type *single_type = type_abi_find_single_struct_element(type);
 
 	if (single_type && !type_is_abi_aggregate(single_type))
 	{
-		BEValue element;
+		BEValue element = *ref;
-		llvm_value_set_address(&element,
+		llvm_value_bitcast(c, &element, single_type);
-							   llvm_emit_bitcast(c, ref->value, type_get_ptr(single_type)),
+		return llvm_store_zero(c, &element);
-							   single_type,
-							   (unsigned)ref->alignment);
-		llvm_store_zero(c, &element);
-		return;
 	}
 	if (type_size(type) <= 16)
 	{
@@ -154,7 +133,7 @@ void llvm_store_zero(GenContext *c, BEValue *ref)
 				llvm_emit_struct_member_ref(c, ref, &member_ref, i);
 				llvm_store_zero(c, &member_ref);
 			}
-			return;
+			return NULL;
 		}
 		if (type->type_kind == TYPE_ARRAY)
 		{
@@ -167,8 +146,8 @@ void llvm_store_zero(GenContext *c, BEValue *ref)
 				llvm_value_set_address(&be_value, element_ptr, type->array.base, align);
 				llvm_store_zero(c, &be_value);
 			}
-			return;
+			return NULL;
 		}
 	}
-	llvm_emit_memclear_size_align(c, ref->value, type_size(ref->type), ref->alignment);
+	return llvm_emit_memclear_size_align(c, ref->value, type_size(ref->type), ref->alignment);
 }

src/compiler/llvm_codegen_type.c

@@ -643,7 +643,7 @@ static LLVMValueRef llvm_get_introspection_for_enum(GenContext *c, Type *type)
 		LLVMSetGlobalConstant(global_ref, true);
 		if (mixed)
 		{
-			associated_value->backend_ref = llvm_emit_bitcast(c, global_ref, type_get_ptr(type_get_array(associated_value->type, elements)));
+			associated_value->backend_ref = llvm_emit_bitcast_ptr(c, global_ref, type_get_array(associated_value->type, elements));
 		}
 		else
 		{

src/compiler/llvm_codegen_value.c

@@ -26,7 +26,7 @@ void llvm_value_set_address_abi_aligned(BEValue *value, LLVMValueRef llvm_value,
 
 void llvm_value_addr(GenContext *c, BEValue *value)
 {
-	llvm_value_fold_failable(c, value);
+	llvm_value_fold_optional(c, value);
 	if (value->kind == BE_ADDRESS) return;
 	if (llvm_is_global_eval(c))
 	{
@@ -34,13 +34,12 @@ void llvm_value_addr(GenContext *c, BEValue *value)
 		LLVMValueRef ref = llvm_add_global_type(c, ".taddr", LLVMTypeOf(val), 0);
 		llvm_set_private_linkage(ref);
 		LLVMSetInitializer(ref, val);
-		llvm_emit_bitcast(c, ref, type_get_ptr(value->type));
+		llvm_value_set_address_abi_aligned(value, llvm_emit_bitcast_ptr(c, ref, value->type), value->type);
-		llvm_value_set_address_abi_aligned(value, ref, value->type);
 	}
 	else
 	{
 		LLVMValueRef temp = llvm_emit_alloca_aligned(c, value->type, "taddr");
-		llvm_store_value_dest_aligned(c, temp, value);
+		llvm_store_to_ptr(c, temp, value);
 		llvm_value_set_address_abi_aligned(value, temp, value->type);
 	}
 }
@@ -56,7 +55,7 @@ void llvm_value_rvalue(GenContext *c, BEValue *value)
 		}
 		return;
 	}
-	llvm_value_fold_failable(c, value);
+	llvm_value_fold_optional(c, value);
 	value->value = llvm_load(c,
 	                         llvm_get_type(c, value->type),
 	                         value->value,
@@ -64,7 +63,7 @@ void llvm_value_rvalue(GenContext *c, BEValue *value)
 	                         "");
 	if (value->type->type_kind == TYPE_BOOL)
 	{
-		value->value = LLVMBuildTrunc(c->builder, value->value, c->bool_type, "");
+		value->value = llvm_emit_trunc_bool(c, value->value);
 		value->kind = BE_BOOLEAN;
 		return;
 	}
@@ -105,16 +104,16 @@ void llvm_emit_jump_to_optional_exit(GenContext *c, LLVMValueRef err_value)
 		llvm_emit_block(c, error_block);
 	}
 
-	llvm_store_raw_abi_alignment(c, c->error_var, err_value, type_anyerr);
+	llvm_store_to_ptr_raw(c, c->error_var, err_value, type_anyerr);
 	llvm_emit_br(c, c->catch_block);
 	llvm_emit_block(c, after_block);
 }
 
-void llvm_value_fold_failable(GenContext *c, BEValue *value)
+void llvm_value_fold_optional(GenContext *c, BEValue *value)
 {
 	if (value->kind == BE_ADDRESS_FAILABLE)
 	{
-		llvm_emit_jump_to_optional_exit(c, llvm_load_natural_alignment(c, type_anyerr, value->failable, ""));
+		llvm_emit_jump_to_optional_exit(c, llvm_load_natural_alignment(c, type_anyerr, value->failable, "optval"));
 		value->kind = BE_ADDRESS;
 	}
 }

test/src/tester.py

@@ -139,7 +139,7 @@ class Issues:
             self.line += 1
 
         self.current_file.close()
-        print("- " + str(self.conf.numtests) + " " + self.sourcefile.filepath + ":", end="")
+        print("- " + str(self.conf.numtests) + "/" + str(self.conf.numtests - self.conf.numsuccess - 1) + " " + self.sourcefile.filepath + ":", end="")
         self.compile("--test compile " + self.current_file.filepath)
         if not self.has_errors:
             self.conf.numsuccess += 1
@@ -209,7 +209,7 @@ class Issues:
             self.current_file.close()
             self.current_file = None
 
-        print("- " + str(self.conf.numtests) + " " + self.sourcefile.filepath + ":", end="")
+        print("- " + str(self.conf.numtests) + "/" + str(self.conf.numtests - self.conf.numsuccess - 1) + " " + self.sourcefile.filepath + ":", end="")
         files_to_compile = ""
         for file in self.files:
             if file.is_target:
@@ -262,7 +262,7 @@ class Issues:
         if len(self.sourcefile.content) == 0: self.exit_error("File was empty")
         is_skip = self.sourcefile.content[0].startswith("// #skip")
         if is_skip != self.skip:
-            print("- " + str(self.conf.numtests) + " " + self.sourcefile.filepath + ": *SKIPPED*")
+            print("- " + str(self.conf.numtests) + "/" + str(self.conf.numtests - self.conf.numsuccess - 1) + " " + self.sourcefile.filepath + ": *SKIPPED*")
             self.conf.numskipped += 1
             return
         if is_skip: self.line += 1

test/test_suite/arrays/array_literal.c3t

@@ -12,7 +12,7 @@ fn double test(uint x)
   return student_t[x];
 }
 
-// #expect: array_literal.ll
+/* #expect: array_literal.ll
 
 @.__const = private unnamed_addr constant [30 x double] [double 0.000000e+00, double 1.270600e+01, double 4.303000e+00, double 3.182000e+00, double 2.776000e+00, double 2.571000e+00, double 2.447000e+00, double 2.365000e+00, double 2.306000e+00, double 2.262000e+00, double 2.228000e+00, double 2.201000e+00, double 2.179000e+00, double 2.160000e+00, double 2.145000e+00, double 2.131000e+00, double 2.120000e+00, double 2.110000e+00, double 2.101000e+00, double 2.093000e+00, double 2.086000e+00, double 2.080000e+00, double 2.074000e+00, double 2.069000e+00, double 2.064000e+00, double 2.060000e+00, double 2.056000e+00, double 2.052000e+00, double 2.048000e+00, double 2.045000e+00], align 16
 
@@ -21,8 +21,8 @@ entry:
   %student_t = alloca [30 x double], align 16
   %1 = bitcast [30 x double]* %student_t to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %1, i8* align 16 bitcast ([30 x double]* @.__const to i8*), i32 240, i1 false)
-  %uiuiext = zext i32 %0 to i64
+  %zext = zext i32 %0 to i64
-  %2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %uiuiext
+  %2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %zext
   %3 = load double, double* %2, align 8
   ret double %3
 }

test/test_suite/bitstruct/array_with_boolean.c3t

@@ -31,41 +31,41 @@ entry:
   store [3 x i8] c"\1A\1E\10", [3 x i8]* %xy, align 1
   %0 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
   %1 = load i8, i8* %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = shl i32 %2, 29
+  %shl = shl i32 %zext, 29
-  %4 = ashr i32 %3, 29
+  %ashr = ashr i32 %shl, 29
-  %5 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
+  %2 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
-  %6 = load i8, i8* %5, align 1
+  %3 = load i8, i8* %2, align 1
-  %7 = zext i8 %6 to i32
+  %zext1 = zext i8 %3 to i32
-  %8 = lshr i32 %7, 3
+  %lshrl = lshr i32 %zext1, 3
-  %9 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
+  %4 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
+  %5 = load i8, i8* %4, align 1
+  %zext2 = zext i8 %5 to i32
+  %shl3 = shl i32 %zext2, 5
+  %6 = or i32 %shl3, %lshrl
+  %shl4 = shl i32 %6, 26
+  %ashr5 = ashr i32 %shl4, 26
+  %7 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
+  %8 = load i8, i8* %7, align 1
+  %zext6 = zext i8 %8 to i32
+  %lshrl7 = lshr i32 %zext6, 1
+  %9 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
   %10 = load i8, i8* %9, align 1
-  %11 = zext i8 %10 to i32
+  %zext8 = zext i8 %10 to i32
-  %12 = shl i32 %11, 5
+  %shl9 = shl i32 %zext8, 7
-  %13 = or i32 %12, %8
+  %11 = or i32 %shl9, %lshrl7
-  %14 = shl i32 %13, 26
+  %shl10 = shl i32 %11, 22
-  %15 = ashr i32 %14, 26
+  %ashr11 = ashr i32 %shl10, 22
-  %16 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
+  %12 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
-  %17 = load i8, i8* %16, align 1
+  %13 = load i8, i8* %12, align 1
-  %18 = zext i8 %17 to i32
+  %lshrl12 = lshr i8 %13, 3
-  %19 = lshr i32 %18, 1
+  %14 = trunc i8 %lshrl12 to i1
-  %20 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
+  %boolsi = zext i1 %14 to i32
-  %21 = load i8, i8* %20, align 1
+  %15 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
-  %22 = zext i8 %21 to i32
+  %16 = load i8, i8* %15, align 1
-  %23 = shl i32 %22, 7
+  %lshrl13 = lshr i8 %16, 4
-  %24 = or i32 %23, %19
+  %17 = trunc i8 %lshrl13 to i1
-  %25 = shl i32 %24, 22
+  %boolsi14 = zext i1 %17 to i32
-  %26 = ashr i32 %25, 22
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i32 0, i32 0), i32 %ashr, i32 %ashr5, i32 %ashr11, i32 %boolsi, i32 %boolsi14)
-  %27 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
-  %28 = load i8, i8* %27, align 1
-  %29 = lshr i8 %28, 3
-  %30 = trunc i8 %29 to i1
-  %boolsi = zext i1 %30 to i32
-  %31 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
-  %32 = load i8, i8* %31, align 1
-  %33 = lshr i8 %32, 4
-  %34 = trunc i8 %33 to i1
-  %boolsi1 = zext i1 %34 to i32
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i32 0, i32 0), i32 %4, i32 %15, i32 %26, i32 %boolsi, i32 %boolsi1)
   ret void
 }

test/test_suite/bitstruct/bitfield_access.c3t

@@ -125,56 +125,56 @@ entry:
   store i8 0, i8* %d, align 1
   %0 = getelementptr inbounds [3 x i8], [3 x i8]* %e1, i64 0, i64 0
   %1 = load i8, i8* %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = shl i32 %2, 29
+  %shl = shl i32 %zext, 29
-  %4 = ashr i32 %3, 29
+  %ashr = ashr i32 %shl, 29
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %4)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
-  %5 = getelementptr inbounds [3 x i8], [3 x i8]* %e2, i64 0, i64 0
+  %2 = getelementptr inbounds [3 x i8], [3 x i8]* %e2, i64 0, i64 0
-  %6 = load i8, i8* %5, align 1
+  %3 = load i8, i8* %2, align 1
-  %7 = zext i8 %6 to i32
+  %zext1 = zext i8 %3 to i32
-  %8 = shl i32 %7, 29
+  %shl2 = shl i32 %zext1, 29
-  %9 = ashr i32 %8, 29
+  %ashr3 = ashr i32 %shl2, 29
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %9)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %ashr3)
-  %10 = getelementptr inbounds [3 x i8], [3 x i8]* %e3, i64 0, i64 0
+  %4 = getelementptr inbounds [3 x i8], [3 x i8]* %e3, i64 0, i64 0
-  %11 = load i8, i8* %10, align 1
+  %5 = load i8, i8* %4, align 1
-  %12 = zext i8 %11 to i32
+  %zext4 = zext i8 %5 to i32
-  %13 = shl i32 %12, 29
+  %shl5 = shl i32 %zext4, 29
-  %14 = ashr i32 %13, 29
+  %ashr6 = ashr i32 %shl5, 29
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %14)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %ashr6)
   store [3 x i8] c"\0B\06 ", [3 x i8]* %z1, align 1
   store [3 x i8] c"\0C\06 ", [3 x i8]* %z2, align 1
   store [3 x i8] c"\0F\06 ", [3 x i8]* %z3, align 1
-  %15 = getelementptr inbounds [3 x i8], [3 x i8]* %z1, i64 0, i64 0
+  %6 = getelementptr inbounds [3 x i8], [3 x i8]* %z1, i64 0, i64 0
-  %16 = load i8, i8* %15, align 1
+  %7 = load i8, i8* %6, align 1
-  %17 = zext i8 %16 to i32
+  %zext7 = zext i8 %7 to i32
-  %18 = and i32 7, %17
+  %8 = and i32 7, %zext7
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i32 %18)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i32 %8)
-  %19 = getelementptr inbounds [3 x i8], [3 x i8]* %z2, i64 0, i64 0
+  %9 = getelementptr inbounds [3 x i8], [3 x i8]* %z2, i64 0, i64 0
-  %20 = load i8, i8* %19, align 1
+  %10 = load i8, i8* %9, align 1
-  %21 = zext i8 %20 to i32
+  %zext8 = zext i8 %10 to i32
-  %22 = and i32 7, %21
+  %11 = and i32 7, %zext8
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i32 0, i32 0), i32 %22)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i32 0, i32 0), i32 %11)
-  %23 = getelementptr inbounds [3 x i8], [3 x i8]* %z3, i64 0, i64 0
+  %12 = getelementptr inbounds [3 x i8], [3 x i8]* %z3, i64 0, i64 0
-  %24 = load i8, i8* %23, align 1
+  %13 = load i8, i8* %12, align 1
-  %25 = zext i8 %24 to i32
+  %zext9 = zext i8 %13 to i32
-  %26 = and i32 7, %25
+  %14 = and i32 7, %zext9
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i32 0, i32 0), i32 %26)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i32 0, i32 0), i32 %14)
   store [5 x i8] c"\00G\02\00\00", [5 x i8]* %xx, align 1
-  %27 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 0
+  %15 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 0
-  %28 = load i8, i8* %27, align 1
+  %16 = load i8, i8* %15, align 1
-  %29 = zext i8 %28 to i32
+  %zext10 = zext i8 %16 to i32
-  %30 = lshr i32 %29, 5
+  %lshrl = lshr i32 %zext10, 5
-  %31 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 1
+  %17 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 1
-  %32 = load i8, i8* %31, align 1
+  %18 = load i8, i8* %17, align 1
-  %33 = zext i8 %32 to i32
+  %zext11 = zext i8 %18 to i32
-  %34 = shl i32 %33, 3
+  %shl12 = shl i32 %zext11, 3
-  %35 = or i32 %34, %30
+  %19 = or i32 %shl12, %lshrl
-  %36 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 2
+  %20 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 2
-  %37 = load i8, i8* %36, align 1
+  %21 = load i8, i8* %20, align 1
-  %38 = zext i8 %37 to i32
+  %zext13 = zext i8 %21 to i32
-  %39 = shl i32 %38, 11
+  %shl14 = shl i32 %zext13, 11
-  %40 = or i32 %39, %35
+  %22 = or i32 %shl14, %19
-  %41 = and i32 262143, %40
+  %23 = and i32 262143, %22
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i32 0, i32 0), i32 %41)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i32 0, i32 0), i32 %23)
   ret void
 }

test/test_suite/bitstruct/bitstruct_access_signed.c3t

@@ -37,55 +37,55 @@ entry:
   store [3 x i8] c"\E0\FD\7F", [3 x i8]* %xx, align 1
   %0 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
   %1 = load i8, i8* %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = lshr i32 %2, 5
+  %lshrl = lshr i32 %zext, 5
-  %4 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
+  %2 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
-  %5 = load i8, i8* %4, align 1
+  %3 = load i8, i8* %2, align 1
-  %6 = zext i8 %5 to i32
+  %zext1 = zext i8 %3 to i32
-  %7 = shl i32 %6, 3
+  %shl = shl i32 %zext1, 3
-  %8 = or i32 %7, %3
+  %4 = or i32 %shl, %lshrl
-  %9 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
+  %5 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
-  %10 = load i8, i8* %9, align 1
+  %6 = load i8, i8* %5, align 1
-  %11 = zext i8 %10 to i32
+  %zext2 = zext i8 %6 to i32
-  %12 = shl i32 %11, 11
+  %shl3 = shl i32 %zext2, 11
-  %13 = or i32 %12, %8
+  %7 = or i32 %shl3, %4
-  %14 = shl i32 %13, 14
+  %shl4 = shl i32 %7, 14
-  %15 = ashr i32 %14, 14
+  %ashr = ashr i32 %shl4, 14
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %15)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
   store [3 x i8] c"\FF\FD\FF", [3 x i8]* %xx, align 1
-  %16 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
+  %8 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0
-  %17 = load i8, i8* %16, align 1
+  %9 = load i8, i8* %8, align 1
-  %18 = zext i8 %17 to i32
+  %zext5 = zext i8 %9 to i32
-  %19 = lshr i32 %18, 5
+  %lshrl6 = lshr i32 %zext5, 5
-  %20 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
+  %10 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1
-  %21 = load i8, i8* %20, align 1
+  %11 = load i8, i8* %10, align 1
-  %22 = zext i8 %21 to i32
+  %zext7 = zext i8 %11 to i32
-  %23 = shl i32 %22, 3
+  %shl8 = shl i32 %zext7, 3
-  %24 = or i32 %23, %19
+  %12 = or i32 %shl8, %lshrl6
-  %25 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
+  %13 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2
-  %26 = load i8, i8* %25, align 1
+  %14 = load i8, i8* %13, align 1
-  %27 = zext i8 %26 to i32
+  %zext9 = zext i8 %14 to i32
-  %28 = shl i32 %27, 11
+  %shl10 = shl i32 %zext9, 11
-  %29 = or i32 %28, %24
+  %15 = or i32 %shl10, %12
-  %30 = shl i32 %29, 14
+  %shl11 = shl i32 %15, 14
-  %31 = ashr i32 %30, 14
+  %ashr12 = ashr i32 %shl11, 14
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %31)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %ashr12)
   store [3 x i8] c"\1F\CF\AA", [3 x i8]* %xxu, align 1
-  %32 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 0
+  %16 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 0
-  %33 = load i8, i8* %32, align 1
+  %17 = load i8, i8* %16, align 1
-  %34 = zext i8 %33 to i32
+  %zext13 = zext i8 %17 to i32
-  %35 = lshr i32 %34, 5
+  %lshrl14 = lshr i32 %zext13, 5
-  %36 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 1
+  %18 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 1
-  %37 = load i8, i8* %36, align 1
+  %19 = load i8, i8* %18, align 1
-  %38 = zext i8 %37 to i32
+  %zext15 = zext i8 %19 to i32
-  %39 = shl i32 %38, 3
+  %shl16 = shl i32 %zext15, 3
-  %40 = or i32 %39, %35
+  %20 = or i32 %shl16, %lshrl14
-  %41 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 2
+  %21 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 2
-  %42 = load i8, i8* %41, align 1
+  %22 = load i8, i8* %21, align 1
-  %43 = zext i8 %42 to i32
+  %zext17 = zext i8 %22 to i32
-  %44 = shl i32 %43, 11
+  %shl18 = shl i32 %zext17, 11
-  %45 = or i32 %44, %40
+  %23 = or i32 %shl18, %20
-  %46 = and i32 262143, %45
+  %24 = and i32 262143, %23
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %46)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %24)
   ret void
 }

test/test_suite/bitstruct/bitstruct_arrays_be.c3t

@@ -46,101 +46,101 @@ entry:
   store [4 x i8] c"\E0\FB\0A\00", [4 x i8]* %xx, align 1
   %0 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
   %1 = load i8, i8* %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = lshr i32 %2, 4
+  %lshrl = lshr i32 %zext, 4
-  %4 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
+  %2 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
-  %5 = load i8, i8* %4, align 1
+  %3 = load i8, i8* %2, align 1
-  %6 = zext i8 %5 to i32
+  %zext1 = zext i8 %3 to i32
-  %7 = shl i32 %6, 4
+  %shl = shl i32 %zext1, 4
-  %8 = or i32 %7, %3
+  %4 = or i32 %shl, %lshrl
-  %9 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
+  %5 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
-  %10 = load i8, i8* %9, align 1
+  %6 = load i8, i8* %5, align 1
-  %11 = zext i8 %10 to i32
+  %zext2 = zext i8 %6 to i32
-  %12 = shl i32 %11, 12
+  %shl3 = shl i32 %zext2, 12
-  %13 = or i32 %12, %8
+  %7 = or i32 %shl3, %4
-  %14 = shl i32 %13, 16
+  %shl4 = shl i32 %7, 16
-  %15 = call i32 @llvm.bswap.i32(i32 %14)
+  %8 = call i32 @llvm.bswap.i32(i32 %shl4)
-  %16 = and i32 65535, %15
+  %9 = and i32 65535, %8
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), i32 %16)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), i32 %9)
   store [4 x i8] c"\F0\EA\0B\00", [4 x i8]* %xy, align 1
   %ptrptr = bitcast [4 x i8]* %xy to i8*
   store i8* %ptrptr, i8** %abc, align 8
-  %17 = load i8*, i8** %abc, align 8
+  %10 = load i8*, i8** %abc, align 8
-  %ptrptr1 = bitcast i8* %17 to [4 x i8]*
+  %ptrptr5 = bitcast i8* %10 to [4 x i8]*
-  store [4 x i8]* %ptrptr1, [4 x i8]** %z, align 8
+  store [4 x i8]* %ptrptr5, [4 x i8]** %z, align 8
-  %18 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
+  %11 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
-  %19 = load i8, i8* %18, align 1
+  %12 = load i8, i8* %11, align 1
-  %20 = zext i8 %19 to i32
+  %zext6 = zext i8 %12 to i32
-  %21 = lshr i32 %20, 4
+  %lshrl7 = lshr i32 %zext6, 4
-  %22 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
+  %13 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
-  %23 = load i8, i8* %22, align 1
+  %14 = load i8, i8* %13, align 1
-  %24 = zext i8 %23 to i32
+  %zext8 = zext i8 %14 to i32
-  %25 = shl i32 %24, 4
+  %shl9 = shl i32 %zext8, 4
-  %26 = or i32 %25, %21
+  %15 = or i32 %shl9, %lshrl7
-  %27 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
+  %16 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
-  %28 = load i8, i8* %27, align 1
+  %17 = load i8, i8* %16, align 1
-  %29 = zext i8 %28 to i32
+  %zext10 = zext i8 %17 to i32
-  %30 = shl i32 %29, 12
+  %shl11 = shl i32 %zext10, 12
-  %31 = or i32 %30, %26
+  %18 = or i32 %shl11, %15
-  %32 = and i32 65535, %31
+  %19 = and i32 65535, %18
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i32 %32)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i32 %19)
-  %33 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
+  %20 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
-  %34 = load i8, i8* %33, align 1
+  %21 = load i8, i8* %20, align 1
-  %35 = and i8 %34, 15
+  %22 = and i8 %21, 15
-  %36 = or i8 %35, -16
+  %23 = or i8 %22, -16
-  store i8 %36, i8* %33, align 1
+  store i8 %23, i8* %20, align 1
-  %37 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
+  %24 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
-  store i8 -18, i8* %37, align 1
+  store i8 -18, i8* %24, align 1
-  %38 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
+  %25 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
+  %26 = load i8, i8* %25, align 1
+  %27 = and i8 %26, -16
+  %28 = or i8 %27, 11
+  store i8 %28, i8* %25, align 1
+  %29 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
+  %30 = load i8, i8* %29, align 1
+  %zext12 = zext i8 %30 to i32
+  %lshrl13 = lshr i32 %zext12, 4
+  %31 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
+  %32 = load i8, i8* %31, align 1
+  %zext14 = zext i8 %32 to i32
+  %shl15 = shl i32 %zext14, 4
+  %33 = or i32 %shl15, %lshrl13
+  %34 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
+  %35 = load i8, i8* %34, align 1
+  %zext16 = zext i8 %35 to i32
+  %shl17 = shl i32 %zext16, 12
+  %36 = or i32 %shl17, %33
+  %37 = and i32 65535, %36
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), i32 %37)
+  %38 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
   %39 = load i8, i8* %38, align 1
-  %40 = and i8 %39, -16
+  %40 = and i8 %39, 15
-  %41 = or i8 %40, 11
+  %41 = or i8 %40, -32
   store i8 %41, i8* %38, align 1
-  %42 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0
+  %42 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
-  %43 = load i8, i8* %42, align 1
+  store i8 -5, i8* %42, align 1
-  %44 = zext i8 %43 to i32
+  %43 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
-  %45 = lshr i32 %44, 4
+  %44 = load i8, i8* %43, align 1
-  %46 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1
+  %45 = and i8 %44, -16
-  %47 = load i8, i8* %46, align 1
+  %46 = or i8 %45, 14
-  %48 = zext i8 %47 to i32
+  store i8 %46, i8* %43, align 1
-  %49 = shl i32 %48, 4
+  %47 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
-  %50 = or i32 %49, %45
+  %48 = load i8, i8* %47, align 1
-  %51 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2
+  %zext18 = zext i8 %48 to i32
-  %52 = load i8, i8* %51, align 1
+  %lshrl19 = lshr i32 %zext18, 4
-  %53 = zext i8 %52 to i32
+  %49 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
-  %54 = shl i32 %53, 12
+  %50 = load i8, i8* %49, align 1
-  %55 = or i32 %54, %50
+  %zext20 = zext i8 %50 to i32
+  %shl21 = shl i32 %zext20, 4
+  %51 = or i32 %shl21, %lshrl19
+  %52 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
+  %53 = load i8, i8* %52, align 1
+  %zext22 = zext i8 %53 to i32
+  %shl23 = shl i32 %zext22, 12
+  %54 = or i32 %shl23, %51
+  %shl24 = shl i32 %54, 16
+  %55 = call i32 @llvm.bswap.i32(i32 %shl24)
   %56 = and i32 65535, %55
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i32 0, i32 0), i32 %56)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i32 %56)
-  %57 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
-  %58 = load i8, i8* %57, align 1
-  %59 = and i8 %58, 15
-  %60 = or i8 %59, -32
-  store i8 %60, i8* %57, align 1
-  %61 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
-  store i8 -5, i8* %61, align 1
-  %62 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
-  %63 = load i8, i8* %62, align 1
-  %64 = and i8 %63, -16
-  %65 = or i8 %64, 14
-  store i8 %65, i8* %62, align 1
-  %66 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0
-  %67 = load i8, i8* %66, align 1
-  %68 = zext i8 %67 to i32
-  %69 = lshr i32 %68, 4
-  %70 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1
-  %71 = load i8, i8* %70, align 1
-  %72 = zext i8 %71 to i32
-  %73 = shl i32 %72, 4
-  %74 = or i32 %73, %69
-  %75 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2
-  %76 = load i8, i8* %75, align 1
-  %77 = zext i8 %76 to i32
-  %78 = shl i32 %77, 12
-  %79 = or i32 %78, %74
-  %80 = shl i32 %79, 16
-  %81 = call i32 @llvm.bswap.i32(i32 %80)
-  %82 = and i32 65535, %81
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i32 %82)
   ret void
 }

test/test_suite/bitstruct/bitstruct_intcontainer.c3t

@@ -57,49 +57,49 @@ entry:
   %xxybe = alloca i64, align 8
   store i32 8388128, i32* %xx, align 4
   %0 = load i32, i32* %xx, align 4
-  %1 = shl i32 %0, 9
+  %shl = shl i32 %0, 9
-  %2 = ashr i32 %1, 14
+  %ashr = ashr i32 %shl, 14
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %2)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
   store i32 1073741375, i32* %xx, align 4
-  %3 = load i32, i32* %xx, align 4
+  %1 = load i32, i32* %xx, align 4
-  %4 = shl i32 %3, 9
+  %shl1 = shl i32 %1, 9
-  %5 = ashr i32 %4, 14
+  %ashr2 = ashr i32 %shl1, 14
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %5)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %ashr2)
   store i32 -3485921, i32* %xxu, align 4
-  %6 = load i32, i32* %xxu, align 4
+  %2 = load i32, i32* %xxu, align 4
-  %7 = lshr i32 %6, 5
+  %lshrl = lshr i32 %2, 5
-  %8 = and i32 262143, %7
+  %3 = and i32 262143, %lshrl
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %8)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %3)
   store i64 1525363991714123551, i64* %xxy, align 8
-  %9 = load i64, i64* %xxy, align 8
+  %4 = load i64, i64* %xxy, align 8
-  %10 = lshr i64 %9, 5
+  %lshrl3 = lshr i64 %4, 5
-  %11 = and i64 262143, %10
+  %5 = and i64 262143, %lshrl3
-  %12 = trunc i64 %11 to i32
+  %ztrunc = trunc i64 %5 to i32
-  %13 = load i64, i64* %xxy, align 8
+  %6 = load i64, i64* %xxy, align 8
-  %14 = lshr i64 %13, 23
+  %lshrl4 = lshr i64 %6, 23
-  %15 = and i64 262143, %14
+  %7 = and i64 262143, %lshrl4
-  %16 = trunc i64 %15 to i32
+  %ztrunc5 = trunc i64 %7 to i32
-  %17 = load i64, i64* %xxy, align 8
+  %8 = load i64, i64* %xxy, align 8
-  %18 = lshr i64 %17, 41
+  %lshrl6 = lshr i64 %8, 41
-  %19 = and i64 2097151, %18
+  %9 = and i64 2097151, %lshrl6
-  %20 = trunc i64 %19 to i32
+  %ztrunc7 = trunc i64 %9 to i32
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i32 0, i32 0), i32 %12, i32 %16, i32 %20)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i32 0, i32 0), i32 %ztrunc, i32 %ztrunc5, i32 %ztrunc7)
   store i64 2292133196431502101, i64* %xxybe, align 8
-  %21 = load i64, i64* %xxybe, align 8
+  %10 = load i64, i64* %xxybe, align 8
-  %22 = call i64 @llvm.bswap.i64(i64 %21)
+  %11 = call i64 @llvm.bswap.i64(i64 %10)
-  %23 = lshr i64 %22, 5
+  %lshrl8 = lshr i64 %11, 5
-  %24 = and i64 262143, %23
+  %12 = and i64 262143, %lshrl8
-  %25 = trunc i64 %24 to i32
+  %ztrunc9 = trunc i64 %12 to i32
-  %26 = load i64, i64* %xxybe, align 8
+  %13 = load i64, i64* %xxybe, align 8
-  %27 = call i64 @llvm.bswap.i64(i64 %26)
+  %14 = call i64 @llvm.bswap.i64(i64 %13)
-  %28 = lshr i64 %27, 23
+  %lshrl10 = lshr i64 %14, 23
-  %29 = and i64 262143, %28
+  %15 = and i64 262143, %lshrl10
-  %30 = trunc i64 %29 to i32
+  %ztrunc11 = trunc i64 %15 to i32
-  %31 = load i64, i64* %xxybe, align 8
+  %16 = load i64, i64* %xxybe, align 8
-  %32 = call i64 @llvm.bswap.i64(i64 %31)
+  %17 = call i64 @llvm.bswap.i64(i64 %16)
-  %33 = lshr i64 %32, 41
+  %lshrl12 = lshr i64 %17, 41
-  %34 = and i64 2097151, %33
+  %18 = and i64 2097151, %lshrl12
-  %35 = trunc i64 %34 to i32
+  %ztrunc13 = trunc i64 %18 to i32
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i32 %25, i32 %30, i32 %35)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.4, i32 0, i32 0), i32 %ztrunc9, i32 %ztrunc11, i32 %ztrunc13)
   ret void
 }

test/test_suite/bitstruct/bitstruct_to_int.c3t

@@ -65,12 +65,12 @@ entry:
   store i32* %b, i32** %c, align 8
   %3 = load i32*, i32** %c, align 8
   %4 = load i32, i32* %3, align 8
-  %5 = shl i32 %4, 28
+  %shl = shl i32 %4, 28
-  %6 = ashr i32 %5, 29
+  %ashr = ashr i32 %shl, 29
-  %7 = load i32*, i32** %c, align 8
+  %5 = load i32*, i32** %c, align 8
-  store i32* %7, i32** %x2, align 8
+  store i32* %5, i32** %x2, align 8
-  %8 = load i32*, i32** %c, align 8
+  %6 = load i32*, i32** %c, align 8
-  %ptrptr = bitcast i32* %8 to [4 x i8]*
+  %ptrptr = bitcast i32* %6 to [4 x i8]*
   store [4 x i8]* %ptrptr, [4 x i8]** %y2, align 8
   ret void
 }
@@ -95,15 +95,15 @@ entry:
   %4 = load [4 x i8]*, [4 x i8]** %c, align 8
   %5 = getelementptr inbounds [4 x i8], [4 x i8]* %4, i64 0, i64 0
   %6 = load i8, i8* %5, align 1
-  %7 = zext i8 %6 to i32
+  %zext = zext i8 %6 to i32
-  %8 = lshr i32 %7, 1
+  %lshrl = lshr i32 %zext, 1
-  %9 = shl i32 %8, 29
+  %shl = shl i32 %lshrl, 29
-  %10 = ashr i32 %9, 29
+  %ashr = ashr i32 %shl, 29
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %10)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %ashr)
-  %11 = load [4 x i8]*, [4 x i8]** %c, align 8
+  %7 = load [4 x i8]*, [4 x i8]** %c, align 8
-  %ptrptr = bitcast [4 x i8]* %11 to i32*
+  %ptrptr = bitcast [4 x i8]* %7 to i32*
   store i32* %ptrptr, i32** %x2, align 8
-  %12 = load [4 x i8]*, [4 x i8]** %c, align 8
+  %8 = load [4 x i8]*, [4 x i8]** %c, align 8
-  store [4 x i8]* %12, [4 x i8]** %y2, align 8
+  store [4 x i8]* %8, [4 x i8]** %y2, align 8
   ret void
 }

test/test_suite/bitstruct/embedded_bitstruct.c3t

@@ -58,24 +58,24 @@ entry:
   %4 = load i32, i32* %3, align 4
   %5 = getelementptr inbounds %Bar, %Bar* %b, i32 0, i32 2
   %6 = load i32, i32* %5, align 4
-  %7 = shl i32 %6, 21
+  %shl = shl i32 %6, 21
-  %8 = ashr i32 %7, 23
+  %ashr = ashr i32 %shl, 23
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i32 %4, i32 %8)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i32 %4, i32 %ashr)
-  %9 = bitcast %Foo* %f to i8*
+  %7 = bitcast %Foo* %f to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %9, i8* align 4 bitcast (%Foo* @.__const.10 to i8*), i32 16, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %7, i8* align 4 bitcast (%Foo* @.__const.10 to i8*), i32 16, i1 false)
-  %10 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
+  %8 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
-  %11 = getelementptr inbounds %anon.1, %anon.1* %10, i32 0, i32 0
+  %9 = getelementptr inbounds %anon.1, %anon.1* %8, i32 0, i32 0
-  %12 = getelementptr inbounds %anon.2, %anon.2* %11, i32 0, i32 0
+  %10 = getelementptr inbounds %anon.2, %anon.2* %9, i32 0, i32 0
-  %13 = load i32, i32* %12, align 4
+  %11 = load i32, i32* %10, align 4
-  %14 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
+  %12 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
-  %15 = getelementptr inbounds %anon.1, %anon.1* %14, i32 0, i32 1
+  %13 = getelementptr inbounds %anon.1, %anon.1* %12, i32 0, i32 1
-  %16 = getelementptr inbounds %anon.3, %anon.3* %15, i32 0, i32 0
+  %14 = getelementptr inbounds %anon.3, %anon.3* %13, i32 0, i32 0
-  %17 = load i32, i32* %16, align 4
+  %15 = load i32, i32* %14, align 4
-  %18 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
+  %16 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0
-  %19 = getelementptr inbounds %anon.1, %anon.1* %18, i32 0, i32 2
+  %17 = getelementptr inbounds %anon.1, %anon.1* %16, i32 0, i32 2
+  %18 = load i32, i32* %17, align 4
+  %19 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 1
   %20 = load i32, i32* %19, align 4
-  %21 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 1
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i32 0, i32 0), i32 %11, i32 %15, i32 %18, i32 %20)
-  %22 = load i32, i32* %21, align 4
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i32 0, i32 0), i32 %13, i32 %17, i32 %20, i32 %22)
   ret void
 }

test/test_suite/cast/top_down_casts.c3t

@@ -15,7 +15,7 @@ fn void test()
     z = w ?? 1;
 }
 
-// #expect: top_down_casts.ll
+/* #expect: top_down_casts.ll
 
 define void @top_down_casts_test() #0 {
 entry:
@@ -59,43 +59,43 @@ entry:
   %10 = load i32, i32* %x, align 4
   %sisiext10 = sext i32 %10 to i64
   %11 = load i32, i32* %y, align 4
-  %12 = zext i32 %11 to i64
+  %zext = zext i32 %11 to i64
-  %shl = shl i64 %sisiext10, %12
+  %shl = shl i64 %sisiext10, %zext
-  %13 = freeze i64 %shl
+  %12 = freeze i64 %shl
-  store i64 %13, i64* %z, align 8
+  store i64 %12, i64* %z, align 8
-  %14 = load i32, i32* %x, align 4
+  %13 = load i32, i32* %x, align 4
-  %sisiext11 = sext i32 %14 to i64
+  %sisiext11 = sext i32 %13 to i64
-  %15 = load i32, i32* %y, align 4
+  %14 = load i32, i32* %y, align 4
-  %16 = zext i32 %15 to i64
+  %zext12 = zext i32 %14 to i64
-  %ashr = ashr i64 %sisiext11, %16
+  %ashr = ashr i64 %sisiext11, %zext12
-  %17 = freeze i64 %ashr
+  %15 = freeze i64 %ashr
-  store i64 %17, i64* %z, align 8
+  store i64 %15, i64* %z, align 8
-  %18 = load i32, i32* %x, align 4
+  %16 = load i32, i32* %x, align 4
-  %sisiext12 = sext i32 %18 to i64
+  %sisiext13 = sext i32 %16 to i64
-  %bnot = xor i64 %sisiext12, -1
+  %bnot = xor i64 %sisiext13, -1
   store i64 %bnot, i64* %z, align 8
-  %19 = load i32, i32* %x, align 4
+  %17 = load i32, i32* %x, align 4
-  %sisiext13 = sext i32 %19 to i64
+  %sisiext14 = sext i32 %17 to i64
-  %20 = load i32, i32* %x, align 4
+  %18 = load i32, i32* %x, align 4
-  %sisiext14 = sext i32 %20 to i64
+  %sisiext15 = sext i32 %18 to i64
-  %neg = sub i64 0, %sisiext14
+  %neg = sub i64 0, %sisiext15
   store i64 %neg, i64* %z, align 8
   store i64 0, i64* %w.f, align 8
   store i32 0, i32* %w, align 4
-  %21 = load i64, i64* %w.f, align 8
+  %optval = load i64, i64* %w.f, align 8
-  %not_err = icmp eq i64 %21, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %else_block
 
 after_check:                                      ; preds = %entry
-  %22 = load i32, i32* %w, align 4
+  %19 = load i32, i32* %w, align 4
-  %sisiext15 = sext i32 %22 to i64
+  %sisiext16 = sext i32 %19 to i64
   br label %phi_block
 
 else_block:                                       ; preds = %entry
   br label %phi_block
 
 phi_block:                                        ; preds = %else_block, %after_check
-  %val = phi i64 [ %sisiext15, %after_check ], [ 1, %else_block ]
+  %val = phi i64 [ %sisiext16, %after_check ], [ 1, %else_block ]
   store i64 %val, i64* %z, align 8
   ret void
 }

test/test_suite/clang/2002-04.c3t

@@ -116,8 +116,8 @@ entry:
   %student_t = alloca [30 x double], align 16
   %1 = bitcast [30 x double]* %student_t to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 16 %1, i8* align 16 bitcast ([30 x double]* @.__const to i8*), i32 240, i1 false)
-  %uiuiext = zext i32 %0 to i64
+  %zext = zext i32 %0 to i64
-  %2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %uiuiext
+  %2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %zext
   %3 = load double, double* %2, align 8
   ret double %3
 }

test/test_suite/enumerations/enum_cast.c3t

@@ -47,6 +47,7 @@ entry:
   ret void
 }
 
+; Function Attrs: nounwind
 define void @test_test() #0 {
 entry:
   %b = alloca i8, align 1
@@ -76,17 +77,17 @@ entry:
   %uifp = uitofp i8 %2 to float
   store float %uifp, float* %e, align 4
   store i64 0, i64* %e.f, align 8
-  %3 = load i64, i64* %xf.f, align 8
+  %optval = load i64, i64* %xf.f, align 8
-  %not_err = icmp eq i64 %3, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %3, i64* %e.f, align 8
+  store i64 %optval, i64* %e.f, align 8
   br label %after_assign
 
 after_check:                                      ; preds = %entry
-  %4 = load i8, i8* %xf, align 1
+  %3 = load i8, i8* %xf, align 1
-  %uifp1 = uitofp i8 %4 to float
+  %uifp1 = uitofp i8 %3 to float
   store float %uifp1, float* %e, align 4
   store i64 0, i64* %e.f, align 8
   br label %after_assign

test/test_suite/errors/error_regression_2.c3t

@@ -366,13 +366,14 @@ if.then15:                                        ; preds = %if.exit9
   %32 = getelementptr inbounds %Doc, %Doc* %literal17, i32 0, i32 0
   %33 = getelementptr inbounds %Head, %Head* %literal18, i32 0, i32 0
   store %"char[]"* null, %"char[]"** %33, align 8
-  %34 = load %Head, %Head* %literal18, align 8
+  %34 = bitcast %Head* %value to i8*
-  store %Head %34, %Head* %value, align 8
+  %35 = bitcast %Head* %literal18 to i8*
-  %35 = call i8* @std_core_mem_malloc(i64 8) #2
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %34, i8* align 8 %35, i32 8, i1 false)
-  %ptrptr = bitcast i8* %35 to %Head*
+  %36 = call i8* @std_core_mem_malloc(i64 8) #2
+  %ptrptr = bitcast i8* %36 to %Head*
   store %Head* %ptrptr, %Head** %temp, align 8
-  %36 = load %Head*, %Head** %temp, align 8
+  %37 = load %Head*, %Head** %temp, align 8
-  %not = icmp eq %Head* %36, null
+  %not = icmp eq %Head* %37, null
   br i1 %not, label %if.then19, label %if.exit20
 
 if.then19:                                        ; preds = %if.then15
@@ -380,51 +381,51 @@ if.then19:                                        ; preds = %if.then15
   br label %guard_block
 
 if.exit20:                                        ; preds = %if.then15
-  %37 = load %Head*, %Head** %temp, align 8
+  %38 = load %Head*, %Head** %temp, align 8
-  %38 = bitcast %Head* %37 to i8*
+  %39 = bitcast %Head* %38 to i8*
-  %39 = bitcast %Head* %value to i8*
+  %40 = bitcast %Head* %value to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %38, i8* align 8 %39, i32 8, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %39, i8* align 8 %40, i32 8, i1 false)
   br label %noerr_block
 
 guard_block:                                      ; preds = %if.then19
-  %40 = load i64, i64* %error_var, align 8
+  %41 = load i64, i64* %error_var, align 8
-  ret i64 %40
+  ret i64 %41
 
 noerr_block:                                      ; preds = %if.exit20
-  %41 = load %Head*, %Head** %temp, align 8
+  %42 = load %Head*, %Head** %temp, align 8
-  store %Head* %41, %Head** %32, align 8
+  store %Head* %42, %Head** %32, align 8
-  %42 = bitcast %Doc* %0 to i8*
+  %43 = bitcast %Doc* %0 to i8*
-  %43 = bitcast %Doc* %literal17 to i8*
+  %44 = bitcast %Doc* %literal17 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %42, i8* align 8 %43, i32 8, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %43, i8* align 8 %44, i32 8, i1 false)
   ret i64 0
 
 if.exit21:                                        ; preds = %if.exit9
-  %44 = bitcast %"char[]"* %url to { i8*, i64 }*
+  %45 = bitcast %"char[]"* %url to { i8*, i64 }*
-  %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0
+  %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0
-  %lo22 = load i8*, i8** %45, align 8
+  %lo22 = load i8*, i8** %46, align 8
-  %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1
+  %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1
-  %hi23 = load i64, i64* %46, align 8
+  %hi23 = load i64, i64* %47, align 8
   store %"char[]" { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.5, i32 0, i32 0), i64 11 }, %"char[]"* %taddr24, align 8
-  %47 = bitcast %"char[]"* %taddr24 to { i8*, i64 }*
+  %48 = bitcast %"char[]"* %taddr24 to { i8*, i64 }*
-  %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 0
+  %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 0
-  %lo25 = load i8*, i8** %48, align 8
+  %lo25 = load i8*, i8** %49, align 8
-  %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 1
+  %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 1
-  %hi26 = load i64, i64* %49, align 8
+  %hi26 = load i64, i64* %50, align 8
-  %50 = call i8 @test_contains(i8* %lo22, i64 %hi23, i8* %lo25, i64 %hi26)
+  %51 = call i8 @test_contains(i8* %lo22, i64 %hi23, i8* %lo25, i64 %hi26)
-  %51 = trunc i8 %50 to i1
+  %52 = trunc i8 %51 to i1
-  br i1 %51, label %if.then27, label %if.exit49
+  br i1 %52, label %if.then27, label %if.exit49
 
 if.then27:                                        ; preds = %if.exit21
-  %52 = getelementptr inbounds %Doc, %Doc* %literal29, i32 0, i32 0
+  %53 = getelementptr inbounds %Doc, %Doc* %literal29, i32 0, i32 0
-  %53 = bitcast %Head* %literal32 to %"char[]"**
+  %54 = bitcast %Head* %literal32 to %"char[]"**
-  store %"char[]"* null, %"char[]"** %53, align 8
+  store %"char[]"* null, %"char[]"** %54, align 8
-  %54 = getelementptr inbounds %Head, %Head* %literal32, i32 0, i32 0
+  %55 = getelementptr inbounds %Head, %Head* %literal32, i32 0, i32 0
   store %"char[]" zeroinitializer, %"char[]"* %value34, align 8
-  %55 = call i8* @std_core_mem_malloc(i64 16) #2
+  %56 = call i8* @std_core_mem_malloc(i64 16) #2
-  %ptrptr36 = bitcast i8* %55 to %"char[]"*
+  %ptrptr36 = bitcast i8* %56 to %"char[]"*
   store %"char[]"* %ptrptr36, %"char[]"** %temp35, align 8
-  %56 = load %"char[]"*, %"char[]"** %temp35, align 8
+  %57 = load %"char[]"*, %"char[]"** %temp35, align 8
-  %not37 = icmp eq %"char[]"* %56, null
+  %not37 = icmp eq %"char[]"* %57, null
   br i1 %not37, label %if.then38, label %if.exit39
 
 if.then38:                                        ; preds = %if.then27
@@ -432,26 +433,27 @@ if.then38:                                        ; preds = %if.then27
   br label %guard_block40
 
 if.exit39:                                        ; preds = %if.then27
-  %57 = load %"char[]"*, %"char[]"** %temp35, align 8
+  %58 = load %"char[]"*, %"char[]"** %temp35, align 8
-  %58 = bitcast %"char[]"* %57 to i8*
+  %59 = bitcast %"char[]"* %58 to i8*
-  %59 = bitcast %"char[]"* %value34 to i8*
+  %60 = bitcast %"char[]"* %value34 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %58, i8* align 8 %59, i32 16, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %59, i8* align 8 %60, i32 16, i1 false)
   br label %noerr_block41
 
 guard_block40:                                    ; preds = %if.then38
-  %60 = load i64, i64* %error_var33, align 8
+  %61 = load i64, i64* %error_var33, align 8
-  ret i64 %60
+  ret i64 %61
 
 noerr_block41:                                    ; preds = %if.exit39
-  %61 = load %"char[]"*, %"char[]"** %temp35, align 8
+  %62 = load %"char[]"*, %"char[]"** %temp35, align 8
-  store %"char[]"* %61, %"char[]"** %54, align 8
+  store %"char[]"* %62, %"char[]"** %55, align 8
-  %62 = load %Head, %Head* %literal32, align 8
+  %63 = bitcast %Head* %value31 to i8*
-  store %Head %62, %Head* %value31, align 8
+  %64 = bitcast %Head* %literal32 to i8*
-  %63 = call i8* @std_core_mem_malloc(i64 8) #2
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %63, i8* align 8 %64, i32 8, i1 false)
-  %ptrptr43 = bitcast i8* %63 to %Head*
+  %65 = call i8* @std_core_mem_malloc(i64 8) #2
+  %ptrptr43 = bitcast i8* %65 to %Head*
   store %Head* %ptrptr43, %Head** %temp42, align 8
-  %64 = load %Head*, %Head** %temp42, align 8
+  %66 = load %Head*, %Head** %temp42, align 8
-  %not44 = icmp eq %Head* %64, null
+  %not44 = icmp eq %Head* %66, null
   br i1 %not44, label %if.then45, label %if.exit46
 
 if.then45:                                        ; preds = %noerr_block41
@@ -459,74 +461,74 @@ if.then45:                                        ; preds = %noerr_block41
   br label %guard_block47
 
 if.exit46:                                        ; preds = %noerr_block41
-  %65 = load %Head*, %Head** %temp42, align 8
+  %67 = load %Head*, %Head** %temp42, align 8
-  %66 = bitcast %Head* %65 to i8*
+  %68 = bitcast %Head* %67 to i8*
-  %67 = bitcast %Head* %value31 to i8*
+  %69 = bitcast %Head* %value31 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %66, i8* align 8 %67, i32 8, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %68, i8* align 8 %69, i32 8, i1 false)
   br label %noerr_block48
 
 guard_block47:                                    ; preds = %if.then45
-  %68 = load i64, i64* %error_var30, align 8
+  %70 = load i64, i64* %error_var30, align 8
-  ret i64 %68
+  ret i64 %70
 
 noerr_block48:                                    ; preds = %if.exit46
-  %69 = load %Head*, %Head** %temp42, align 8
+  %71 = load %Head*, %Head** %temp42, align 8
-  store %Head* %69, %Head** %52, align 8
+  store %Head* %71, %Head** %53, align 8
-  %70 = bitcast %Doc* %0 to i8*
+  %72 = bitcast %Doc* %0 to i8*
-  %71 = bitcast %Doc* %literal29 to i8*
+  %73 = bitcast %Doc* %literal29 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %70, i8* align 8 %71, i32 8, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %72, i8* align 8 %73, i32 8, i1 false)
   ret i64 0
 
 if.exit49:                                        ; preds = %if.exit21
-  %72 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1
+  %74 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1
-  %73 = load i64, i64* %72, align 8
+  %75 = load i64, i64* %74, align 8
-  %uisitrunc = trunc i64 %73 to i32
+  %uisitrunc = trunc i64 %75 to i32
-  %74 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0
+  %76 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0
-  %75 = load i8*, i8** %74, align 8
+  %77 = load i8*, i8** %76, align 8
-  %76 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i32 0, i32 0), i32 %uisitrunc, i8* %75)
+  %78 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* null, i64 0, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i32 0, i32 0), i32 %uisitrunc, i8* %77)
-  store i32 %76, i32* %len, align 4
+  store i32 %78, i32* %len, align 4
-  %77 = load i32, i32* %len, align 4
+  %79 = load i32, i32* %len, align 4
-  %siuiext = sext i32 %77 to i64
+  %siuiext = sext i32 %79 to i64
   %add = add i64 %siuiext, 1
-  %78 = call i8* @std_core_mem_malloc(i64 %add) #2
+  %80 = call i8* @std_core_mem_malloc(i64 %add) #2
-  store i8* %78, i8** %str, align 8
+  store i8* %80, i8** %str, align 8
-  %79 = load i8*, i8** %str, align 8
+  %81 = load i8*, i8** %str, align 8
-  %not50 = icmp eq i8* %79, null
+  %not50 = icmp eq i8* %81, null
   br i1 %not50, label %if.then51, label %if.exit52
 
 if.then51:                                        ; preds = %if.exit49
   ret i64 ptrtoint (%.fault* @"test_ReadError$OUT_OF_MEMORY" to i64)
 
 if.exit52:                                        ; preds = %if.exit49
-  %80 = load i8*, i8** %str, align 8
+  %82 = load i8*, i8** %str, align 8
-  %81 = load i32, i32* %len, align 4
+  %83 = load i32, i32* %len, align 4
-  %siuiext53 = sext i32 %81 to i64
+  %siuiext53 = sext i32 %83 to i64
   %add54 = add i64 %siuiext53, 1
-  %82 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1
+  %84 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1
-  %83 = load i64, i64* %82, align 8
+  %85 = load i64, i64* %84, align 8
-  %uisitrunc55 = trunc i64 %83 to i32
+  %uisitrunc55 = trunc i64 %85 to i32
-  %84 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0
+  %86 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0
-  %85 = load i8*, i8** %84, align 8
+  %87 = load i8*, i8** %86, align 8
-  %86 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %80, i64 %add54, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i32 0, i32 0), i32 %uisitrunc55, i8* %85)
+  %88 = call i32 (i8*, i64, i8*, ...) @snprintf(i8* %82, i64 %add54, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i32 0, i32 0), i32 %uisitrunc55, i8* %87)
-  %87 = getelementptr inbounds %Doc, %Doc* %literal57, i32 0, i32 0
+  %89 = getelementptr inbounds %Doc, %Doc* %literal57, i32 0, i32 0
-  %88 = bitcast %Head* %literal60 to %"char[]"**
+  %90 = bitcast %Head* %literal60 to %"char[]"**
-  store %"char[]"* null, %"char[]"** %88, align 8
+  store %"char[]"* null, %"char[]"** %90, align 8
-  %89 = getelementptr inbounds %Head, %Head* %literal60, i32 0, i32 0
+  %91 = getelementptr inbounds %Head, %Head* %literal60, i32 0, i32 0
-  %90 = load i8*, i8** %str, align 8
+  %92 = load i8*, i8** %str, align 8
-  %91 = load i32, i32* %len, align 4
+  %93 = load i32, i32* %len, align 4
-  %sub = sub i32 %91, 1
+  %sub = sub i32 %93, 1
   %sisiext = sext i32 %sub to i64
-  %92 = add i64 %sisiext, 1
+  %94 = add i64 %sisiext, 1
-  %size = sub i64 %92, 0
+  %size = sub i64 %94, 0
-  %ptroffset = getelementptr inbounds i8, i8* %90, i64 0
+  %ptroffset = getelementptr inbounds i8, i8* %92, i64 0
-  %93 = insertvalue %"char[]" undef, i8* %ptroffset, 0
+  %95 = insertvalue %"char[]" undef, i8* %ptroffset, 0
-  %94 = insertvalue %"char[]" %93, i64 %size, 1
+  %96 = insertvalue %"char[]" %95, i64 %size, 1
-  store %"char[]" %94, %"char[]"* %value62, align 8
+  store %"char[]" %96, %"char[]"* %value62, align 8
-  %95 = call i8* @std_core_mem_malloc(i64 16) #2
+  %97 = call i8* @std_core_mem_malloc(i64 16) #2
-  %ptrptr64 = bitcast i8* %95 to %"char[]"*
+  %ptrptr64 = bitcast i8* %97 to %"char[]"*
   store %"char[]"* %ptrptr64, %"char[]"** %temp63, align 8
-  %96 = load %"char[]"*, %"char[]"** %temp63, align 8
+  %98 = load %"char[]"*, %"char[]"** %temp63, align 8
-  %not65 = icmp eq %"char[]"* %96, null
+  %not65 = icmp eq %"char[]"* %98, null
   br i1 %not65, label %if.then66, label %if.exit67
 
 if.then66:                                        ; preds = %if.exit52
@@ -534,26 +536,27 @@ if.then66:                                        ; preds = %if.exit52
   br label %guard_block68
 
 if.exit67:                                        ; preds = %if.exit52
-  %97 = load %"char[]"*, %"char[]"** %temp63, align 8
+  %99 = load %"char[]"*, %"char[]"** %temp63, align 8
-  %98 = bitcast %"char[]"* %97 to i8*
+  %100 = bitcast %"char[]"* %99 to i8*
-  %99 = bitcast %"char[]"* %value62 to i8*
+  %101 = bitcast %"char[]"* %value62 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %98, i8* align 8 %99, i32 16, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %100, i8* align 8 %101, i32 16, i1 false)
   br label %noerr_block69
 
 guard_block68:                                    ; preds = %if.then66
-  %100 = load i64, i64* %error_var61, align 8
+  %102 = load i64, i64* %error_var61, align 8
-  ret i64 %100
+  ret i64 %102
 
 noerr_block69:                                    ; preds = %if.exit67
-  %101 = load %"char[]"*, %"char[]"** %temp63, align 8
+  %103 = load %"char[]"*, %"char[]"** %temp63, align 8
-  store %"char[]"* %101, %"char[]"** %89, align 8
+  store %"char[]"* %103, %"char[]"** %91, align 8
-  %102 = load %Head, %Head* %literal60, align 8
+  %104 = bitcast %Head* %value59 to i8*
-  store %Head %102, %Head* %value59, align 8
+  %105 = bitcast %Head* %literal60 to i8*
-  %103 = call i8* @std_core_mem_malloc(i64 8) #2
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %104, i8* align 8 %105, i32 8, i1 false)
-  %ptrptr71 = bitcast i8* %103 to %Head*
+  %106 = call i8* @std_core_mem_malloc(i64 8) #2
+  %ptrptr71 = bitcast i8* %106 to %Head*
   store %Head* %ptrptr71, %Head** %temp70, align 8
-  %104 = load %Head*, %Head** %temp70, align 8
+  %107 = load %Head*, %Head** %temp70, align 8
-  %not72 = icmp eq %Head* %104, null
+  %not72 = icmp eq %Head* %107, null
   br i1 %not72, label %if.then73, label %if.exit74
 
 if.then73:                                        ; preds = %noerr_block69
@@ -561,22 +564,22 @@ if.then73:                                        ; preds = %noerr_block69
   br label %guard_block75
 
 if.exit74:                                        ; preds = %noerr_block69
-  %105 = load %Head*, %Head** %temp70, align 8
+  %108 = load %Head*, %Head** %temp70, align 8
-  %106 = bitcast %Head* %105 to i8*
+  %109 = bitcast %Head* %108 to i8*
-  %107 = bitcast %Head* %value59 to i8*
+  %110 = bitcast %Head* %value59 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %106, i8* align 8 %107, i32 8, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %109, i8* align 8 %110, i32 8, i1 false)
   br label %noerr_block76
 
 guard_block75:                                    ; preds = %if.then73
-  %108 = load i64, i64* %error_var58, align 8
+  %111 = load i64, i64* %error_var58, align 8
-  ret i64 %108
+  ret i64 %111
 
 noerr_block76:                                    ; preds = %if.exit74
-  %109 = load %Head*, %Head** %temp70, align 8
+  %112 = load %Head*, %Head** %temp70, align 8
-  store %Head* %109, %Head** %87, align 8
+  store %Head* %112, %Head** %89, align 8
-  %110 = bitcast %Doc* %0 to i8*
+  %113 = bitcast %Doc* %0 to i8*
-  %111 = bitcast %Doc* %literal57 to i8*
+  %114 = bitcast %Doc* %literal57 to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %110, i8* align 8 %111, i32 8, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %113, i8* align 8 %114, i32 8, i1 false)
   ret i64 0
 }
 
@@ -836,7 +839,7 @@ entry:
   store i64 %9, i64* %anon1, align 8
   br label %loop.cond
 
-loop.cond:                                        ; preds = %phi_block11, %entry
+loop.cond:                                        ; preds = %phi_block12, %entry
   %10 = load i64, i64* %anon, align 8
   %11 = load i64, i64* %anon1, align 8
   %lt = icmp ult i64 %10, %11
@@ -914,40 +917,40 @@ after_check:                                      ; preds = %cond.phi
   br label %after_assign
 
 after_assign:                                     ; preds = %after_check, %assign_optional
-  %47 = load i64, i64* %has_title.f, align 8
+  %optval = load i64, i64* %has_title.f, align 8
-  %not_err5 = icmp eq i64 %47, 0
+  %not_err5 = icmp eq i64 %optval, 0
   br i1 %not_err5, label %after_check6, label %else_block
 
 after_check6:                                     ; preds = %after_assign
-  %48 = load i8, i8* %has_title, align 1
+  %47 = load i8, i8* %has_title, align 1
-  %49 = call i8* @test_bool_to_string(i8 %48)
+  %48 = call i8* @test_bool_to_string(i8 %47)
   br label %phi_block
 
 else_block:                                       ; preds = %after_assign
-  %50 = load i64, i64* %has_title.f, align 8
+  %49 = load i64, i64* %has_title.f, align 8
-  %51 = call i8* @test_nameFromError(i64 %50)
+  %50 = call i8* @test_nameFromError(i64 %49)
   br label %phi_block
 
 phi_block:                                        ; preds = %else_block, %after_check6
-  %val7 = phi i8* [ %49, %after_check6 ], [ %51, %else_block ]
+  %val7 = phi i8* [ %48, %after_check6 ], [ %50, %else_block ]
-  %52 = load i64, i64* %has_title.f, align 8
+  %optval8 = load i64, i64* %has_title.f, align 8
-  %not_err8 = icmp eq i64 %52, 0
+  %not_err9 = icmp eq i64 %optval8, 0
-  br i1 %not_err8, label %after_check9, label %else_block10
+  br i1 %not_err9, label %after_check10, label %else_block11
 
-after_check9:                                     ; preds = %phi_block
+after_check10:                                    ; preds = %phi_block
-  %53 = load i8, i8* %has_title, align 1
+  %51 = load i8, i8* %has_title, align 1
-  %54 = trunc i8 %53 to i1
+  %52 = trunc i8 %51 to i1
-  br label %phi_block11
+  br label %phi_block12
 
-else_block10:                                     ; preds = %phi_block
+else_block11:                                     ; preds = %phi_block
-  br label %phi_block11
+  br label %phi_block12
 
-phi_block11:                                      ; preds = %else_block10, %after_check9
+phi_block12:                                      ; preds = %else_block11, %after_check10
-  %val12 = phi i1 [ %54, %after_check9 ], [ false, %else_block10 ]
+  %val13 = phi i1 [ %52, %after_check10 ], [ false, %else_block11 ]
-  %ternary = select i1 %val12, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.27, i32 0, i32 0)
+  %ternary = select i1 %val13, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i32 0, i32 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.27, i32 0, i32 0)
-  %55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i32 0, i32 0), i8* %val7, i8* %ternary)
+  %53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i32 0, i32 0), i8* %val7, i8* %ternary)
-  %56 = load i64, i64* %anon, align 8
+  %54 = load i64, i64* %anon, align 8
-  %add = add i64 %56, 1
+  %add = add i64 %54, 1
   store i64 %add, i64* %anon, align 8
   br label %loop.cond
 

test/test_suite/errors/failable_inits.c3t

@@ -41,25 +41,25 @@ entry:
   %error_var = alloca i64, align 8
   %reterr = alloca i64, align 8
   store i64 ptrtoint (%.fault* @"test_Foo$MY_VAL1" to i64), i64* %x.f, align 8
-  %0 = load i64, i64* %x.f, align 8
+  %optval = load i64, i64* %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, i64* %error_var, align 8
+  store i64 %optval, i64* %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %1 = load i64, i64* %error_var, align 8
+  %0 = load i64, i64* %error_var, align 8
-  ret i64 %1
+  ret i64 %0
 
 noerr_block:                                      ; preds = %after_check
-  %2 = bitcast %Bar* %y to i8*
+  %1 = bitcast %Bar* %y to i8*
-  %3 = bitcast %Bar* %x to i8*
+  %2 = bitcast %Bar* %x to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %2, i8* align 4 %3, i32 4, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %1, i8* align 4 %2, i32 4, i1 false)
   ret i64 0
 }
 
@@ -74,25 +74,25 @@ entry:
   %0 = bitcast %Bar* %x to i32*
   store i32 0, i32* %0, align 4
   store i64 0, i64* %x.f, align 8
-  %1 = load i64, i64* %x.f, align 8
+  %optval = load i64, i64* %x.f, align 8
-  %not_err = icmp eq i64 %1, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %1, i64* %error_var, align 8
+  store i64 %optval, i64* %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %2 = load i64, i64* %error_var, align 8
+  %1 = load i64, i64* %error_var, align 8
-  ret i64 %2
+  ret i64 %1
 
 noerr_block:                                      ; preds = %after_check
-  %3 = bitcast %Bar* %y to i8*
+  %2 = bitcast %Bar* %y to i8*
-  %4 = bitcast %Bar* %x to i8*
+  %3 = bitcast %Bar* %x to i8*
-  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %3, i8* align 4 %4, i32 4, i1 false)
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %2, i8* align 4 %3, i32 4, i1 false)
   ret i64 0
 }
 

test/test_suite/errors/failable_taddr_and_access.c3t

@@ -45,77 +45,77 @@ entry:
   %w = alloca %Foo*, align 8
   %w.f = alloca i64, align 8
   %literal = alloca %Foo, align 4
-  %literal5 = alloca %Foo, align 4
+  %literal6 = alloca %Foo, align 4
   store i32 2, i32* %z, align 4
   store i64 0, i64* %z.f, align 8
   %0 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 0
-  %1 = load i64, i64* %z.f, align 8
+  %optval = load i64, i64* %z.f, align 8
-  %not_err = icmp eq i64 %1, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %1, i64* %w.f, align 8
+  store i64 %optval, i64* %w.f, align 8
   br label %after_assign
 
 after_check:                                      ; preds = %entry
-  %2 = load i32, i32* %z, align 4
+  %1 = load i32, i32* %z, align 4
-  store i32 %2, i32* %0, align 4
+  store i32 %1, i32* %0, align 4
-  %3 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1
+  %2 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1
-  store i32 0, i32* %3, align 4
+  store i32 0, i32* %2, align 4
   store %Foo* %literal, %Foo** %w, align 8
   store i64 0, i64* %w.f, align 8
   br label %after_assign
 
 after_assign:                                     ; preds = %after_check, %assign_optional
-  %4 = load i64, i64* %w.f, align 8
+  %optval1 = load i64, i64* %w.f, align 8
-  %not_err1 = icmp eq i64 %4, 0
+  %not_err2 = icmp eq i64 %optval1, 0
-  br i1 %not_err1, label %after_check2, label %voiderr
+  br i1 %not_err2, label %after_check3, label %voiderr
 
-after_check2:                                     ; preds = %after_assign
+after_check3:                                     ; preds = %after_assign
-  %5 = load %Foo*, %Foo** %w, align 8
+  %3 = load %Foo*, %Foo** %w, align 8
-  %6 = getelementptr inbounds %Foo, %Foo* %5, i32 0, i32 0
+  %4 = getelementptr inbounds %Foo, %Foo* %3, i32 0, i32 0
-  %7 = load i32, i32* %6, align 8
+  %5 = load i32, i32* %4, align 8
-  %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %7)
+  %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %5)
   br label %voiderr
 
-voiderr:                                          ; preds = %after_check2, %after_assign
+voiderr:                                          ; preds = %after_check3, %after_assign
   store i64 ptrtoint (%.fault* @"test_MyErr$FOO" to i64), i64* %z.f, align 8
-  br label %voiderr4
+  br label %voiderr5
 
-voiderr4:                                         ; preds = %voiderr
+voiderr5:                                         ; preds = %voiderr
-  %9 = getelementptr inbounds %Foo, %Foo* %literal5, i32 0, i32 0
+  %7 = getelementptr inbounds %Foo, %Foo* %literal6, i32 0, i32 0
-  %10 = load i64, i64* %z.f, align 8
+  %optval7 = load i64, i64* %z.f, align 8
-  %not_err6 = icmp eq i64 %10, 0
+  %not_err8 = icmp eq i64 %optval7, 0
-  br i1 %not_err6, label %after_check8, label %assign_optional7
+  br i1 %not_err8, label %after_check10, label %assign_optional9
 
-assign_optional7:                                 ; preds = %voiderr4
+assign_optional9:                                 ; preds = %voiderr5
-  store i64 %10, i64* %w.f, align 8
+  store i64 %optval7, i64* %w.f, align 8
-  br label %after_assign9
+  br label %after_assign11
 
-after_check8:                                     ; preds = %voiderr4
+after_check10:                                    ; preds = %voiderr5
-  %11 = load i32, i32* %z, align 4
+  %8 = load i32, i32* %z, align 4
-  store i32 %11, i32* %9, align 4
+  store i32 %8, i32* %7, align 4
-  %12 = getelementptr inbounds %Foo, %Foo* %literal5, i32 0, i32 1
+  %9 = getelementptr inbounds %Foo, %Foo* %literal6, i32 0, i32 1
-  store i32 0, i32* %12, align 4
+  store i32 0, i32* %9, align 4
-  store %Foo* %literal5, %Foo** %w, align 8
+  store %Foo* %literal6, %Foo** %w, align 8
   store i64 0, i64* %w.f, align 8
-  br label %after_assign9
+  br label %after_assign11
 
-after_assign9:                                    ; preds = %after_check8, %assign_optional7
+after_assign11:                                   ; preds = %after_check10, %assign_optional9
-  br label %voiderr10
+  br label %voiderr12
 
-voiderr10:                                        ; preds = %after_assign9
+voiderr12:                                        ; preds = %after_assign11
-  %13 = load i64, i64* %w.f, align 8
+  %optval13 = load i64, i64* %w.f, align 8
-  %not_err11 = icmp eq i64 %13, 0
+  %not_err14 = icmp eq i64 %optval13, 0
-  br i1 %not_err11, label %after_check12, label %voiderr13
+  br i1 %not_err14, label %after_check15, label %voiderr16
 
-after_check12:                                    ; preds = %voiderr10
+after_check15:                                    ; preds = %voiderr12
-  %14 = load %Foo*, %Foo** %w, align 8
+  %10 = load %Foo*, %Foo** %w, align 8
-  %15 = getelementptr inbounds %Foo, %Foo* %14, i32 0, i32 0
+  %11 = getelementptr inbounds %Foo, %Foo* %10, i32 0, i32 0
-  %16 = load i32, i32* %15, align 8
+  %12 = load i32, i32* %11, align 8
-  %17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i32 0, i32 0), i32 %16)
+  %13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i32 0, i32 0), i32 %12)
-  br label %voiderr13
+  br label %voiderr16
 
-voiderr13:                                        ; preds = %after_check12, %voiderr10
+voiderr16:                                        ; preds = %after_check15, %voiderr12
   ret void
 }

test/test_suite/errors/or_err_bool.c3t

@@ -16,19 +16,19 @@ entry:
   %x.f = alloca i64, align 8
   store i8 0, i8* %x, align 1
   store i64 0, i64* %x.f, align 8
-  %0 = load i64, i64* %x.f, align 8
+  %optval = load i64, i64* %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %else_block
 
 after_check:                                      ; preds = %entry
-  %1 = load i8, i8* %x, align 1
+  %0 = load i8, i8* %x, align 1
-  %2 = trunc i8 %1 to i1
+  %1 = trunc i8 %0 to i1
   br label %phi_block
 
 else_block:                                       ; preds = %entry
   br label %phi_block
 
 phi_block:                                        ; preds = %else_block, %after_check
-  %val = phi i1 [ %2, %after_check ], [ true, %else_block ]
+  %val = phi i1 [ %1, %after_check ], [ true, %else_block ]
   ret void
 }

test/test_suite/errors/rethrow.c3t

@@ -14,20 +14,20 @@ fn void! test()
   %reterr = alloca i64, align 8
   store i64 0, i64* %i.f, align 8
   store i32 0, i32* %i, align 4
-  %0 = load i64, i64* %i.f, align 8
+  %optval = load i64, i64* %i.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, i64* %error_var, align 8
+  store i64 %optval, i64* %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %1 = load i64, i64* %error_var, align 8
+  %0 = load i64, i64* %error_var, align 8
-  ret i64 %1
+  ret i64 %0
 
 noerr_block:                                      ; preds = %after_check
   ret i64 0

test/test_suite/errors/rethrow_mingw.c3t

@@ -18,20 +18,20 @@ entry:
   %reterr = alloca i64, align 8
   store i64 0, i64* %i.f, align 8
   store i32 0, i32* %i, align 4
-  %0 = load i64, i64* %i.f, align 8
+  %optval = load i64, i64* %i.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, i64* %error_var, align 8
+  store i64 %optval, i64* %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %1 = load i64, i64* %error_var, align 8
+  %0 = load i64, i64* %error_var, align 8
-  ret i64 %1
+  ret i64 %0
 
 noerr_block:                                      ; preds = %after_check
   ret i64 0

test/test_suite/errors/try_assign.c3t

@@ -43,13 +43,13 @@ entry:
   store i64 0, i64* %w.f, align 8
   store i32 0, i32* %w, align 4
   store i32 1, i32* %gh, align 4
-  %0 = load i64, i64* %z.f, align 8
+  %optval = load i64, i64* %z.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %catch_landing
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, i32* %z, align 4
+  %0 = load i32, i32* %z, align 4
-  store i32 %1, i32* %x, align 4
+  store i32 %0, i32* %x, align 4
   br label %phi_try_catch
 
 catch_landing:                                    ; preds = %entry
@@ -60,93 +60,93 @@ phi_try_catch:                                    ; preds = %catch_landing, %aft
   br i1 %val, label %chain_next, label %fail_chain
 
 chain_next:                                       ; preds = %phi_try_catch
-  %2 = load i64, i64* %w.f, align 8
+  %optval1 = load i64, i64* %w.f, align 8
-  %not_err1 = icmp eq i64 %2, 0
+  %not_err2 = icmp eq i64 %optval1, 0
-  br i1 %not_err1, label %after_check2, label %catch_landing3
+  br i1 %not_err2, label %after_check3, label %catch_landing4
 
-after_check2:                                     ; preds = %chain_next
+after_check3:                                     ; preds = %chain_next
-  %3 = load i32, i32* %w, align 4
+  %1 = load i32, i32* %w, align 4
-  store i32 %3, i32* %gh, align 4
+  store i32 %1, i32* %gh, align 4
-  br label %phi_try_catch4
+  br label %phi_try_catch5
 
-catch_landing3:                                   ; preds = %chain_next
+catch_landing4:                                   ; preds = %chain_next
-  br label %phi_try_catch4
+  br label %phi_try_catch5
 
-phi_try_catch4:                                   ; preds = %catch_landing3, %after_check2
+phi_try_catch5:                                   ; preds = %catch_landing4, %after_check3
-  %val5 = phi i1 [ true, %after_check2 ], [ false, %catch_landing3 ]
+  %val6 = phi i1 [ true, %after_check3 ], [ false, %catch_landing4 ]
-  br i1 %val5, label %chain_next6, label %fail_chain
+  br i1 %val6, label %chain_next7, label %fail_chain
 
-chain_next6:                                      ; preds = %phi_try_catch4
+chain_next7:                                      ; preds = %phi_try_catch5
   br label %end_chain
 
-fail_chain:                                       ; preds = %phi_try_catch4, %phi_try_catch
+fail_chain:                                       ; preds = %phi_try_catch5, %phi_try_catch
   br label %end_chain
 
-end_chain:                                        ; preds = %fail_chain, %chain_next6
+end_chain:                                        ; preds = %fail_chain, %chain_next7
-  %chain.phi = phi i1 [ true, %chain_next6 ], [ false, %fail_chain ]
+  %chain.phi = phi i1 [ true, %chain_next7 ], [ false, %fail_chain ]
   br i1 %chain.phi, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_chain
-  %4 = load i32, i32* %x, align 4
+  %2 = load i32, i32* %x, align 4
-  %5 = load i32, i32* %gh, align 4
+  %3 = load i32, i32* %gh, align 4
-  %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i32 %4, i32 %5)
+  %4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i32 %2, i32 %3)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_chain
-  %7 = load i64, i64* %z.f, align 8
+  %optval8 = load i64, i64* %z.f, align 8
-  %not_err7 = icmp eq i64 %7, 0
+  %not_err9 = icmp eq i64 %optval8, 0
-  br i1 %not_err7, label %after_check8, label %catch_landing11
+  br i1 %not_err9, label %after_check10, label %catch_landing14
 
-after_check8:                                     ; preds = %if.exit
+after_check10:                                    ; preds = %if.exit
-  %8 = load i32, i32* %z, align 4
+  %5 = load i32, i32* %z, align 4
-  %9 = load i64, i64* %w.f, align 8
+  %optval11 = load i64, i64* %w.f, align 8
-  %not_err9 = icmp eq i64 %9, 0
+  %not_err12 = icmp eq i64 %optval11, 0
-  br i1 %not_err9, label %after_check10, label %catch_landing11
+  br i1 %not_err12, label %after_check13, label %catch_landing14
 
-after_check10:                                    ; preds = %after_check8
+after_check13:                                    ; preds = %after_check10
-  %10 = load i32, i32* %w, align 4
+  %6 = load i32, i32* %w, align 4
-  %add = add i32 %8, %10
+  %add = add i32 %5, %6
   store i32 %add, i32* %x, align 4
-  br label %phi_try_catch12
+  br label %phi_try_catch15
 
-catch_landing11:                                  ; preds = %after_check8, %if.exit
+catch_landing14:                                  ; preds = %after_check10, %if.exit
-  br label %phi_try_catch12
+  br label %phi_try_catch15
 
-phi_try_catch12:                                  ; preds = %catch_landing11, %after_check10
+phi_try_catch15:                                  ; preds = %catch_landing14, %after_check13
-  %val13 = phi i1 [ true, %after_check10 ], [ false, %catch_landing11 ]
+  %val16 = phi i1 [ true, %after_check13 ], [ false, %catch_landing14 ]
-  br i1 %val13, label %if.then14, label %if.exit15
+  br i1 %val16, label %if.then17, label %if.exit18
 
-if.then14:                                        ; preds = %phi_try_catch12
+if.then17:                                        ; preds = %phi_try_catch15
-  %11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0))
+  %7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0))
-  br label %if.exit15
+  br label %if.exit18
 
-if.exit15:                                        ; preds = %if.then14, %phi_try_catch12
+if.exit18:                                        ; preds = %if.then17, %phi_try_catch15
   store i64 0, i64* %e, align 8
   br label %testblock
 
-testblock:                                        ; preds = %if.exit15
+testblock:                                        ; preds = %if.exit18
-  %12 = load i64, i64* %z.f, align 8
+  %optval19 = load i64, i64* %z.f, align 8
-  %not_err16 = icmp eq i64 %12, 0
+  %not_err20 = icmp eq i64 %optval19, 0
-  br i1 %not_err16, label %after_check17, label %assign_optional
+  br i1 %not_err20, label %after_check21, label %assign_optional
 
 assign_optional:                                  ; preds = %testblock
-  store i64 %12, i64* %e, align 8
+  store i64 %optval19, i64* %e, align 8
   br label %end_block
 
-after_check17:                                    ; preds = %testblock
+after_check21:                                    ; preds = %testblock
   store i64 0, i64* %e, align 8
   br label %end_block
 
-end_block:                                        ; preds = %after_check17, %assign_optional
+end_block:                                        ; preds = %after_check21, %assign_optional
-  %13 = load i64, i64* %e, align 8
+  %8 = load i64, i64* %e, align 8
-  %neq = icmp ne i64 %13, 0
+  %neq = icmp ne i64 %8, 0
-  br i1 %neq, label %if.then18, label %if.exit19
+  br i1 %neq, label %if.then22, label %if.exit23
 
-if.then18:                                        ; preds = %end_block
+if.then22:                                        ; preds = %end_block
-  %14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0))
+  %9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0))
-  br label %if.exit19
+  br label %if.exit23
 
-if.exit19:                                        ; preds = %if.then18, %end_block
+if.exit23:                                        ; preds = %if.then22, %end_block
   ret void
 }
 

test/test_suite/errors/try_catch_if.c3t

@@ -55,24 +55,24 @@ entry:
   br label %testblock
 
 testblock:                                        ; preds = %entry
-  %0 = load i64, i64* %a.f, align 8
+  %optval = load i64, i64* %a.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %testblock
-  store i64 %0, i64* %err, align 8
+  store i64 %optval, i64* %err, align 8
   br label %end_block
 
 after_check:                                      ; preds = %testblock
   br label %testblock1
 
 testblock1:                                       ; preds = %after_check
-  %1 = call i64 @try_catch_if_tester(i32* %retparam)
+  %0 = call i64 @try_catch_if_tester(i32* %retparam)
-  %not_err2 = icmp eq i64 %1, 0
+  %not_err2 = icmp eq i64 %0, 0
   br i1 %not_err2, label %after_check4, label %assign_optional3
 
 assign_optional3:                                 ; preds = %testblock1
-  store i64 %1, i64* %err, align 8
+  store i64 %0, i64* %err, align 8
   br label %end_block
 
 after_check4:                                     ; preds = %testblock1
@@ -80,17 +80,17 @@ after_check4:                                     ; preds = %testblock1
   br label %end_block
 
 end_block:                                        ; preds = %after_check4, %assign_optional3, %assign_optional
-  %2 = load i64, i64* %err, align 8
+  %1 = load i64, i64* %err, align 8
-  %neq = icmp ne i64 %2, 0
+  %neq = icmp ne i64 %1, 0
   br i1 %neq, label %if.then, label %if.else
 
 if.then:                                          ; preds = %end_block
-  %3 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i32 0, i32 0))
+  %2 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i32 0, i32 0))
   br label %if.exit
 
 if.else:                                          ; preds = %end_block
-  %4 = load i32, i32* %a, align 4
+  %3 = load i32, i32* %a, align 4
-  %5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i32 %4)
+  %4 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i32 %3)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.else, %if.then

test/test_suite/errors/try_with_unwrapper.c3t

@@ -74,13 +74,13 @@ entry:
   store i32 11, i32* %a, align 4
   store i64 0, i64* %a.f, align 8
   store i32 0, i32* %b, align 4
-  %0 = load i64, i64* %a.f, align 8
+  %optval = load i64, i64* %a.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %catch_landing
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, i32* %a, align 4
+  %0 = load i32, i32* %a, align 4
-  store i32 %1, i32* %b, align 4
+  store i32 %0, i32* %b, align 4
   br label %phi_try_catch
 
 catch_landing:                                    ; preds = %entry
@@ -92,13 +92,13 @@ phi_try_catch:                                    ; preds = %catch_landing, %aft
 
 chain_next:                                       ; preds = %phi_try_catch
   store i32 0, i32* %c, align 4
-  %2 = call i64 @try_with_unwrapper_tester(i32* %retparam)
+  %1 = call i64 @try_with_unwrapper_tester(i32* %retparam)
-  %not_err1 = icmp eq i64 %2, 0
+  %not_err1 = icmp eq i64 %1, 0
   br i1 %not_err1, label %after_check2, label %catch_landing3
 
 after_check2:                                     ; preds = %chain_next
-  %3 = load i32, i32* %retparam, align 4
+  %2 = load i32, i32* %retparam, align 4
-  store i32 %3, i32* %c, align 4
+  store i32 %2, i32* %c, align 4
   br label %phi_try_catch4
 
 catch_landing3:                                   ; preds = %chain_next
@@ -119,11 +119,11 @@ end_chain:                                        ; preds = %fail_chain, %chain_
   br i1 %chain.phi, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_chain
-  %4 = load i32, i32* %b, align 4
+  %3 = load i32, i32* %b, align 4
-  %5 = call i32 @try_with_unwrapper_hello(i32 %4)
+  %4 = call i32 @try_with_unwrapper_hello(i32 %3)
-  %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %5)
+  %5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %4)
-  %7 = load i32, i32* %c, align 4
+  %6 = load i32, i32* %c, align 4
-  %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %7)
+  %7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %6)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_chain
@@ -140,13 +140,13 @@ entry:
   store i64 0, i64* %a.f, align 8
   store i32 0, i32* %a, align 4
   store i32 0, i32* %b, align 4
-  %0 = load i64, i64* %a.f, align 8
+  %optval = load i64, i64* %a.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %catch_landing
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, i32* %a, align 4
+  %0 = load i32, i32* %a, align 4
-  store i32 %1, i32* %b, align 4
+  store i32 %0, i32* %b, align 4
   br label %phi_try_catch
 
 catch_landing:                                    ; preds = %entry
@@ -157,9 +157,9 @@ phi_try_catch:                                    ; preds = %catch_landing, %aft
   br i1 %val, label %chain_next, label %fail_chain
 
 chain_next:                                       ; preds = %phi_try_catch
-  %2 = load i32, i32* %b, align 4
+  %1 = load i32, i32* %b, align 4
-  %3 = call i32 @try_with_unwrapper_hello(i32 %2)
+  %2 = call i32 @try_with_unwrapper_hello(i32 %1)
-  %intbool = icmp ne i32 %3, 0
+  %intbool = icmp ne i32 %2, 0
   br i1 %intbool, label %chain_next1, label %fail_chain
 
 chain_next1:                                      ; preds = %chain_next
@@ -173,9 +173,9 @@ end_chain:                                        ; preds = %fail_chain, %chain_
   br i1 %chain.phi, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_chain
-  %4 = load i32, i32* %b, align 4
+  %3 = load i32, i32* %b, align 4
-  %add = add i32 %4, 1
+  %add = add i32 %3, 1
-  %5 = call i32 @try_with_unwrapper_hello(i32 %add)
+  %4 = call i32 @try_with_unwrapper_hello(i32 %add)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_chain

test/test_suite/expressions/chained_ternary.c3t

@@ -55,174 +55,174 @@ cond.phi4:                                        ; preds = %cond.phi, %cond.lhs
   br i1 %not6, label %cond.lhs7, label %cond.rhs8
 
 cond.lhs7:                                        ; preds = %cond.phi4
-  %6 = load i64, i64* %x.f, align 8
+  %optval = load i64, i64* %x.f, align 8
-  %not_err = icmp eq i64 %6, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %cond.lhs7
-  store i64 %6, i64* %y.f, align 8
+  store i64 %optval, i64* %y.f, align 8
   br label %after_assign
 
 after_check:                                      ; preds = %cond.lhs7
-  %7 = load i8*, i8** %x, align 8
+  %6 = load i8*, i8** %x, align 8
   br label %cond.phi9
 
 cond.rhs8:                                        ; preds = %cond.phi4
-  %8 = load i8*, i8** %b, align 8
+  %7 = load i8*, i8** %b, align 8
   br label %cond.phi9
 
 cond.phi9:                                        ; preds = %cond.rhs8, %after_check
-  %val10 = phi i8* [ %7, %after_check ], [ %8, %cond.rhs8 ]
+  %val10 = phi i8* [ %6, %after_check ], [ %7, %cond.rhs8 ]
   store i8* %val10, i8** %y, align 8
   store i64 0, i64* %y.f, align 8
   br label %after_assign
 
 after_assign:                                     ; preds = %cond.phi9, %assign_optional
-  %9 = load i8*, i8** %a, align 8
+  %8 = load i8*, i8** %a, align 8
-  %not11 = icmp eq i8* %9, null
+  %not11 = icmp eq i8* %8, null
   br i1 %not11, label %cond.lhs12, label %cond.rhs13
 
 cond.lhs12:                                       ; preds = %after_assign
-  %10 = load i8*, i8** %b, align 8
+  %9 = load i8*, i8** %b, align 8
-  br label %cond.phi17
+  br label %cond.phi18
 
 cond.rhs13:                                       ; preds = %after_assign
-  %11 = load i64, i64* %x.f, align 8
+  %optval14 = load i64, i64* %x.f, align 8
-  %not_err14 = icmp eq i64 %11, 0
+  %not_err15 = icmp eq i64 %optval14, 0
-  br i1 %not_err14, label %after_check16, label %assign_optional15
+  br i1 %not_err15, label %after_check17, label %assign_optional16
 
-assign_optional15:                                ; preds = %cond.rhs13
+assign_optional16:                                ; preds = %cond.rhs13
-  store i64 %11, i64* %y.f, align 8
+  store i64 %optval14, i64* %y.f, align 8
-  br label %after_assign19
+  br label %after_assign20
 
-after_check16:                                    ; preds = %cond.rhs13
+after_check17:                                    ; preds = %cond.rhs13
-  %12 = load i8*, i8** %x, align 8
+  %10 = load i8*, i8** %x, align 8
-  br label %cond.phi17
+  br label %cond.phi18
 
-cond.phi17:                                       ; preds = %after_check16, %cond.lhs12
+cond.phi18:                                       ; preds = %after_check17, %cond.lhs12
-  %val18 = phi i8* [ %10, %cond.lhs12 ], [ %12, %after_check16 ]
+  %val19 = phi i8* [ %9, %cond.lhs12 ], [ %10, %after_check17 ]
-  store i8* %val18, i8** %y, align 8
+  store i8* %val19, i8** %y, align 8
   store i64 0, i64* %y.f, align 8
-  br label %after_assign19
+  br label %after_assign20
 
-after_assign19:                                   ; preds = %cond.phi17, %assign_optional15
+after_assign20:                                   ; preds = %cond.phi18, %assign_optional16
   br label %voiderr
 
-voiderr:                                          ; preds = %after_assign19
+voiderr:                                          ; preds = %after_assign20
-  %13 = load i8*, i8** %a, align 8
+  %11 = load i8*, i8** %a, align 8
-  %not20 = icmp eq i8* %13, null
+  %not21 = icmp eq i8* %11, null
-  br i1 %not20, label %cond.lhs21, label %cond.rhs25
+  br i1 %not21, label %cond.lhs22, label %cond.rhs27
 
-cond.lhs21:                                       ; preds = %voiderr
+cond.lhs22:                                       ; preds = %voiderr
-  %14 = load i64, i64* %x.f, align 8
+  %optval23 = load i64, i64* %x.f, align 8
-  %not_err22 = icmp eq i64 %14, 0
+  %not_err24 = icmp eq i64 %optval23, 0
-  br i1 %not_err22, label %after_check24, label %assign_optional23
+  br i1 %not_err24, label %after_check26, label %assign_optional25
 
-assign_optional23:                                ; preds = %cond.lhs21
+assign_optional25:                                ; preds = %cond.lhs22
-  store i64 %14, i64* %y.f, align 8
+  store i64 %optval23, i64* %y.f, align 8
-  br label %after_assign31
+  br label %after_assign34
 
-after_check24:                                    ; preds = %cond.lhs21
+after_check26:                                    ; preds = %cond.lhs22
+  %12 = load i8*, i8** %x, align 8
+  br label %cond.phi32
+
+cond.rhs27:                                       ; preds = %voiderr
+  %optval28 = load i64, i64* %x.f, align 8
+  %not_err29 = icmp eq i64 %optval28, 0
+  br i1 %not_err29, label %after_check31, label %assign_optional30
+
+assign_optional30:                                ; preds = %cond.rhs27
+  store i64 %optval28, i64* %y.f, align 8
+  br label %after_assign34
+
+after_check31:                                    ; preds = %cond.rhs27
+  %13 = load i8*, i8** %x, align 8
+  br label %cond.phi32
+
+cond.phi32:                                       ; preds = %after_check31, %after_check26
+  %val33 = phi i8* [ %12, %after_check26 ], [ %13, %after_check31 ]
+  store i8* %val33, i8** %y, align 8
+  store i64 0, i64* %y.f, align 8
+  br label %after_assign34
+
+after_assign34:                                   ; preds = %cond.phi32, %assign_optional30, %assign_optional25
+  br label %voiderr35
+
+voiderr35:                                        ; preds = %after_assign34
+  %14 = load i8*, i8** %a, align 8
+  %not36 = icmp eq i8* %14, null
+  br i1 %not36, label %cond.lhs37, label %cond.rhs42
+
+cond.lhs37:                                       ; preds = %voiderr35
+  %optval38 = load i64, i64* %x.f, align 8
+  %not_err39 = icmp eq i64 %optval38, 0
+  br i1 %not_err39, label %after_check41, label %assign_optional40
+
+assign_optional40:                                ; preds = %cond.lhs37
+  store i64 %optval38, i64* %y.f, align 8
+  br label %after_assign44
+
+after_check41:                                    ; preds = %cond.lhs37
   %15 = load i8*, i8** %x, align 8
-  br label %cond.phi29
+  br label %cond.phi43
 
-cond.rhs25:                                       ; preds = %voiderr
+cond.rhs42:                                       ; preds = %voiderr35
-  %16 = load i64, i64* %x.f, align 8
+  store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %y.f, align 8
-  %not_err26 = icmp eq i64 %16, 0
+  br label %after_assign44
-  br i1 %not_err26, label %after_check28, label %assign_optional27
 
-assign_optional27:                                ; preds = %cond.rhs25
+cond.phi43:                                       ; preds = %after_check41
-  store i64 %16, i64* %y.f, align 8
+  store i8* %15, i8** %y, align 8
-  br label %after_assign31
+  store i64 0, i64* %y.f, align 8
+  br label %after_assign44
 
-after_check28:                                    ; preds = %cond.rhs25
+after_assign44:                                   ; preds = %cond.phi43, %cond.rhs42, %assign_optional40
+  br label %voiderr45
+
+voiderr45:                                        ; preds = %after_assign44
+  %16 = load i8*, i8** %a, align 8
+  %not46 = icmp eq i8* %16, null
+  br i1 %not46, label %cond.lhs47, label %cond.rhs48
+
+cond.lhs47:                                       ; preds = %voiderr45
+  store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %y.f, align 8
+  br label %after_assign54
+
+cond.rhs48:                                       ; preds = %voiderr45
+  %optval49 = load i64, i64* %x.f, align 8
+  %not_err50 = icmp eq i64 %optval49, 0
+  br i1 %not_err50, label %after_check52, label %assign_optional51
+
+assign_optional51:                                ; preds = %cond.rhs48
+  store i64 %optval49, i64* %y.f, align 8
+  br label %after_assign54
+
+after_check52:                                    ; preds = %cond.rhs48
   %17 = load i8*, i8** %x, align 8
-  br label %cond.phi29
+  br label %cond.phi53
 
-cond.phi29:                                       ; preds = %after_check28, %after_check24
+cond.phi53:                                       ; preds = %after_check52
-  %val30 = phi i8* [ %15, %after_check24 ], [ %17, %after_check28 ]
+  store i8* %17, i8** %y, align 8
-  store i8* %val30, i8** %y, align 8
   store i64 0, i64* %y.f, align 8
-  br label %after_assign31
+  br label %after_assign54
 
-after_assign31:                                   ; preds = %cond.phi29, %assign_optional27, %assign_optional23
+after_assign54:                                   ; preds = %cond.phi53, %assign_optional51, %cond.lhs47
-  br label %voiderr32
+  br label %voiderr55
 
-voiderr32:                                        ; preds = %after_assign31
+voiderr55:                                        ; preds = %after_assign54
   %18 = load i8*, i8** %a, align 8
-  %not33 = icmp eq i8* %18, null
+  %not56 = icmp eq i8* %18, null
-  br i1 %not33, label %cond.lhs34, label %cond.rhs38
+  br i1 %not56, label %cond.lhs57, label %cond.rhs58
 
-cond.lhs34:                                       ; preds = %voiderr32
+cond.lhs57:                                       ; preds = %voiderr55
-  %19 = load i64, i64* %x.f, align 8
-  %not_err35 = icmp eq i64 %19, 0
-  br i1 %not_err35, label %after_check37, label %assign_optional36
-
-assign_optional36:                                ; preds = %cond.lhs34
-  store i64 %19, i64* %y.f, align 8
-  br label %after_assign40
-
-after_check37:                                    ; preds = %cond.lhs34
-  %20 = load i8*, i8** %x, align 8
-  br label %cond.phi39
-
-cond.rhs38:                                       ; preds = %voiderr32
   store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %y.f, align 8
-  br label %after_assign40
+  br label %after_assign60
 
-cond.phi39:                                       ; preds = %after_check37
+cond.rhs58:                                       ; preds = %voiderr55
-  store i8* %20, i8** %y, align 8
-  store i64 0, i64* %y.f, align 8
-  br label %after_assign40
-
-after_assign40:                                   ; preds = %cond.phi39, %cond.rhs38, %assign_optional36
-  br label %voiderr41
-
-voiderr41:                                        ; preds = %after_assign40
-  %21 = load i8*, i8** %a, align 8
-  %not42 = icmp eq i8* %21, null
-  br i1 %not42, label %cond.lhs43, label %cond.rhs44
-
-cond.lhs43:                                       ; preds = %voiderr41
-  store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %y.f, align 8
-  br label %after_assign49
-
-cond.rhs44:                                       ; preds = %voiderr41
-  %22 = load i64, i64* %x.f, align 8
-  %not_err45 = icmp eq i64 %22, 0
-  br i1 %not_err45, label %after_check47, label %assign_optional46
-
-assign_optional46:                                ; preds = %cond.rhs44
-  store i64 %22, i64* %y.f, align 8
-  br label %after_assign49
-
-after_check47:                                    ; preds = %cond.rhs44
-  %23 = load i8*, i8** %x, align 8
-  br label %cond.phi48
-
-cond.phi48:                                       ; preds = %after_check47
-  store i8* %23, i8** %y, align 8
-  store i64 0, i64* %y.f, align 8
-  br label %after_assign49
-
-after_assign49:                                   ; preds = %cond.phi48, %assign_optional46, %cond.lhs43
-  br label %voiderr50
-
-voiderr50:                                        ; preds = %after_assign49
-  %24 = load i8*, i8** %a, align 8
-  %not51 = icmp eq i8* %24, null
-  br i1 %not51, label %cond.lhs52, label %cond.rhs53
-
-cond.lhs52:                                       ; preds = %voiderr50
-  store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %y.f, align 8
-  br label %after_assign55
-
-cond.rhs53:                                       ; preds = %voiderr50
   store i64 ptrtoint (%.fault* @"test_Test$BAR" to i64), i64* %y.f, align 8
-  br label %after_assign55
+  br label %after_assign60
 
-after_assign55:                                   ; preds = %cond.rhs53, %cond.lhs52
+after_assign60:                                   ; preds = %cond.rhs58, %cond.lhs57
-  br label %voiderr56
+  br label %voiderr61
 
-voiderr56:                                        ; preds = %after_assign55
+voiderr61:                                        ; preds = %after_assign60
   ret void

test/test_suite/failable_catch.c3t

@@ -61,91 +61,91 @@ expr_block.exit:                                  ; preds = %if.then
   store i64 0, i64* %a.f, align 8
   br label %after_assign
 after_assign:                                     ; preds = %expr_block.exit, %if.exit
-  %3 = load i64, i64* %a.f, align 8
+  %optval = load i64, i64* %a.f, align 8
-  %not_err = icmp eq i64 %3, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %else_block
 after_check:                                      ; preds = %after_assign
-  %4 = load i32, i32* %a, align 4
+  %3 = load i32, i32* %a, align 4
-  %add = add i32 %4, 3
+  %add = add i32 %3, 3
   br label %phi_block
 else_block:                                       ; preds = %after_assign
   br label %phi_block
 phi_block:                                        ; preds = %else_block, %after_check
   %val = phi i32 [ %add, %after_check ], [ 2, %else_block ]
   store i32 %val, i32* %x1, align 4
-  %5 = load i32, i32* %x1, align 4
+  %4 = load i32, i32* %x1, align 4
-  %intbool3 = icmp ne i32 %5, 0
+  %intbool3 = icmp ne i32 %4, 0
   br i1 %intbool3, label %if.then4, label %if.exit5
 if.then4:                                         ; preds = %phi_block
-  %6 = load i32, i32* %x1, align 4
+  %5 = load i32, i32* %x1, align 4
-  store i32 %6, i32* %blockret2, align 4
+  store i32 %5, i32* %blockret2, align 4
   br label %expr_block.exit6
 if.exit5:                                         ; preds = %phi_block
   store i64 ptrtoint (%.fault* @"failable_catch_MyErr$TEST" to i64), i64* %b.f, align 8
   br label %after_assign7
 expr_block.exit6:                                 ; preds = %if.then4
-  %7 = load i32, i32* %blockret2, align 4
+  %6 = load i32, i32* %blockret2, align 4
-  store i32 %7, i32* %b, align 4
+  store i32 %6, i32* %b, align 4
   store i64 0, i64* %b.f, align 8
   br label %after_assign7
 after_assign7:                                    ; preds = %expr_block.exit6, %if.exit5
   store i32 0, i32* %x8, align 4
-  %8 = load i32, i32* %x8, align 4
+  %7 = load i32, i32* %x8, align 4
-  %intbool10 = icmp ne i32 %8, 0
+  %intbool10 = icmp ne i32 %7, 0
   br i1 %intbool10, label %if.then11, label %if.exit12
 if.then11:                                        ; preds = %after_assign7
-  %9 = load i32, i32* %x8, align 4
+  %8 = load i32, i32* %x8, align 4
-  store i32 %9, i32* %blockret9, align 4
+  store i32 %8, i32* %blockret9, align 4
   br label %expr_block.exit13
 if.exit12:                                        ; preds = %after_assign7
   store i64 ptrtoint (%.fault* @"failable_catch_MyErr$TEST" to i64), i64* %c.f, align 8
   br label %after_assign14
 expr_block.exit13:                                ; preds = %if.then11
-  %10 = load i32, i32* %blockret9, align 4
+  %9 = load i32, i32* %blockret9, align 4
-  store i32 %10, i32* %c, align 4
+  store i32 %9, i32* %c, align 4
   store i64 0, i64* %c.f, align 8
   br label %after_assign14
 after_assign14:                                   ; preds = %expr_block.exit13, %if.exit12
-  %11 = load i64, i64* %a.f, align 8
+  %optval15 = load i64, i64* %a.f, align 8
-  %not_err15 = icmp eq i64 %11, 0
+  %not_err16 = icmp eq i64 %optval15, 0
-  br i1 %not_err15, label %after_check16, label %voiderr
+  br i1 %not_err16, label %after_check17, label %voiderr
-after_check16:                                    ; preds = %after_assign14
+after_check17:                                    ; preds = %after_assign14
-  %12 = load i32, i32* %a, align 4
+  %10 = load i32, i32* %a, align 4
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 %12)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 %10)
   br label %voiderr
-voiderr:                                          ; preds = %after_check16, %after_assign14
+voiderr:                                          ; preds = %after_check17, %after_assign14
-  %13 = load i64, i64* %b.f, align 8
+  %optval18 = load i64, i64* %b.f, align 8
-  %not_err17 = icmp eq i64 %13, 0
+  %not_err19 = icmp eq i64 %optval18, 0
-  br i1 %not_err17, label %after_check18, label %voiderr19
+  br i1 %not_err19, label %after_check20, label %voiderr21
-after_check18:                                    ; preds = %voiderr
+after_check20:                                    ; preds = %voiderr
-  %14 = load i32, i32* %b, align 4
+  %11 = load i32, i32* %b, align 4
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i32 0, i32 0), i32 %14)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i32 0, i32 0), i32 %11)
-  br label %voiderr19
+  br label %voiderr21
-voiderr19:                                        ; preds = %after_check18, %voiderr
+voiderr21:                                        ; preds = %after_check20, %voiderr
-  %15 = load i64, i64* %c.f, align 8
+  %optval22 = load i64, i64* %c.f, align 8
-  %not_err20 = icmp eq i64 %15, 0
+  %not_err23 = icmp eq i64 %optval22, 0
-  br i1 %not_err20, label %after_check21, label %voiderr22
+  br i1 %not_err23, label %after_check24, label %voiderr25
-after_check21:                                    ; preds = %voiderr19
+after_check24:                                    ; preds = %voiderr21
-  %16 = load i32, i32* %c, align 4
+  %12 = load i32, i32* %c, align 4
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0), i32 %16)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0), i32 %12)
-  br label %voiderr22
+  br label %voiderr25
-voiderr22:                                        ; preds = %after_check21, %voiderr19
+voiderr25:                                        ; preds = %after_check24, %voiderr21
-  %17 = load i64, i64* %c.f, align 8
+  %13 = load i64, i64* %c.f, align 8
-  %neq = icmp ne i64 %17, 0
+  %neq = icmp ne i64 %13, 0
-  br i1 %neq, label %if.then23, label %if.exit24
+  br i1 %neq, label %if.then26, label %if.exit27
-if.then23:                                        ; preds = %voiderr22
+if.then26:                                        ; preds = %voiderr25
   call void (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i32 0, i32 0))
-  br label %if.exit24
+  br label %if.exit27
-if.exit24:                                        ; preds = %if.then23, %voiderr22
+if.exit27:                                        ; preds = %if.then26, %voiderr25
   store i32 3, i32* %c, align 4
   store i64 0, i64* %c.f, align 8
-  %18 = load i64, i64* %c.f, align 8
+  %optval28 = load i64, i64* %c.f, align 8
-  %not_err25 = icmp eq i64 %18, 0
+  %not_err29 = icmp eq i64 %optval28, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
+  br i1 %not_err29, label %after_check30, label %voiderr31
-after_check26:                                    ; preds = %if.exit24
+after_check30:                                    ; preds = %if.exit27
-  %19 = load i32, i32* %c, align 4
+  %14 = load i32, i32* %c, align 4
-  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i32 0, i32 0), i32 %19)
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i32 0, i32 0), i32 %14)
-  br label %voiderr27
+  br label %voiderr31
-voiderr27:                                        ; preds = %after_check26, %if.exit24
+voiderr31:                                        ; preds = %after_check30, %if.exit27
   ret i32 0
 }

test/test_suite/from_docs/examples_if_catch.c3t

@@ -119,12 +119,12 @@ after_assign:                                     ; preds = %after_check, %assig
   br label %testblock
 
 testblock:                                        ; preds = %after_assign
-  %4 = load i64, i64* %ratio.f, align 8
+  %optval = load i64, i64* %ratio.f, align 8
-  %not_err1 = icmp eq i64 %4, 0
+  %not_err1 = icmp eq i64 %optval, 0
   br i1 %not_err1, label %after_check3, label %assign_optional2
 
 assign_optional2:                                 ; preds = %testblock
-  store i64 %4, i64* %err, align 8
+  store i64 %optval, i64* %err, align 8
   br label %end_block
 
 after_check3:                                     ; preds = %testblock
@@ -132,32 +132,32 @@ after_check3:                                     ; preds = %testblock
   br label %end_block
 
 end_block:                                        ; preds = %after_check3, %assign_optional2
-  %5 = load i64, i64* %err, align 8
+  %4 = load i64, i64* %err, align 8
-  %neq = icmp ne i64 %5, 0
+  %neq = icmp ne i64 %4, 0
   br i1 %neq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_block
-  store i64 %5, i64* %switch, align 8
+  store i64 %4, i64* %switch, align 8
   br label %switch.entry
 
 switch.entry:                                     ; preds = %if.then
-  %6 = load i64, i64* %switch, align 8
+  %5 = load i64, i64* %switch, align 8
-  %eq = icmp eq i64 ptrtoint (%.fault* @"demo_MathError$DIVISION_BY_ZERO" to i64), %6
+  %eq = icmp eq i64 ptrtoint (%.fault* @"demo_MathError$DIVISION_BY_ZERO" to i64), %5
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
-  %7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i32 0, i32 0))
+  %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i32 0, i32 0))
   ret void
 
 next_if:                                          ; preds = %switch.entry
   br label %switch.default
 
 switch.default:                                   ; preds = %next_if
-  %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i32 0, i32 0))
+  %7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i32 0, i32 0))
   ret void
 
 if.exit:                                          ; preds = %end_block
-  %9 = load double, double* %ratio, align 8
+  %8 = load double, double* %ratio, align 8
-  %10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i32 0, i32 0), double %9)
+  %9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i32 0, i32 0), double %8)
   ret void
 }

test/test_suite/functions/assorted_tests.c3t

@@ -48,7 +48,7 @@ fn void denormalize(InternalFPF* ptr)
 }
 
 
-// #expect: test.ll
+/* #expect: test.ll
 
 define i32 @test_foo1() #0 {
 entry:
@@ -57,8 +57,8 @@ entry:
   %0 = load i32, i32* %w_cnt, align 4
   %1 = load i8*, i8** %pp, align 8
   %2 = load i8, i8* %1, align 8
-  %uiuiext = zext i8 %2 to i32
+  %zext = zext i8 %2 to i32
-  %add = add i32 %0, %uiuiext
+  %add = add i32 %0, %zext
   store i32 %add, i32* %w_cnt, align 4
   %3 = load i32, i32* %w_cnt, align 4
   ret i32 %3

test/test_suite/functions/simple_test.c3t

@@ -22,8 +22,8 @@ entry:
   %0 = load i32, i32* %w_cnt, align 4
   %1 = load i8*, i8** %pp, align 8
   %2 = load i8, i8* %1, align 8
-  %uiuiext = zext i8 %2 to i32
+  %zext = zext i8 %2 to i32
-  %add = add i32 %0, %uiuiext
+  %add = add i32 %0, %zext
   store i32 %add, i32* %w_cnt, align 4
   %3 = load i32, i32* %w_cnt, align 4
   ret i32 %3

test/test_suite/macros/macro_with_body.c3t

@@ -69,36 +69,37 @@ entry:
   %0 = bitcast %Foo* %f to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast (%Foo* @.__const to i8*), i32 4, i1 false)
   store i32 0, i32* %y, align 4
-  %1 = load %Foo, %Foo* %f, align 4
+  %1 = bitcast %Foo* %foo to i8*
-  store %Foo %1, %Foo* %foo, align 4
+  %2 = bitcast %Foo* %f to i8*
-  %2 = getelementptr inbounds %Foo, %Foo* %foo, i32 0, i32 0
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %1, i8* align 4 %2, i32 4, i1 false)
-  %3 = load i32, i32* %2, align 4
+  %3 = getelementptr inbounds %Foo, %Foo* %foo, i32 0, i32 0
-  store i32 %3, i32* %y, align 4
+  %4 = load i32, i32* %3, align 4
-  %4 = call i32 @withbody_Foo_mutate(%Foo* %foo)
+  store i32 %4, i32* %y, align 4
-  store i32 %4, i32* %x, align 4
+  %5 = call i32 @withbody_Foo_mutate(%Foo* %foo)
-  %5 = load i32, i32* %y, align 4
+  store i32 %5, i32* %x, align 4
-  store i32 %5, i32* %dy, align 4
+  %6 = load i32, i32* %y, align 4
-  %6 = load i32, i32* %x, align 4
+  store i32 %6, i32* %dy, align 4
-  %7 = load i32, i32* %dy, align 4
+  %7 = load i32, i32* %x, align 4
-  %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i32 %6, i32 %7)
+  %8 = load i32, i32* %dy, align 4
+  %9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i32 0, i32 0), i32 %7, i32 %8)
   store i32 10, i32* %times, align 4
   store i32 0, i32* %i, align 4
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %9 = load i32, i32* %i, align 4
+  %10 = load i32, i32* %i, align 4
-  %10 = load i32, i32* %times, align 4
+  %11 = load i32, i32* %times, align 4
-  %lt = icmp slt i32 %9, %10
+  %lt = icmp slt i32 %10, %11
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %11 = load i32, i32* %i, align 4
+  %12 = load i32, i32* %i, align 4
-  %add = add i32 %11, 1
+  %add = add i32 %12, 1
   store i32 %add, i32* %loop, align 4
-  %12 = load i32, i32* %loop, align 4
+  %13 = load i32, i32* %loop, align 4
-  %13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i32 %12)
+  %14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i32 %13)
-  %14 = load i32, i32* %i, align 4
+  %15 = load i32, i32* %i, align 4
-  %add1 = add i32 %14, 1
+  %add1 = add i32 %15, 1
   store i32 %add1, i32* %i, align 4
   br label %loop.cond
 

test/test_suite/macros/userland_bitcast.c3t

@@ -102,8 +102,9 @@ entry:
   store i16 0, i16* %5, align 2
   %6 = getelementptr inbounds %Foo, %Foo* %z, i32 0, i32 0
   store i16 %0, i16* %6, align 2
-  %7 = load %Foo, %Foo* %z, align 2
+  %7 = bitcast %Foo* %expr to i8*
-  store %Foo %7, %Foo* %expr, align 2
+  %8 = bitcast %Foo* %z to i8*
+  call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 2 %7, i8* align 2 %8, i32 8, i1 false)
   %ptrptr = bitcast %Foo* %expr to i16*
   store i16* %ptrptr, i16** %b, align 8
   %ptrptr1 = bitcast i64* %x to i16*
@@ -112,27 +113,27 @@ entry:
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %8 = load i64, i64* %i, align 8
+  %9 = load i64, i64* %i, align 8
-  %lt = icmp ult i64 %8, 8
+  %lt = icmp ult i64 %9, 8
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %9 = load i16*, i16** %to, align 8
+  %10 = load i16*, i16** %to, align 8
-  %10 = load i64, i64* %i, align 8
+  %11 = load i64, i64* %i, align 8
-  %ptroffset = getelementptr inbounds i16, i16* %9, i64 %10
+  %ptroffset = getelementptr inbounds i16, i16* %10, i64 %11
-  %11 = load i16*, i16** %b, align 8
+  %12 = load i16*, i16** %b, align 8
-  %12 = load i64, i64* %i, align 8
+  %13 = load i64, i64* %i, align 8
-  %ptroffset2 = getelementptr inbounds i16, i16* %11, i64 %12
+  %ptroffset2 = getelementptr inbounds i16, i16* %12, i64 %13
-  %13 = load i16, i16* %ptroffset2, align 2
+  %14 = load i16, i16* %ptroffset2, align 2
-  store i16 %13, i16* %ptroffset, align 2
+  store i16 %14, i16* %ptroffset, align 2
-  %14 = load i64, i64* %i, align 8
+  %15 = load i64, i64* %i, align 8
-  %add = add i64 %14, 2
+  %add = add i64 %15, 2
   store i64 %add, i64* %i, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  %15 = load i64, i64* %x, align 8
+  %16 = load i64, i64* %x, align 8
-  ret i64 %15
+  ret i64 %16
 }
 
 ; Function Attrs: nounwind

test/test_suite/statements/comparison_widening.c3t

@@ -8,7 +8,7 @@ fn void test1()
     int d = b ?: 1;
 }
 
-// #expect: comparison_widening.ll
+/* #expect: comparison_widening.ll
 
 define void @comparison_widening_test1() #0 {
 entry:
@@ -20,9 +20,9 @@ entry:
   store i32 2, i32* %b, align 4
   %0 = load i32, i32* %b, align 4
   %1 = load i8, i8* %a, align 1
-  %uiuiext = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %gt = icmp sgt i32 %0, %uiuiext
+  %gt = icmp sgt i32 %0, %zext
-  %check = icmp sge i32 %uiuiext, 0
+  %check = icmp sge i32 %zext, 0
   %siui-gt = and i1 %check, %gt
   %ternary = select i1 %siui-gt, i8 1, i8 0
   store i8 %ternary, i8* %c, align 1

test/test_suite/statements/foreach_common.c3t

@@ -55,6 +55,7 @@ fn void main()
 
 entry:
   %foo = alloca [3 x float], align 4
+  %foo2 = alloca <3 x float>, align 16
   %anon = alloca i64, align 8
   %a = alloca float, align 4
   %anon1 = alloca i64, align 8
@@ -69,8 +70,23 @@ entry:
   %a31 = alloca double, align 8
   %anon35 = alloca i64, align 8
   %a39 = alloca double, align 8
+  %anon43 = alloca i64, align 8
+  %anon44 = alloca i64, align 8
+  %a47 = alloca float, align 4
+  %anon51 = alloca i64, align 8
+  %anon52 = alloca i64, align 8
+  %i56 = alloca i64, align 8
+  %a57 = alloca float, align 4
+  %anon61 = alloca i64, align 8
+  %anon62 = alloca i64, align 8
+  %i66 = alloca i8, align 1
+  %a68 = alloca double, align 8
+  %anon73 = alloca i64, align 8
+  %anon74 = alloca i64, align 8
+  %a78 = alloca double, align 8
   %0 = bitcast [3 x float]* %foo to i8*
   call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %0, i8* align 4 bitcast ([3 x float]* @.__const to i8*), i32 12, i1 false)
+  store <3 x float> <float 2.000000e+00, float 4.500000e+00, float 8.000000e+00>, <3 x float>* %foo2, align 16
   store i64 0, i64* %anon, align 8
   br label %loop.cond
 
@@ -178,8 +194,8 @@ loop.cond27:                                      ; preds = %loop.body29, %loop.
 
 loop.body29:                                      ; preds = %loop.cond27
   %30 = load i64, i64* %anon26, align 8
-  %uiuitrunc = trunc i64 %30 to i8
+  %ztrunc = trunc i64 %30 to i8
-  store i8 %uiuitrunc, i8* %i30, align 1
+  store i8 %ztrunc, i8* %i30, align 1
   %31 = load i64, i64* %anon26, align 8
   %32 = getelementptr inbounds [3 x float], [3 x float]* %foo, i64 0, i64 %31
   %33 = load float, float* %32, align 4
@@ -217,5 +233,109 @@ loop.body38:                                      ; preds = %loop.cond36
   br label %loop.cond36
 
 loop.exit42:                                      ; preds = %loop.cond36
+  store i64 0, i64* %anon43, align 8
+  store i64 3, i64* %anon44, align 8
+  br label %loop.cond45
+
+loop.cond45:                                      ; preds = %loop.body46, %loop.exit42
+  %43 = load i64, i64* %anon43, align 8
+  %44 = load i64, i64* %anon44, align 8
+  %lt = icmp ult i64 %43, %44
+  br i1 %lt, label %loop.body46, label %loop.exit50
+
+loop.body46:                                      ; preds = %loop.cond45
+  %45 = load <3 x float>, <3 x float>* %foo2, align 16
+  %46 = load i64, i64* %anon43, align 8
+  %47 = extractelement <3 x float> %45, i64 %46
+  store float %47, float* %a47, align 4
+  %48 = load float, float* %a47, align 4
+  %fpfpext48 = fpext float %48 to double
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.6, i32 0, i32 0), double %fpfpext48)
+  %49 = load i64, i64* %anon43, align 8
+  %add49 = add i64 %49, 1
+  store i64 %add49, i64* %anon43, align 8
+  br label %loop.cond45
+
+loop.exit50:                                      ; preds = %loop.cond45
+  store i64 0, i64* %anon51, align 8
+  store i64 3, i64* %anon52, align 8
+  br label %loop.cond53
+
+loop.cond53:                                      ; preds = %loop.body55, %loop.exit50
+  %50 = load i64, i64* %anon51, align 8
+  %51 = load i64, i64* %anon52, align 8
+  %lt54 = icmp ult i64 %50, %51
+  br i1 %lt54, label %loop.body55, label %loop.exit60
+
+loop.body55:                                      ; preds = %loop.cond53
+  %52 = load i64, i64* %anon51, align 8
+  store i64 %52, i64* %i56, align 8
+  %53 = load <3 x float>, <3 x float>* %foo2, align 16
+  %54 = load i64, i64* %anon51, align 8
+  %55 = extractelement <3 x float> %53, i64 %54
+  store float %55, float* %a57, align 4
+  %56 = load i64, i64* %i56, align 8
+  %57 = load float, float* %a57, align 4
+  %fpfpext58 = fpext float %57 to double
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.7, i32 0, i32 0), i64 %56, double %fpfpext58)
+  %58 = load i64, i64* %anon51, align 8
+  %add59 = add i64 %58, 1
+  store i64 %add59, i64* %anon51, align 8
+  br label %loop.cond53
+
+loop.exit60:                                      ; preds = %loop.cond53
+  store i64 0, i64* %anon61, align 8
+  store i64 3, i64* %anon62, align 8
+  br label %loop.cond63
+
+loop.cond63:                                      ; preds = %loop.body65, %loop.exit60
+  %59 = load i64, i64* %anon61, align 8
+  %60 = load i64, i64* %anon62, align 8
+  %lt64 = icmp ult i64 %59, %60
+  br i1 %lt64, label %loop.body65, label %loop.exit72
+
+loop.body65:                                      ; preds = %loop.cond63
+  %61 = load i64, i64* %anon61, align 8
+  %ztrunc67 = trunc i64 %61 to i8
+  store i8 %ztrunc67, i8* %i66, align 1
+  %62 = load <3 x float>, <3 x float>* %foo2, align 16
+  %63 = load i64, i64* %anon61, align 8
+  %64 = extractelement <3 x float> %62, i64 %63
+  %fpfpext69 = fpext float %64 to double
+  store double %fpfpext69, double* %a68, align 8
+  %65 = load i8, i8* %i66, align 1
+  %uisiext70 = zext i8 %65 to i32
+  %66 = load double, double* %a68, align 8
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.8, i32 0, i32 0), i32 %uisiext70, double %66)
+  %67 = load i64, i64* %anon61, align 8
+  %add71 = add i64 %67, 1
+  store i64 %add71, i64* %anon61, align 8
+  br label %loop.cond63
+
+loop.exit72:                                      ; preds = %loop.cond63
+  store i64 0, i64* %anon73, align 8
+  store i64 3, i64* %anon74, align 8
+  br label %loop.cond75
+
+loop.cond75:                                      ; preds = %loop.body77, %loop.exit72
+  %68 = load i64, i64* %anon73, align 8
+  %69 = load i64, i64* %anon74, align 8
+  %lt76 = icmp ult i64 %68, %69
+  br i1 %lt76, label %loop.body77, label %loop.exit81
+
+loop.body77:                                      ; preds = %loop.cond75
+  %70 = load <3 x float>, <3 x float>* %foo2, align 16
+  %71 = load i64, i64* %anon73, align 8
+  %72 = extractelement <3 x float> %70, i64 %71
+  %fpfpext79 = fpext float %72 to double
+  store double %fpfpext79, double* %a78, align 8
+  %73 = load double, double* %a78, align 8
+  call void (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i32 0, i32 0), double %73)
+  %74 = load i64, i64* %anon73, align 8
+  %add80 = add i64 %74, 1
+  store i64 %add80, i64* %anon73, align 8
+  br label %loop.cond75
+
+loop.exit81:                                      ; preds = %loop.cond75
   ret void
 }

test/test_suite/statements/various_switching.c3t

@@ -86,12 +86,12 @@ entry:
   br label %testblock
 
 testblock:                                        ; preds = %entry
-  %0 = load i64, i64* %x.f, align 8
+  %optval = load i64, i64* %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %testblock
-  store i64 %0, i64* %err, align 8
+  store i64 %optval, i64* %err, align 8
   br label %end_block
 
 after_check:                                      ; preds = %testblock
@@ -99,17 +99,17 @@ after_check:                                      ; preds = %testblock
   br label %end_block
 
 end_block:                                        ; preds = %after_check, %assign_optional
-  %1 = load i64, i64* %err, align 8
+  %0 = load i64, i64* %err, align 8
-  %neq = icmp ne i64 %1, 0
+  %neq = icmp ne i64 %0, 0
   br i1 %neq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_block
-  store i64 %1, i64* %switch, align 8
+  store i64 %0, i64* %switch, align 8
   br label %switch.entry
 
 switch.entry:                                     ; preds = %if.then
-  %2 = load i64, i64* %switch, align 8
+  %1 = load i64, i64* %switch, align 8
-  %eq = icmp eq i64 ptrtoint (%.fault* @"mymodule_HelloErr$FOO" to i64), %2
+  %eq = icmp eq i64 ptrtoint (%.fault* @"mymodule_HelloErr$FOO" to i64), %1
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
@@ -117,7 +117,7 @@ switch.case:                                      ; preds = %switch.entry
   br label %switch.exit
 
 next_if:                                          ; preds = %switch.entry
-  %eq1 = icmp eq i64 ptrtoint (%.fault* @"mymodule_ByeErr$BAR" to i64), %2
+  %eq1 = icmp eq i64 ptrtoint (%.fault* @"mymodule_ByeErr$BAR" to i64), %1
   br i1 %eq1, label %switch.case2, label %next_if3
 
 switch.case2:                                     ; preds = %next_if
@@ -135,13 +135,13 @@ switch.exit:                                      ; preds = %switch.default, %sw
   br label %if.exit
 
 if.exit:                                          ; preds = %switch.exit, %end_block
-  %3 = load i64, i64* %z, align 8
+  %2 = load i64, i64* %z, align 8
-  store i64 %3, i64* %switch4, align 8
+  store i64 %2, i64* %switch4, align 8
   br label %switch.entry5
 
 switch.entry5:                                    ; preds = %if.exit
-  %4 = load i64, i64* %switch4, align 8
+  %3 = load i64, i64* %switch4, align 8
-  %eq6 = icmp eq i64 ptrtoint (%.introspect* @"ct$int" to i64), %4
+  %eq6 = icmp eq i64 ptrtoint (%.introspect* @"ct$int" to i64), %3
   br i1 %eq6, label %switch.case7, label %next_if8
 
 switch.case7:                                     ; preds = %switch.entry5
@@ -149,14 +149,14 @@ switch.case7:                                     ; preds = %switch.entry5
   br label %switch.exit16
 
 next_if8:                                         ; preds = %switch.entry5
-  %eq9 = icmp eq i64 ptrtoint (%.introspect* @"ct$bool" to i64), %4
+  %eq9 = icmp eq i64 ptrtoint (%.introspect* @"ct$bool" to i64), %3
   br i1 %eq9, label %switch.case10, label %next_if11
 
 switch.case10:                                    ; preds = %next_if8
   br label %switch.case13
 
 next_if11:                                        ; preds = %next_if8
-  %eq12 = icmp eq i64 ptrtoint (%.introspect* @"ct$double" to i64), %4
+  %eq12 = icmp eq i64 ptrtoint (%.introspect* @"ct$double" to i64), %3
   br i1 %eq12, label %switch.case13, label %next_if14
 
 switch.case13:                                    ; preds = %next_if11, %switch.case10
@@ -172,18 +172,18 @@ switch.default15:                                 ; preds = %next_if14, %switch.
 switch.exit16:                                    ; preds = %switch.default15, %switch.case7
   store i32 1, i32* %a, align 4
   store i32 2, i32* %b, align 4
-  %5 = load i32, i32* %b, align 4
+  %4 = load i32, i32* %b, align 4
-  %6 = load i32, i32* %a, align 4
+  %5 = load i32, i32* %a, align 4
-  %add = add i32 %5, %6
+  %add = add i32 %4, %5
   store i32 %add, i32* %zy, align 4
-  %7 = load i32, i32* %zy, align 4
+  %6 = load i32, i32* %zy, align 4
-  store i32 %7, i32* %switch17, align 4
+  store i32 %6, i32* %switch17, align 4
   br label %switch.entry18
 
 switch.entry18:                                   ; preds = %switch.exit16
-  %8 = load i32, i32* %switch17, align 4
+  %7 = load i32, i32* %switch17, align 4
-  %9 = load i32, i32* %a, align 4
+  %8 = load i32, i32* %a, align 4
-  %eq19 = icmp eq i32 %9, %8
+  %eq19 = icmp eq i32 %8, %7
   br i1 %eq19, label %switch.case20, label %next_if21
 
 switch.case20:                                    ; preds = %switch.entry18
@@ -191,8 +191,8 @@ switch.case20:                                    ; preds = %switch.entry18
   br label %switch.exit26
 
 next_if21:                                        ; preds = %switch.entry18
-  %10 = load i32, i32* %b, align 4
+  %9 = load i32, i32* %b, align 4
-  %eq22 = icmp eq i32 %10, %8
+  %eq22 = icmp eq i32 %9, %7
   br i1 %eq22, label %switch.case23, label %next_if24
 
 switch.case23:                                    ; preds = %next_if21
@@ -211,11 +211,11 @@ switch.exit26:                                    ; preds = %switch.default25, %
   br label %switch.entry28
 
 switch.entry28:                                   ; preds = %switch.exit26
-  %11 = load i8, i8* %switch27, align 1
+  %10 = load i8, i8* %switch27, align 1
-  %12 = trunc i8 %11 to i1
+  %11 = trunc i8 %10 to i1
-  %13 = load i32, i32* %a, align 4
+  %12 = load i32, i32* %a, align 4
-  %lt = icmp slt i32 %13, 0
+  %lt = icmp slt i32 %12, 0
-  %eq29 = icmp eq i1 %lt, %12
+  %eq29 = icmp eq i1 %lt, %11
   br i1 %eq29, label %switch.case30, label %next_if31
 
 switch.case30:                                    ; preds = %switch.entry28
@@ -223,9 +223,9 @@ switch.case30:                                    ; preds = %switch.entry28
   br label %switch.exit37
 
 next_if31:                                        ; preds = %switch.entry28
-  %14 = load i32, i32* %a, align 4
+  %13 = load i32, i32* %a, align 4
-  %eq32 = icmp eq i32 %14, 1
+  %eq32 = icmp eq i32 %13, 1
-  %eq33 = icmp eq i1 %eq32, %12
+  %eq33 = icmp eq i1 %eq32, %11
   br i1 %eq33, label %switch.case34, label %next_if35
 
 switch.case34:                                    ; preds = %next_if31

test/test_suite2/arrays/array_literal.c3t

@@ -20,8 +20,8 @@ define double @array_literal_test(i32 %0) #0 {
 entry:
   %student_t = alloca [30 x double], align 16
   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %student_t, ptr align 16 @.__const, i32 240, i1 false)
-  %uiuiext = zext i32 %0 to i64
+  %zext = zext i32 %0 to i64
-  %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %uiuiext
+  %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %zext
   %2 = load double, ptr %1, align 8
   ret double %2
 }

test/test_suite2/bitstruct/array_with_boolean.c3t

@@ -31,41 +31,41 @@ entry:
   store [3 x i8] c"\1A\1E\10", ptr %xy, align 1
   %0 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
   %1 = load i8, ptr %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = shl i32 %2, 29
+  %shl = shl i32 %zext, 29
-  %4 = ashr i32 %3, 29
+  %ashr = ashr i32 %shl, 29
-  %5 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
+  %2 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
-  %6 = load i8, ptr %5, align 1
+  %3 = load i8, ptr %2, align 1
-  %7 = zext i8 %6 to i32
+  %zext1 = zext i8 %3 to i32
-  %8 = lshr i32 %7, 3
+  %lshrl = lshr i32 %zext1, 3
-  %9 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
+  %4 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
+  %5 = load i8, ptr %4, align 1
+  %zext2 = zext i8 %5 to i32
+  %shl3 = shl i32 %zext2, 5
+  %6 = or i32 %shl3, %lshrl
+  %shl4 = shl i32 %6, 26
+  %ashr5 = ashr i32 %shl4, 26
+  %7 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
+  %8 = load i8, ptr %7, align 1
+  %zext6 = zext i8 %8 to i32
+  %lshrl7 = lshr i32 %zext6, 1
+  %9 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
   %10 = load i8, ptr %9, align 1
-  %11 = zext i8 %10 to i32
+  %zext8 = zext i8 %10 to i32
-  %12 = shl i32 %11, 5
+  %shl9 = shl i32 %zext8, 7
-  %13 = or i32 %12, %8
+  %11 = or i32 %shl9, %lshrl7
-  %14 = shl i32 %13, 26
+  %shl10 = shl i32 %11, 22
-  %15 = ashr i32 %14, 26
+  %ashr11 = ashr i32 %shl10, 22
-  %16 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
+  %12 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
-  %17 = load i8, ptr %16, align 1
+  %13 = load i8, ptr %12, align 1
-  %18 = zext i8 %17 to i32
+  %lshrl12 = lshr i8 %13, 3
-  %19 = lshr i32 %18, 1
+  %14 = trunc i8 %lshrl12 to i1
-  %20 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
+  %boolsi = zext i1 %14 to i32
-  %21 = load i8, ptr %20, align 1
+  %15 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
-  %22 = zext i8 %21 to i32
+  %16 = load i8, ptr %15, align 1
-  %23 = shl i32 %22, 7
+  %lshrl13 = lshr i8 %16, 4
-  %24 = or i32 %23, %19
+  %17 = trunc i8 %lshrl13 to i1
-  %25 = shl i32 %24, 22
+  %boolsi14 = zext i1 %17 to i32
-  %26 = ashr i32 %25, 22
+  call void (ptr, ...) @printf(ptr @.str, i32 %ashr, i32 %ashr5, i32 %ashr11, i32 %boolsi, i32 %boolsi14)
-  %27 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
-  %28 = load i8, ptr %27, align 1
-  %29 = lshr i8 %28, 3
-  %30 = trunc i8 %29 to i1
-  %boolsi = zext i1 %30 to i32
-  %31 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
-  %32 = load i8, ptr %31, align 1
-  %33 = lshr i8 %32, 4
-  %34 = trunc i8 %33 to i1
-  %boolsi1 = zext i1 %34 to i32
-  call void (ptr, ...) @printf(ptr @.str, i32 %4, i32 %15, i32 %26, i32 %boolsi, i32 %boolsi1)
   ret void
 }

test/test_suite2/bitstruct/bitfield_access.c3t

@@ -125,56 +125,56 @@ entry:
   store i8 0, ptr %d, align 1
   %0 = getelementptr inbounds [3 x i8], ptr %e1, i64 0, i64 0
   %1 = load i8, ptr %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = shl i32 %2, 29
+  %shl = shl i32 %zext, 29
-  %4 = ashr i32 %3, 29
+  %ashr = ashr i32 %shl, 29
-  call void (ptr, ...) @printf(ptr @.str, i32 %4)
+  call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
-  %5 = getelementptr inbounds [3 x i8], ptr %e2, i64 0, i64 0
+  %2 = getelementptr inbounds [3 x i8], ptr %e2, i64 0, i64 0
-  %6 = load i8, ptr %5, align 1
+  %3 = load i8, ptr %2, align 1
-  %7 = zext i8 %6 to i32
+  %zext1 = zext i8 %3 to i32
-  %8 = shl i32 %7, 29
+  %shl2 = shl i32 %zext1, 29
-  %9 = ashr i32 %8, 29
+  %ashr3 = ashr i32 %shl2, 29
-  call void (ptr, ...) @printf(ptr @.str.1, i32 %9)
+  call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr3)
-  %10 = getelementptr inbounds [3 x i8], ptr %e3, i64 0, i64 0
+  %4 = getelementptr inbounds [3 x i8], ptr %e3, i64 0, i64 0
-  %11 = load i8, ptr %10, align 1
+  %5 = load i8, ptr %4, align 1
-  %12 = zext i8 %11 to i32
+  %zext4 = zext i8 %5 to i32
-  %13 = shl i32 %12, 29
+  %shl5 = shl i32 %zext4, 29
-  %14 = ashr i32 %13, 29
+  %ashr6 = ashr i32 %shl5, 29
-  call void (ptr, ...) @printf(ptr @.str.2, i32 %14)
+  call void (ptr, ...) @printf(ptr @.str.2, i32 %ashr6)
   store [3 x i8] c"\0B\06 ", ptr %z1, align 1
   store [3 x i8] c"\0C\06 ", ptr %z2, align 1
   store [3 x i8] c"\0F\06 ", ptr %z3, align 1
-  %15 = getelementptr inbounds [3 x i8], ptr %z1, i64 0, i64 0
+  %6 = getelementptr inbounds [3 x i8], ptr %z1, i64 0, i64 0
-  %16 = load i8, ptr %15, align 1
+  %7 = load i8, ptr %6, align 1
-  %17 = zext i8 %16 to i32
+  %zext7 = zext i8 %7 to i32
-  %18 = and i32 7, %17
+  %8 = and i32 7, %zext7
-  call void (ptr, ...) @printf(ptr @.str.3, i32 %18)
+  call void (ptr, ...) @printf(ptr @.str.3, i32 %8)
-  %19 = getelementptr inbounds [3 x i8], ptr %z2, i64 0, i64 0
+  %9 = getelementptr inbounds [3 x i8], ptr %z2, i64 0, i64 0
-  %20 = load i8, ptr %19, align 1
+  %10 = load i8, ptr %9, align 1
-  %21 = zext i8 %20 to i32
+  %zext8 = zext i8 %10 to i32
-  %22 = and i32 7, %21
+  %11 = and i32 7, %zext8
-  call void (ptr, ...) @printf(ptr @.str.4, i32 %22)
+  call void (ptr, ...) @printf(ptr @.str.4, i32 %11)
-  %23 = getelementptr inbounds [3 x i8], ptr %z3, i64 0, i64 0
+  %12 = getelementptr inbounds [3 x i8], ptr %z3, i64 0, i64 0
-  %24 = load i8, ptr %23, align 1
+  %13 = load i8, ptr %12, align 1
-  %25 = zext i8 %24 to i32
+  %zext9 = zext i8 %13 to i32
-  %26 = and i32 7, %25
+  %14 = and i32 7, %zext9
-  call void (ptr, ...) @printf(ptr @.str.5, i32 %26)
+  call void (ptr, ...) @printf(ptr @.str.5, i32 %14)
   store [5 x i8] c"\00G\02\00\00", ptr %xx, align 1
-  %27 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 0
+  %15 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 0
-  %28 = load i8, ptr %27, align 1
+  %16 = load i8, ptr %15, align 1
-  %29 = zext i8 %28 to i32
+  %zext10 = zext i8 %16 to i32
-  %30 = lshr i32 %29, 5
+  %lshrl = lshr i32 %zext10, 5
-  %31 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 1
+  %17 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 1
-  %32 = load i8, ptr %31, align 1
+  %18 = load i8, ptr %17, align 1
-  %33 = zext i8 %32 to i32
+  %zext11 = zext i8 %18 to i32
-  %34 = shl i32 %33, 3
+  %shl12 = shl i32 %zext11, 3
-  %35 = or i32 %34, %30
+  %19 = or i32 %shl12, %lshrl
-  %36 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 2
+  %20 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 2
-  %37 = load i8, ptr %36, align 1
+  %21 = load i8, ptr %20, align 1
-  %38 = zext i8 %37 to i32
+  %zext13 = zext i8 %21 to i32
-  %39 = shl i32 %38, 11
+  %shl14 = shl i32 %zext13, 11
-  %40 = or i32 %39, %35
+  %22 = or i32 %shl14, %19
-  %41 = and i32 262143, %40
+  %23 = and i32 262143, %22
-  call void (ptr, ...) @printf(ptr @.str.6, i32 %41)
+  call void (ptr, ...) @printf(ptr @.str.6, i32 %23)
   ret void
 }

test/test_suite2/bitstruct/bitstruct_access_signed.c3t

@@ -37,55 +37,55 @@ entry:
   store [3 x i8] c"\E0\FD\7F", ptr %xx, align 1
   %0 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
   %1 = load i8, ptr %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = lshr i32 %2, 5
+  %lshrl = lshr i32 %zext, 5
-  %4 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
+  %2 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
-  %5 = load i8, ptr %4, align 1
+  %3 = load i8, ptr %2, align 1
-  %6 = zext i8 %5 to i32
+  %zext1 = zext i8 %3 to i32
-  %7 = shl i32 %6, 3
+  %shl = shl i32 %zext1, 3
-  %8 = or i32 %7, %3
+  %4 = or i32 %shl, %lshrl
-  %9 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
+  %5 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
-  %10 = load i8, ptr %9, align 1
+  %6 = load i8, ptr %5, align 1
-  %11 = zext i8 %10 to i32
+  %zext2 = zext i8 %6 to i32
-  %12 = shl i32 %11, 11
+  %shl3 = shl i32 %zext2, 11
-  %13 = or i32 %12, %8
+  %7 = or i32 %shl3, %4
-  %14 = shl i32 %13, 14
+  %shl4 = shl i32 %7, 14
-  %15 = ashr i32 %14, 14
+  %ashr = ashr i32 %shl4, 14
-  call void (ptr, ...) @printf(ptr @.str, i32 %15)
+  call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
   store [3 x i8] c"\FF\FD\FF", ptr %xx, align 1
-  %16 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
+  %8 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0
-  %17 = load i8, ptr %16, align 1
+  %9 = load i8, ptr %8, align 1
-  %18 = zext i8 %17 to i32
+  %zext5 = zext i8 %9 to i32
-  %19 = lshr i32 %18, 5
+  %lshrl6 = lshr i32 %zext5, 5
-  %20 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
+  %10 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1
-  %21 = load i8, ptr %20, align 1
+  %11 = load i8, ptr %10, align 1
-  %22 = zext i8 %21 to i32
+  %zext7 = zext i8 %11 to i32
-  %23 = shl i32 %22, 3
+  %shl8 = shl i32 %zext7, 3
-  %24 = or i32 %23, %19
+  %12 = or i32 %shl8, %lshrl6
-  %25 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
+  %13 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2
-  %26 = load i8, ptr %25, align 1
+  %14 = load i8, ptr %13, align 1
-  %27 = zext i8 %26 to i32
+  %zext9 = zext i8 %14 to i32
-  %28 = shl i32 %27, 11
+  %shl10 = shl i32 %zext9, 11
-  %29 = or i32 %28, %24
+  %15 = or i32 %shl10, %12
-  %30 = shl i32 %29, 14
+  %shl11 = shl i32 %15, 14
-  %31 = ashr i32 %30, 14
+  %ashr12 = ashr i32 %shl11, 14
-  call void (ptr, ...) @printf(ptr @.str.1, i32 %31)
+  call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr12)
   store [3 x i8] c"\1F\CF\AA", ptr %xxu, align 1
-  %32 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 0
+  %16 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 0
-  %33 = load i8, ptr %32, align 1
+  %17 = load i8, ptr %16, align 1
-  %34 = zext i8 %33 to i32
+  %zext13 = zext i8 %17 to i32
-  %35 = lshr i32 %34, 5
+  %lshrl14 = lshr i32 %zext13, 5
-  %36 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 1
+  %18 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 1
-  %37 = load i8, ptr %36, align 1
+  %19 = load i8, ptr %18, align 1
-  %38 = zext i8 %37 to i32
+  %zext15 = zext i8 %19 to i32
-  %39 = shl i32 %38, 3
+  %shl16 = shl i32 %zext15, 3
-  %40 = or i32 %39, %35
+  %20 = or i32 %shl16, %lshrl14
-  %41 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 2
+  %21 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 2
-  %42 = load i8, ptr %41, align 1
+  %22 = load i8, ptr %21, align 1
-  %43 = zext i8 %42 to i32
+  %zext17 = zext i8 %22 to i32
-  %44 = shl i32 %43, 11
+  %shl18 = shl i32 %zext17, 11
-  %45 = or i32 %44, %40
+  %23 = or i32 %shl18, %20
-  %46 = and i32 262143, %45
+  %24 = and i32 262143, %23
-  call void (ptr, ...) @printf(ptr @.str.2, i32 %46)
+  call void (ptr, ...) @printf(ptr @.str.2, i32 %24)
   ret void
 }

test/test_suite2/bitstruct/bitstruct_arrays_be.c3t

@@ -46,99 +46,99 @@ entry:
   store [4 x i8] c"\E0\FB\0A\00", ptr %xx, align 1
   %0 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
   %1 = load i8, ptr %0, align 1
-  %2 = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %3 = lshr i32 %2, 4
+  %lshrl = lshr i32 %zext, 4
-  %4 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
+  %2 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
-  %5 = load i8, ptr %4, align 1
+  %3 = load i8, ptr %2, align 1
-  %6 = zext i8 %5 to i32
+  %zext1 = zext i8 %3 to i32
-  %7 = shl i32 %6, 4
+  %shl = shl i32 %zext1, 4
-  %8 = or i32 %7, %3
+  %4 = or i32 %shl, %lshrl
-  %9 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
+  %5 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
-  %10 = load i8, ptr %9, align 1
+  %6 = load i8, ptr %5, align 1
-  %11 = zext i8 %10 to i32
+  %zext2 = zext i8 %6 to i32
-  %12 = shl i32 %11, 12
+  %shl3 = shl i32 %zext2, 12
-  %13 = or i32 %12, %8
+  %7 = or i32 %shl3, %4
-  %14 = shl i32 %13, 16
+  %shl4 = shl i32 %7, 16
-  %15 = call i32 @llvm.bswap.i32(i32 %14)
+  %8 = call i32 @llvm.bswap.i32(i32 %shl4)
-  %16 = and i32 65535, %15
+  %9 = and i32 65535, %8
-  call void (ptr, ...) @printf(ptr @.str, i32 %16)
+  call void (ptr, ...) @printf(ptr @.str, i32 %9)
   store [4 x i8] c"\F0\EA\0B\00", ptr %xy, align 1
   store ptr %xy, ptr %abc, align 8
-  %17 = load ptr, ptr %abc, align 8
+  %10 = load ptr, ptr %abc, align 8
-  store ptr %17, ptr %z, align 8
+  store ptr %10, ptr %z, align 8
-  %18 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
+  %11 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
-  %19 = load i8, ptr %18, align 1
+  %12 = load i8, ptr %11, align 1
-  %20 = zext i8 %19 to i32
+  %zext5 = zext i8 %12 to i32
-  %21 = lshr i32 %20, 4
+  %lshrl6 = lshr i32 %zext5, 4
-  %22 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
+  %13 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
-  %23 = load i8, ptr %22, align 1
+  %14 = load i8, ptr %13, align 1
-  %24 = zext i8 %23 to i32
+  %zext7 = zext i8 %14 to i32
-  %25 = shl i32 %24, 4
+  %shl8 = shl i32 %zext7, 4
-  %26 = or i32 %25, %21
+  %15 = or i32 %shl8, %lshrl6
-  %27 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
+  %16 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
-  %28 = load i8, ptr %27, align 1
+  %17 = load i8, ptr %16, align 1
-  %29 = zext i8 %28 to i32
+  %zext9 = zext i8 %17 to i32
-  %30 = shl i32 %29, 12
+  %shl10 = shl i32 %zext9, 12
-  %31 = or i32 %30, %26
+  %18 = or i32 %shl10, %15
-  %32 = and i32 65535, %31
+  %19 = and i32 65535, %18
-  call void (ptr, ...) @printf(ptr @.str.1, i32 %32)
+  call void (ptr, ...) @printf(ptr @.str.1, i32 %19)
-  %33 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
+  %20 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
-  %34 = load i8, ptr %33, align 1
+  %21 = load i8, ptr %20, align 1
-  %35 = and i8 %34, 15
+  %22 = and i8 %21, 15
-  %36 = or i8 %35, -16
+  %23 = or i8 %22, -16
-  store i8 %36, ptr %33, align 1
+  store i8 %23, ptr %20, align 1
-  %37 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
+  %24 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
-  store i8 -18, ptr %37, align 1
+  store i8 -18, ptr %24, align 1
-  %38 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
+  %25 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
+  %26 = load i8, ptr %25, align 1
+  %27 = and i8 %26, -16
+  %28 = or i8 %27, 11
+  store i8 %28, ptr %25, align 1
+  %29 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
+  %30 = load i8, ptr %29, align 1
+  %zext11 = zext i8 %30 to i32
+  %lshrl12 = lshr i32 %zext11, 4
+  %31 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
+  %32 = load i8, ptr %31, align 1
+  %zext13 = zext i8 %32 to i32
+  %shl14 = shl i32 %zext13, 4
+  %33 = or i32 %shl14, %lshrl12
+  %34 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
+  %35 = load i8, ptr %34, align 1
+  %zext15 = zext i8 %35 to i32
+  %shl16 = shl i32 %zext15, 12
+  %36 = or i32 %shl16, %33
+  %37 = and i32 65535, %36
+  call void (ptr, ...) @printf(ptr @.str.2, i32 %37)
+  %38 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
   %39 = load i8, ptr %38, align 1
-  %40 = and i8 %39, -16
+  %40 = and i8 %39, 15
-  %41 = or i8 %40, 11
+  %41 = or i8 %40, -32
   store i8 %41, ptr %38, align 1
-  %42 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0
+  %42 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
-  %43 = load i8, ptr %42, align 1
+  store i8 -5, ptr %42, align 1
-  %44 = zext i8 %43 to i32
+  %43 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
-  %45 = lshr i32 %44, 4
+  %44 = load i8, ptr %43, align 1
-  %46 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1
+  %45 = and i8 %44, -16
-  %47 = load i8, ptr %46, align 1
+  %46 = or i8 %45, 14
-  %48 = zext i8 %47 to i32
+  store i8 %46, ptr %43, align 1
-  %49 = shl i32 %48, 4
+  %47 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
-  %50 = or i32 %49, %45
+  %48 = load i8, ptr %47, align 1
-  %51 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2
+  %zext17 = zext i8 %48 to i32
-  %52 = load i8, ptr %51, align 1
+  %lshrl18 = lshr i32 %zext17, 4
-  %53 = zext i8 %52 to i32
+  %49 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
-  %54 = shl i32 %53, 12
+  %50 = load i8, ptr %49, align 1
-  %55 = or i32 %54, %50
+  %zext19 = zext i8 %50 to i32
+  %shl20 = shl i32 %zext19, 4
+  %51 = or i32 %shl20, %lshrl18
+  %52 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
+  %53 = load i8, ptr %52, align 1
+  %zext21 = zext i8 %53 to i32
+  %shl22 = shl i32 %zext21, 12
+  %54 = or i32 %shl22, %51
+  %shl23 = shl i32 %54, 16
+  %55 = call i32 @llvm.bswap.i32(i32 %shl23)
   %56 = and i32 65535, %55
-  call void (ptr, ...) @printf(ptr @.str.2, i32 %56)
+  call void (ptr, ...) @printf(ptr @.str.3, i32 %56)
-  %57 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
-  %58 = load i8, ptr %57, align 1
-  %59 = and i8 %58, 15
-  %60 = or i8 %59, -32
-  store i8 %60, ptr %57, align 1
-  %61 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
-  store i8 -5, ptr %61, align 1
-  %62 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
-  %63 = load i8, ptr %62, align 1
-  %64 = and i8 %63, -16
-  %65 = or i8 %64, 14
-  store i8 %65, ptr %62, align 1
-  %66 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0
-  %67 = load i8, ptr %66, align 1
-  %68 = zext i8 %67 to i32
-  %69 = lshr i32 %68, 4
-  %70 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1
-  %71 = load i8, ptr %70, align 1
-  %72 = zext i8 %71 to i32
-  %73 = shl i32 %72, 4
-  %74 = or i32 %73, %69
-  %75 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2
-  %76 = load i8, ptr %75, align 1
-  %77 = zext i8 %76 to i32
-  %78 = shl i32 %77, 12
-  %79 = or i32 %78, %74
-  %80 = shl i32 %79, 16
-  %81 = call i32 @llvm.bswap.i32(i32 %80)
-  %82 = and i32 65535, %81
-  call void (ptr, ...) @printf(ptr @.str.3, i32 %82)
   ret void
 }

test/test_suite2/bitstruct/bitstruct_intcontainer.c3t

@@ -57,49 +57,49 @@ entry:
   %xxybe = alloca i64, align 8
   store i32 8388128, ptr %xx, align 4
   %0 = load i32, ptr %xx, align 4
-  %1 = shl i32 %0, 9
+  %shl = shl i32 %0, 9
-  %2 = ashr i32 %1, 14
+  %ashr = ashr i32 %shl, 14
-  call void (ptr, ...) @printf(ptr @.str, i32 %2)
+  call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
   store i32 1073741375, ptr %xx, align 4
-  %3 = load i32, ptr %xx, align 4
+  %1 = load i32, ptr %xx, align 4
-  %4 = shl i32 %3, 9
+  %shl1 = shl i32 %1, 9
-  %5 = ashr i32 %4, 14
+  %ashr2 = ashr i32 %shl1, 14
-  call void (ptr, ...) @printf(ptr @.str.1, i32 %5)
+  call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr2)
   store i32 -3485921, ptr %xxu, align 4
-  %6 = load i32, ptr %xxu, align 4
+  %2 = load i32, ptr %xxu, align 4
-  %7 = lshr i32 %6, 5
+  %lshrl = lshr i32 %2, 5
-  %8 = and i32 262143, %7
+  %3 = and i32 262143, %lshrl
-  call void (ptr, ...) @printf(ptr @.str.2, i32 %8)
+  call void (ptr, ...) @printf(ptr @.str.2, i32 %3)
   store i64 1525363991714123551, ptr %xxy, align 8
-  %9 = load i64, ptr %xxy, align 8
+  %4 = load i64, ptr %xxy, align 8
-  %10 = lshr i64 %9, 5
+  %lshrl3 = lshr i64 %4, 5
-  %11 = and i64 262143, %10
+  %5 = and i64 262143, %lshrl3
-  %12 = trunc i64 %11 to i32
+  %ztrunc = trunc i64 %5 to i32
-  %13 = load i64, ptr %xxy, align 8
+  %6 = load i64, ptr %xxy, align 8
-  %14 = lshr i64 %13, 23
+  %lshrl4 = lshr i64 %6, 23
-  %15 = and i64 262143, %14
+  %7 = and i64 262143, %lshrl4
-  %16 = trunc i64 %15 to i32
+  %ztrunc5 = trunc i64 %7 to i32
-  %17 = load i64, ptr %xxy, align 8
+  %8 = load i64, ptr %xxy, align 8
-  %18 = lshr i64 %17, 41
+  %lshrl6 = lshr i64 %8, 41
-  %19 = and i64 2097151, %18
+  %9 = and i64 2097151, %lshrl6
-  %20 = trunc i64 %19 to i32
+  %ztrunc7 = trunc i64 %9 to i32
-  call void (ptr, ...) @printf(ptr @.str.3, i32 %12, i32 %16, i32 %20)
+  call void (ptr, ...) @printf(ptr @.str.3, i32 %ztrunc, i32 %ztrunc5, i32 %ztrunc7)
   store i64 2292133196431502101, ptr %xxybe, align 8
-  %21 = load i64, ptr %xxybe, align 8
+  %10 = load i64, ptr %xxybe, align 8
-  %22 = call i64 @llvm.bswap.i64(i64 %21)
+  %11 = call i64 @llvm.bswap.i64(i64 %10)
-  %23 = lshr i64 %22, 5
+  %lshrl8 = lshr i64 %11, 5
-  %24 = and i64 262143, %23
+  %12 = and i64 262143, %lshrl8
-  %25 = trunc i64 %24 to i32
+  %ztrunc9 = trunc i64 %12 to i32
-  %26 = load i64, ptr %xxybe, align 8
+  %13 = load i64, ptr %xxybe, align 8
-  %27 = call i64 @llvm.bswap.i64(i64 %26)
+  %14 = call i64 @llvm.bswap.i64(i64 %13)
-  %28 = lshr i64 %27, 23
+  %lshrl10 = lshr i64 %14, 23
-  %29 = and i64 262143, %28
+  %15 = and i64 262143, %lshrl10
-  %30 = trunc i64 %29 to i32
+  %ztrunc11 = trunc i64 %15 to i32
-  %31 = load i64, ptr %xxybe, align 8
+  %16 = load i64, ptr %xxybe, align 8
-  %32 = call i64 @llvm.bswap.i64(i64 %31)
+  %17 = call i64 @llvm.bswap.i64(i64 %16)
-  %33 = lshr i64 %32, 41
+  %lshrl12 = lshr i64 %17, 41
-  %34 = and i64 2097151, %33
+  %18 = and i64 2097151, %lshrl12
-  %35 = trunc i64 %34 to i32
+  %ztrunc13 = trunc i64 %18 to i32
-  call void (ptr, ...) @printf(ptr @.str.4, i32 %25, i32 %30, i32 %35)
+  call void (ptr, ...) @printf(ptr @.str.4, i32 %ztrunc9, i32 %ztrunc11, i32 %ztrunc13)
   ret void
 }

test/test_suite2/bitstruct/bitstruct_to_int.c3t

@@ -64,12 +64,12 @@ entry:
   store ptr %b, ptr %c, align 8
   %2 = load ptr, ptr %c, align 8
   %3 = load i32, ptr %2, align 8
-  %4 = shl i32 %3, 28
+  %shl = shl i32 %3, 28
-  %5 = ashr i32 %4, 29
+  %ashr = ashr i32 %shl, 29
-  %6 = load ptr, ptr %c, align 8
+  %4 = load ptr, ptr %c, align 8
-  store ptr %6, ptr %x2, align 8
+  store ptr %4, ptr %x2, align 8
-  %7 = load ptr, ptr %c, align 8
+  %5 = load ptr, ptr %c, align 8
-  store ptr %7, ptr %y2, align 8
+  store ptr %5, ptr %y2, align 8
   ret void
 }
 
@@ -90,14 +90,14 @@ entry:
   %1 = load ptr, ptr %c, align 8
   %2 = getelementptr inbounds [4 x i8], ptr %1, i64 0, i64 0
   %3 = load i8, ptr %2, align 1
-  %4 = zext i8 %3 to i32
+  %zext = zext i8 %3 to i32
-  %5 = lshr i32 %4, 1
+  %lshrl = lshr i32 %zext, 1
-  %6 = shl i32 %5, 29
+  %shl = shl i32 %lshrl, 29
-  %7 = ashr i32 %6, 29
+  %ashr = ashr i32 %shl, 29
-  call void (ptr, ...) @printf(ptr @.str, i32 %7)
+  call void (ptr, ...) @printf(ptr @.str, i32 %ashr)
-  %8 = load ptr, ptr %c, align 8
+  %4 = load ptr, ptr %c, align 8
-  store ptr %8, ptr %x2, align 8
+  store ptr %4, ptr %x2, align 8
-  %9 = load ptr, ptr %c, align 8
+  %5 = load ptr, ptr %c, align 8
-  store ptr %9, ptr %y2, align 8
+  store ptr %5, ptr %y2, align 8
   ret void
 }

test/test_suite2/bitstruct/embedded_bitstruct.c3t

@@ -57,23 +57,23 @@ entry:
   %3 = load i32, ptr %2, align 4
   %4 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 2
   %5 = load i32, ptr %4, align 4
-  %6 = shl i32 %5, 21
+  %shl = shl i32 %5, 21
-  %7 = ashr i32 %6, 23
+  %ashr = ashr i32 %shl, 23
-  call void (ptr, ...) @printf(ptr @.str, i32 %3, i32 %7)
+  call void (ptr, ...) @printf(ptr @.str, i32 %3, i32 %ashr)
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %f, ptr align 4 @.__const.10, i32 16, i1 false)
-  %8 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
+  %6 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
-  %9 = getelementptr inbounds %anon.1, ptr %8, i32 0, i32 0
+  %7 = getelementptr inbounds %anon.1, ptr %6, i32 0, i32 0
-  %10 = getelementptr inbounds %anon.2, ptr %9, i32 0, i32 0
+  %8 = getelementptr inbounds %anon.2, ptr %7, i32 0, i32 0
-  %11 = load i32, ptr %10, align 4
+  %9 = load i32, ptr %8, align 4
-  %12 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
+  %10 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
-  %13 = getelementptr inbounds %anon.1, ptr %12, i32 0, i32 1
+  %11 = getelementptr inbounds %anon.1, ptr %10, i32 0, i32 1
-  %14 = getelementptr inbounds %anon.3, ptr %13, i32 0, i32 0
+  %12 = getelementptr inbounds %anon.3, ptr %11, i32 0, i32 0
-  %15 = load i32, ptr %14, align 4
+  %13 = load i32, ptr %12, align 4
-  %16 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
+  %14 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0
-  %17 = getelementptr inbounds %anon.1, ptr %16, i32 0, i32 2
+  %15 = getelementptr inbounds %anon.1, ptr %14, i32 0, i32 2
+  %16 = load i32, ptr %15, align 4
+  %17 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 1
   %18 = load i32, ptr %17, align 4
-  %19 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 1
+  call void (ptr, ...) @printf(ptr @.str.11, i32 %9, i32 %13, i32 %16, i32 %18)
-  %20 = load i32, ptr %19, align 4
-  call void (ptr, ...) @printf(ptr @.str.11, i32 %11, i32 %15, i32 %18, i32 %20)
   ret void
 }

test/test_suite2/cast/top_down_casts.c3t

@@ -15,7 +15,7 @@ fn void test()
     z = w ?? 1;
 }
 
-// #expect: top_down_casts.ll
+/* #expect: top_down_casts.ll
 
 define void @top_down_casts_test() #0 {
 entry:
@@ -59,43 +59,43 @@ entry:
   %10 = load i32, ptr %x, align 4
   %sisiext10 = sext i32 %10 to i64
   %11 = load i32, ptr %y, align 4
-  %12 = zext i32 %11 to i64
+  %zext = zext i32 %11 to i64
-  %shl = shl i64 %sisiext10, %12
+  %shl = shl i64 %sisiext10, %zext
-  %13 = freeze i64 %shl
+  %12 = freeze i64 %shl
-  store i64 %13, ptr %z, align 8
+  store i64 %12, ptr %z, align 8
-  %14 = load i32, ptr %x, align 4
+  %13 = load i32, ptr %x, align 4
-  %sisiext11 = sext i32 %14 to i64
+  %sisiext11 = sext i32 %13 to i64
-  %15 = load i32, ptr %y, align 4
+  %14 = load i32, ptr %y, align 4
-  %16 = zext i32 %15 to i64
+  %zext12 = zext i32 %14 to i64
-  %ashr = ashr i64 %sisiext11, %16
+  %ashr = ashr i64 %sisiext11, %zext12
-  %17 = freeze i64 %ashr
+  %15 = freeze i64 %ashr
-  store i64 %17, ptr %z, align 8
+  store i64 %15, ptr %z, align 8
-  %18 = load i32, ptr %x, align 4
+  %16 = load i32, ptr %x, align 4
-  %sisiext12 = sext i32 %18 to i64
+  %sisiext13 = sext i32 %16 to i64
-  %bnot = xor i64 %sisiext12, -1
+  %bnot = xor i64 %sisiext13, -1
   store i64 %bnot, ptr %z, align 8
-  %19 = load i32, ptr %x, align 4
+  %17 = load i32, ptr %x, align 4
-  %sisiext13 = sext i32 %19 to i64
+  %sisiext14 = sext i32 %17 to i64
-  %20 = load i32, ptr %x, align 4
+  %18 = load i32, ptr %x, align 4
-  %sisiext14 = sext i32 %20 to i64
+  %sisiext15 = sext i32 %18 to i64
-  %neg = sub i64 0, %sisiext14
+  %neg = sub i64 0, %sisiext15
   store i64 %neg, ptr %z, align 8
   store i64 0, ptr %w.f, align 8
   store i32 0, ptr %w, align 4
-  %21 = load i64, ptr %w.f, align 8
+  %optval = load i64, ptr %w.f, align 8
-  %not_err = icmp eq i64 %21, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %else_block
 
 after_check:                                      ; preds = %entry
-  %22 = load i32, ptr %w, align 4
+  %19 = load i32, ptr %w, align 4
-  %sisiext15 = sext i32 %22 to i64
+  %sisiext16 = sext i32 %19 to i64
   br label %phi_block
 
 else_block:                                       ; preds = %entry
   br label %phi_block
 
 phi_block:                                        ; preds = %else_block, %after_check
-  %val = phi i64 [ %sisiext15, %after_check ], [ 1, %else_block ]
+  %val = phi i64 [ %sisiext16, %after_check ], [ 1, %else_block ]
   store i64 %val, ptr %z, align 8
   ret void
 }

test/test_suite2/clang/2002-04.c3t

@@ -114,8 +114,8 @@ define double @test_test(i32 %0) #0 {
 entry:
   %student_t = alloca [30 x double], align 16
   call void @llvm.memcpy.p0.p0.i32(ptr align 16 %student_t, ptr align 16 @.__const, i32 240, i1 false)
-  %uiuiext = zext i32 %0 to i64
+  %zext = zext i32 %0 to i64
-  %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %uiuiext
+  %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %zext
   %2 = load double, ptr %1, align 8
   ret double %2
 }

test/test_suite2/enumerations/enum_cast.c3t

@@ -76,17 +76,17 @@ entry:
   %uifp = uitofp i8 %2 to float
   store float %uifp, ptr %e, align 4
   store i64 0, ptr %e.f, align 8
-  %3 = load i64, ptr %xf.f, align 8
+  %optval = load i64, ptr %xf.f, align 8
-  %not_err = icmp eq i64 %3, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %3, ptr %e.f, align 8
+  store i64 %optval, ptr %e.f, align 8
   br label %after_assign
 
 after_check:                                      ; preds = %entry
-  %4 = load i8, ptr %xf, align 1
+  %3 = load i8, ptr %xf, align 1
-  %uifp1 = uitofp i8 %4 to float
+  %uifp1 = uitofp i8 %3 to float
   store float %uifp1, ptr %e, align 4
   store i64 0, ptr %e.f, align 8
   br label %after_assign

test/test_suite2/errors/error_regression_2.c3t

@@ -356,12 +356,11 @@ if.then15:                                        ; preds = %if.exit9
   %24 = getelementptr inbounds %Doc, ptr %literal17, i32 0, i32 0
   %25 = getelementptr inbounds %Head, ptr %literal18, i32 0, i32 0
   store ptr null, ptr %25, align 8
-  %26 = load %Head, ptr %literal18, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value, ptr align 8 %literal18, i32 8, i1 false)
-  store %Head %26, ptr %value, align 8
+  %26 = call ptr @std_core_mem_malloc(i64 8) #2
-  %27 = call ptr @std_core_mem_malloc(i64 8) #2
+  store ptr %26, ptr %temp, align 8
-  store ptr %27, ptr %temp, align 8
+  %27 = load ptr, ptr %temp, align 8
-  %28 = load ptr, ptr %temp, align 8
+  %not = icmp eq ptr %27, null
-  %not = icmp eq ptr %28, null
   br i1 %not, label %if.then19, label %if.exit20
 
 if.then19:                                        ; preds = %if.then15
@@ -369,43 +368,43 @@ if.then19:                                        ; preds = %if.then15
   br label %guard_block
 
 if.exit20:                                        ; preds = %if.then15
-  %29 = load ptr, ptr %temp, align 8
+  %28 = load ptr, ptr %temp, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %29, ptr align 8 %value, i32 8, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %28, ptr align 8 %value, i32 8, i1 false)
   br label %noerr_block
 
 guard_block:                                      ; preds = %if.then19
-  %30 = load i64, ptr %error_var, align 8
+  %29 = load i64, ptr %error_var, align 8
-  ret i64 %30
+  ret i64 %29
 
 noerr_block:                                      ; preds = %if.exit20
-  %31 = load ptr, ptr %temp, align 8
+  %30 = load ptr, ptr %temp, align 8
-  store ptr %31, ptr %24, align 8
+  store ptr %30, ptr %24, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal17, i32 8, i1 false)
   ret i64 0
 
 if.exit21:                                        ; preds = %if.exit9
-  %32 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0
+  %31 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0
-  %lo22 = load ptr, ptr %32, align 8
+  %lo22 = load ptr, ptr %31, align 8
-  %33 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1
+  %32 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1
-  %hi23 = load i64, ptr %33, align 8
+  %hi23 = load i64, ptr %32, align 8
   store %"char[]" { ptr @.str.5, i64 11 }, ptr %taddr24, align 8
-  %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 0
+  %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 0
-  %lo25 = load ptr, ptr %34, align 8
+  %lo25 = load ptr, ptr %33, align 8
-  %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 1
+  %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 1
-  %hi26 = load i64, ptr %35, align 8
+  %hi26 = load i64, ptr %34, align 8
-  %36 = call i8 @test_contains(ptr %lo22, i64 %hi23, ptr %lo25, i64 %hi26)
+  %35 = call i8 @test_contains(ptr %lo22, i64 %hi23, ptr %lo25, i64 %hi26)
-  %37 = trunc i8 %36 to i1
+  %36 = trunc i8 %35 to i1
-  br i1 %37, label %if.then27, label %if.exit47
+  br i1 %36, label %if.then27, label %if.exit47
 
 if.then27:                                        ; preds = %if.exit21
-  %38 = getelementptr inbounds %Doc, ptr %literal29, i32 0, i32 0
+  %37 = getelementptr inbounds %Doc, ptr %literal29, i32 0, i32 0
   store ptr null, ptr %literal32, align 8
-  %39 = getelementptr inbounds %Head, ptr %literal32, i32 0, i32 0
+  %38 = getelementptr inbounds %Head, ptr %literal32, i32 0, i32 0
   store %"char[]" zeroinitializer, ptr %value34, align 8
-  %40 = call ptr @std_core_mem_malloc(i64 16) #2
+  %39 = call ptr @std_core_mem_malloc(i64 16) #2
-  store ptr %40, ptr %temp35, align 8
+  store ptr %39, ptr %temp35, align 8
-  %41 = load ptr, ptr %temp35, align 8
+  %40 = load ptr, ptr %temp35, align 8
-  %not36 = icmp eq ptr %41, null
+  %not36 = icmp eq ptr %40, null
   br i1 %not36, label %if.then37, label %if.exit38
 
 if.then37:                                        ; preds = %if.then27
@@ -413,23 +412,22 @@ if.then37:                                        ; preds = %if.then27
   br label %guard_block39
 
 if.exit38:                                        ; preds = %if.then27
-  %42 = load ptr, ptr %temp35, align 8
+  %41 = load ptr, ptr %temp35, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %42, ptr align 8 %value34, i32 16, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %41, ptr align 8 %value34, i32 16, i1 false)
   br label %noerr_block40
 
 guard_block39:                                    ; preds = %if.then37
-  %43 = load i64, ptr %error_var33, align 8
+  %42 = load i64, ptr %error_var33, align 8
-  ret i64 %43
+  ret i64 %42
 
 noerr_block40:                                    ; preds = %if.exit38
-  %44 = load ptr, ptr %temp35, align 8
+  %43 = load ptr, ptr %temp35, align 8
-  store ptr %44, ptr %39, align 8
+  store ptr %43, ptr %38, align 8
-  %45 = load %Head, ptr %literal32, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value31, ptr align 8 %literal32, i32 8, i1 false)
-  store %Head %45, ptr %value31, align 8
+  %44 = call ptr @std_core_mem_malloc(i64 8) #2
-  %46 = call ptr @std_core_mem_malloc(i64 8) #2
+  store ptr %44, ptr %temp41, align 8
-  store ptr %46, ptr %temp41, align 8
+  %45 = load ptr, ptr %temp41, align 8
-  %47 = load ptr, ptr %temp41, align 8
+  %not42 = icmp eq ptr %45, null
-  %not42 = icmp eq ptr %47, null
   br i1 %not42, label %if.then43, label %if.exit44
 
 if.then43:                                        ; preds = %noerr_block40
@@ -437,68 +435,68 @@ if.then43:                                        ; preds = %noerr_block40
   br label %guard_block45
 
 if.exit44:                                        ; preds = %noerr_block40
-  %48 = load ptr, ptr %temp41, align 8
+  %46 = load ptr, ptr %temp41, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %48, ptr align 8 %value31, i32 8, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %46, ptr align 8 %value31, i32 8, i1 false)
   br label %noerr_block46
 
 guard_block45:                                    ; preds = %if.then43
-  %49 = load i64, ptr %error_var30, align 8
+  %47 = load i64, ptr %error_var30, align 8
-  ret i64 %49
+  ret i64 %47
 
 noerr_block46:                                    ; preds = %if.exit44
-  %50 = load ptr, ptr %temp41, align 8
+  %48 = load ptr, ptr %temp41, align 8
-  store ptr %50, ptr %38, align 8
+  store ptr %48, ptr %37, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal29, i32 8, i1 false)
   ret i64 0
 
 if.exit47:                                        ; preds = %if.exit21
-  %51 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
+  %49 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
-  %52 = load i64, ptr %51, align 8
+  %50 = load i64, ptr %49, align 8
-  %uisitrunc = trunc i64 %52 to i32
+  %uisitrunc = trunc i64 %50 to i32
-  %53 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
+  %51 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
-  %54 = load ptr, ptr %53, align 8
+  %52 = load ptr, ptr %51, align 8
-  %55 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.7, i32 %uisitrunc, ptr %54)
+  %53 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.7, i32 %uisitrunc, ptr %52)
-  store i32 %55, ptr %len, align 4
+  store i32 %53, ptr %len, align 4
-  %56 = load i32, ptr %len, align 4
+  %54 = load i32, ptr %len, align 4
-  %siuiext = sext i32 %56 to i64
+  %siuiext = sext i32 %54 to i64
   %add = add i64 %siuiext, 1
-  %57 = call ptr @std_core_mem_malloc(i64 %add) #2
+  %55 = call ptr @std_core_mem_malloc(i64 %add) #2
-  store ptr %57, ptr %str, align 8
+  store ptr %55, ptr %str, align 8
-  %58 = load ptr, ptr %str, align 8
+  %56 = load ptr, ptr %str, align 8
-  %not48 = icmp eq ptr %58, null
+  %not48 = icmp eq ptr %56, null
   br i1 %not48, label %if.then49, label %if.exit50
 
 if.then49:                                        ; preds = %if.exit47
   ret i64 ptrtoint (ptr @"test_ReadError$OUT_OF_MEMORY" to i64)
 
 if.exit50:                                        ; preds = %if.exit47
-  %59 = load ptr, ptr %str, align 8
+  %57 = load ptr, ptr %str, align 8
-  %60 = load i32, ptr %len, align 4
+  %58 = load i32, ptr %len, align 4
-  %siuiext51 = sext i32 %60 to i64
+  %siuiext51 = sext i32 %58 to i64
   %add52 = add i64 %siuiext51, 1
-  %61 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
+  %59 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1
-  %62 = load i64, ptr %61, align 8
+  %60 = load i64, ptr %59, align 8
-  %uisitrunc53 = trunc i64 %62 to i32
+  %uisitrunc53 = trunc i64 %60 to i32
-  %63 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
+  %61 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0
-  %64 = load ptr, ptr %63, align 8
+  %62 = load ptr, ptr %61, align 8
-  %65 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %59, i64 %add52, ptr @.str.8, i32 %uisitrunc53, ptr %64)
+  %63 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %57, i64 %add52, ptr @.str.8, i32 %uisitrunc53, ptr %62)
-  %66 = getelementptr inbounds %Doc, ptr %literal55, i32 0, i32 0
+  %64 = getelementptr inbounds %Doc, ptr %literal55, i32 0, i32 0
   store ptr null, ptr %literal58, align 8
-  %67 = getelementptr inbounds %Head, ptr %literal58, i32 0, i32 0
+  %65 = getelementptr inbounds %Head, ptr %literal58, i32 0, i32 0
-  %68 = load ptr, ptr %str, align 8
+  %66 = load ptr, ptr %str, align 8
-  %69 = load i32, ptr %len, align 4
+  %67 = load i32, ptr %len, align 4
-  %sub = sub i32 %69, 1
+  %sub = sub i32 %67, 1
   %sisiext = sext i32 %sub to i64
-  %70 = add i64 %sisiext, 1
+  %68 = add i64 %sisiext, 1
-  %size = sub i64 %70, 0
+  %size = sub i64 %68, 0
-  %ptroffset = getelementptr inbounds i8, ptr %68, i64 0
+  %ptroffset = getelementptr inbounds i8, ptr %66, i64 0
-  %71 = insertvalue %"char[]" undef, ptr %ptroffset, 0
+  %69 = insertvalue %"char[]" undef, ptr %ptroffset, 0
-  %72 = insertvalue %"char[]" %71, i64 %size, 1
+  %70 = insertvalue %"char[]" %69, i64 %size, 1
-  store %"char[]" %72, ptr %value60, align 8
+  store %"char[]" %70, ptr %value60, align 8
-  %73 = call ptr @std_core_mem_malloc(i64 16) #2
+  %71 = call ptr @std_core_mem_malloc(i64 16) #2
-  store ptr %73, ptr %temp61, align 8
+  store ptr %71, ptr %temp61, align 8
-  %74 = load ptr, ptr %temp61, align 8
+  %72 = load ptr, ptr %temp61, align 8
-  %not62 = icmp eq ptr %74, null
+  %not62 = icmp eq ptr %72, null
   br i1 %not62, label %if.then63, label %if.exit64
 
 if.then63:                                        ; preds = %if.exit50
@@ -506,23 +504,22 @@ if.then63:                                        ; preds = %if.exit50
   br label %guard_block65
 
 if.exit64:                                        ; preds = %if.exit50
-  %75 = load ptr, ptr %temp61, align 8
+  %73 = load ptr, ptr %temp61, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %75, ptr align 8 %value60, i32 16, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %73, ptr align 8 %value60, i32 16, i1 false)
   br label %noerr_block66
 
 guard_block65:                                    ; preds = %if.then63
-  %76 = load i64, ptr %error_var59, align 8
+  %74 = load i64, ptr %error_var59, align 8
-  ret i64 %76
+  ret i64 %74
 
 noerr_block66:                                    ; preds = %if.exit64
-  %77 = load ptr, ptr %temp61, align 8
+  %75 = load ptr, ptr %temp61, align 8
-  store ptr %77, ptr %67, align 8
+  store ptr %75, ptr %65, align 8
-  %78 = load %Head, ptr %literal58, align 8
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value57, ptr align 8 %literal58, i32 8, i1 false)
-  store %Head %78, ptr %value57, align 8
+  %76 = call ptr @std_core_mem_malloc(i64 8) #2
-  %79 = call ptr @std_core_mem_malloc(i64 8) #2
+  store ptr %76, ptr %temp67, align 8
-  store ptr %79, ptr %temp67, align 8
+  %77 = load ptr, ptr %temp67, align 8
-  %80 = load ptr, ptr %temp67, align 8
+  %not68 = icmp eq ptr %77, null
-  %not68 = icmp eq ptr %80, null
   br i1 %not68, label %if.then69, label %if.exit70
 
 if.then69:                                        ; preds = %noerr_block66
@@ -530,17 +527,17 @@ if.then69:                                        ; preds = %noerr_block66
   br label %guard_block71
 
 if.exit70:                                        ; preds = %noerr_block66
-  %81 = load ptr, ptr %temp67, align 8
+  %78 = load ptr, ptr %temp67, align 8
-  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %81, ptr align 8 %value57, i32 8, i1 false)
+  call void @llvm.memcpy.p0.p0.i32(ptr align 8 %78, ptr align 8 %value57, i32 8, i1 false)
   br label %noerr_block72
 
 guard_block71:                                    ; preds = %if.then69
-  %82 = load i64, ptr %error_var56, align 8
+  %79 = load i64, ptr %error_var56, align 8
-  ret i64 %82
+  ret i64 %79
 
 noerr_block72:                                    ; preds = %if.exit70
-  %83 = load ptr, ptr %temp67, align 8
+  %80 = load ptr, ptr %temp67, align 8
-  store ptr %83, ptr %66, align 8
+  store ptr %80, ptr %64, align 8
   call void @llvm.memcpy.p0.p0.i32(ptr align 8 %0, ptr align 8 %literal55, i32 8, i1 false)
   ret i64 0
 }
@@ -789,7 +786,7 @@ entry:
   store i64 %8, ptr %anon1, align 8
   br label %loop.cond
 
-loop.cond:                                        ; preds = %phi_block11, %entry
+loop.cond:                                        ; preds = %phi_block12, %entry
   %9 = load i64, ptr %anon, align 8
   %10 = load i64, ptr %anon1, align 8
   %lt = icmp ult i64 %9, %10
@@ -860,40 +857,40 @@ after_check:                                      ; preds = %cond.phi
   br label %after_assign
 
 after_assign:                                     ; preds = %after_check, %assign_optional
-  %39 = load i64, ptr %has_title.f, align 8
+  %optval = load i64, ptr %has_title.f, align 8
-  %not_err5 = icmp eq i64 %39, 0
+  %not_err5 = icmp eq i64 %optval, 0
   br i1 %not_err5, label %after_check6, label %else_block
 
 after_check6:                                     ; preds = %after_assign
-  %40 = load i8, ptr %has_title, align 1
+  %39 = load i8, ptr %has_title, align 1
-  %41 = call ptr @test_bool_to_string(i8 %40)
+  %40 = call ptr @test_bool_to_string(i8 %39)
   br label %phi_block
 
 else_block:                                       ; preds = %after_assign
-  %42 = load i64, ptr %has_title.f, align 8
+  %41 = load i64, ptr %has_title.f, align 8
-  %43 = call ptr @test_nameFromError(i64 %42)
+  %42 = call ptr @test_nameFromError(i64 %41)
   br label %phi_block
 
 phi_block:                                        ; preds = %else_block, %after_check6
-  %val7 = phi ptr [ %41, %after_check6 ], [ %43, %else_block ]
+  %val7 = phi ptr [ %40, %after_check6 ], [ %42, %else_block ]
-  %44 = load i64, ptr %has_title.f, align 8
+  %optval8 = load i64, ptr %has_title.f, align 8
-  %not_err8 = icmp eq i64 %44, 0
+  %not_err9 = icmp eq i64 %optval8, 0
-  br i1 %not_err8, label %after_check9, label %else_block10
+  br i1 %not_err9, label %after_check10, label %else_block11
 
-after_check9:                                     ; preds = %phi_block
+after_check10:                                    ; preds = %phi_block
-  %45 = load i8, ptr %has_title, align 1
+  %43 = load i8, ptr %has_title, align 1
-  %46 = trunc i8 %45 to i1
+  %44 = trunc i8 %43 to i1
-  br label %phi_block11
+  br label %phi_block12
 
-else_block10:                                     ; preds = %phi_block
+else_block11:                                     ; preds = %phi_block
-  br label %phi_block11
+  br label %phi_block12
 
-phi_block11:                                      ; preds = %else_block10, %after_check9
+phi_block12:                                      ; preds = %else_block11, %after_check10
-  %val12 = phi i1 [ %46, %after_check9 ], [ false, %else_block10 ]
+  %val13 = phi i1 [ %44, %after_check10 ], [ false, %else_block11 ]
-  %ternary = select i1 %val12, ptr @.str.26, ptr @.str.27
+  %ternary = select i1 %val13, ptr @.str.26, ptr @.str.27
-  %47 = call i32 (ptr, ...) @printf(ptr @.str.25, ptr %val7, ptr %ternary)
+  %45 = call i32 (ptr, ...) @printf(ptr @.str.25, ptr %val7, ptr %ternary)
-  %48 = load i64, ptr %anon, align 8
+  %46 = load i64, ptr %anon, align 8
-  %add = add i64 %48, 1
+  %add = add i64 %46, 1
   store i64 %add, ptr %anon, align 8
   br label %loop.cond
 

test/test_suite2/errors/failable_chained_init.c3t

@@ -58,18 +58,18 @@ entry:
   %vararg = alloca %"variant[]", align 8
   %varargslots = alloca [1 x %variant], align 16
   %err5 = alloca i64, align 8
-  %retparam13 = alloca i64, align 8
+  %retparam14 = alloca i64, align 8
-  %taddr14 = alloca %"char[]", align 8
+  %taddr15 = alloca %"char[]", align 8
-  %vararg17 = alloca %"variant[]", align 8
+  %vararg18 = alloca %"variant[]", align 8
-  %varargslots18 = alloca [1 x %variant], align 16
+  %varargslots19 = alloca [1 x %variant], align 16
-  %retparam25 = alloca i64, align 8
+  %retparam26 = alloca i64, align 8
-  %taddr26 = alloca %"char[]", align 8
+  %taddr27 = alloca %"char[]", align 8
-  %vararg29 = alloca %"variant[]", align 8
+  %vararg30 = alloca %"variant[]", align 8
-  %varargslots30 = alloca [1 x %variant], align 16
+  %varargslots31 = alloca [1 x %variant], align 16
-  %retparam38 = alloca i64, align 8
+  %retparam40 = alloca i64, align 8
-  %taddr39 = alloca %"char[]", align 8
+  %taddr41 = alloca %"char[]", align 8
-  %vararg42 = alloca %"variant[]", align 8
+  %vararg44 = alloca %"variant[]", align 8
-  %varargslots43 = alloca [1 x %variant], align 16
+  %varargslots45 = alloca [1 x %variant], align 16
   store i32 1, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %a.f, align 8
@@ -80,12 +80,12 @@ after_assign:                                     ; preds = %entry
   br label %testblock
 
 testblock:                                        ; preds = %after_assign
-  %0 = load i64, ptr %a.f, align 8
+  %optval = load i64, ptr %a.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %testblock
-  store i64 %0, ptr %err, align 8
+  store i64 %optval, ptr %err, align 8
   br label %end_block
 
 after_check:                                      ; preds = %testblock
@@ -93,30 +93,30 @@ after_check:                                      ; preds = %testblock
   br label %end_block
 
 end_block:                                        ; preds = %after_check, %assign_optional
-  %1 = load i64, ptr %err, align 8
+  %0 = load i64, ptr %err, align 8
-  %neq = icmp ne i64 %1, 0
+  %neq = icmp ne i64 %0, 0
   br i1 %neq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_block
   store %"char[]" { ptr @.str, i64 13 }, ptr %taddr, align 8
-  %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
+  %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
-  %lo = load ptr, ptr %2, align 8
+  %lo = load ptr, ptr %1, align 8
-  %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
+  %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
-  %hi = load i64, ptr %3, align 8
+  %hi = load i64, ptr %2, align 8
-  %4 = insertvalue %variant undef, ptr %err, 0
+  %3 = insertvalue %variant undef, ptr %err, 0
-  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
+  %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
-  store %variant %5, ptr %6, align 16
+  store %variant %4, ptr %5, align 16
-  %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
+  %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
-  store i64 1, ptr %7, align 8
+  store i64 1, ptr %6, align 8
-  %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
+  %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
-  store ptr %varargslots, ptr %8, align 8
+  store ptr %varargslots, ptr %7, align 8
-  %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
+  %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
-  %lo1 = load ptr, ptr %9, align 8
+  %lo1 = load ptr, ptr %8, align 8
-  %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
+  %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
-  %hi2 = load i64, ptr %10, align 8
+  %hi2 = load i64, ptr %9, align 8
-  %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2)
+  %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2)
-  %not_err3 = icmp eq i64 %11, 0
+  %not_err3 = icmp eq i64 %10, 0
   br i1 %not_err3, label %after_check4, label %voiderr
 
 after_check4:                                     ; preds = %if.then
@@ -129,112 +129,112 @@ if.exit:                                          ; preds = %voiderr, %end_block
   br label %testblock6
 
 testblock6:                                       ; preds = %if.exit
-  %12 = load i64, ptr %b.f, align 8
+  %optval7 = load i64, ptr %b.f, align 8
-  %not_err7 = icmp eq i64 %12, 0
+  %not_err8 = icmp eq i64 %optval7, 0
-  br i1 %not_err7, label %after_check9, label %assign_optional8
+  br i1 %not_err8, label %after_check10, label %assign_optional9
 
-assign_optional8:                                 ; preds = %testblock6
+assign_optional9:                                 ; preds = %testblock6
-  store i64 %12, ptr %err5, align 8
+  store i64 %optval7, ptr %err5, align 8
-  br label %end_block10
+  br label %end_block11
 
-after_check9:                                     ; preds = %testblock6
+after_check10:                                    ; preds = %testblock6
   store i64 0, ptr %err5, align 8
-  br label %end_block10
+  br label %end_block11
 
-end_block10:                                      ; preds = %after_check9, %assign_optional8
+end_block11:                                      ; preds = %after_check10, %assign_optional9
-  %13 = load i64, ptr %err5, align 8
+  %11 = load i64, ptr %err5, align 8
-  %neq11 = icmp ne i64 %13, 0
+  %neq12 = icmp ne i64 %11, 0
-  br i1 %neq11, label %if.then12, label %if.exit24
+  br i1 %neq12, label %if.then13, label %if.exit25
 
-if.then12:                                        ; preds = %end_block10
+if.then13:                                        ; preds = %end_block11
-  store %"char[]" { ptr @.str.1, i64 13 }, ptr %taddr14, align 8
+  store %"char[]" { ptr @.str.1, i64 13 }, ptr %taddr15, align 8
-  %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr14, i32 0, i32 0
+  %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr15, i32 0, i32 0
-  %lo15 = load ptr, ptr %14, align 8
+  %lo16 = load ptr, ptr %12, align 8
-  %15 = getelementptr inbounds { ptr, i64 }, ptr %taddr14, i32 0, i32 1
+  %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr15, i32 0, i32 1
-  %hi16 = load i64, ptr %15, align 8
+  %hi17 = load i64, ptr %13, align 8
-  %16 = insertvalue %variant undef, ptr %err5, 0
+  %14 = insertvalue %variant undef, ptr %err5, 0
-  %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %18 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0
+  %16 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0
-  store %variant %17, ptr %18, align 16
+  store %variant %15, ptr %16, align 16
-  %19 = getelementptr inbounds %"variant[]", ptr %vararg17, i32 0, i32 1
+  %17 = getelementptr inbounds %"variant[]", ptr %vararg18, i32 0, i32 1
-  store i64 1, ptr %19, align 8
+  store i64 1, ptr %17, align 8
-  %20 = getelementptr inbounds %"variant[]", ptr %vararg17, i32 0, i32 0
+  %18 = getelementptr inbounds %"variant[]", ptr %vararg18, i32 0, i32 0
-  store ptr %varargslots18, ptr %20, align 8
+  store ptr %varargslots19, ptr %18, align 8
-  %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg17, i32 0, i32 0
+  %19 = getelementptr inbounds { ptr, i64 }, ptr %vararg18, i32 0, i32 0
-  %lo19 = load ptr, ptr %21, align 8
+  %lo20 = load ptr, ptr %19, align 8
-  %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg17, i32 0, i32 1
+  %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg18, i32 0, i32 1
-  %hi20 = load i64, ptr %22, align 8
+  %hi21 = load i64, ptr %20, align 8
-  %23 = call i64 @std_io_printfln(ptr %retparam13, ptr %lo15, i64 %hi16, ptr %lo19, i64 %hi20)
+  %21 = call i64 @std_io_printfln(ptr %retparam14, ptr %lo16, i64 %hi17, ptr %lo20, i64 %hi21)
-  %not_err21 = icmp eq i64 %23, 0
+  %not_err22 = icmp eq i64 %21, 0
-  br i1 %not_err21, label %after_check22, label %voiderr23
+  br i1 %not_err22, label %after_check23, label %voiderr24
 
-after_check22:                                    ; preds = %if.then12
+after_check23:                                    ; preds = %if.then13
-  br label %voiderr23
+  br label %voiderr24
 
-voiderr23:                                        ; preds = %after_check22, %if.then12
+voiderr24:                                        ; preds = %after_check23, %if.then13
-  br label %if.exit24
+  br label %if.exit25
 
-if.exit24:                                        ; preds = %voiderr23, %end_block10
+if.exit25:                                        ; preds = %voiderr24, %end_block11
-  store %"char[]" { ptr @.str.2, i64 9 }, ptr %taddr26, align 8
+  store %"char[]" { ptr @.str.2, i64 9 }, ptr %taddr27, align 8
-  %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr26, i32 0, i32 0
+  %22 = getelementptr inbounds { ptr, i64 }, ptr %taddr27, i32 0, i32 0
-  %lo27 = load ptr, ptr %24, align 8
+  %lo28 = load ptr, ptr %22, align 8
-  %25 = getelementptr inbounds { ptr, i64 }, ptr %taddr26, i32 0, i32 1
+  %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr27, i32 0, i32 1
-  %hi28 = load i64, ptr %25, align 8
+  %hi29 = load i64, ptr %23, align 8
-  %26 = load i64, ptr %a.f, align 8
+  %optval32 = load i64, ptr %a.f, align 8
-  %not_err31 = icmp eq i64 %26, 0
+  %not_err33 = icmp eq i64 %optval32, 0
-  br i1 %not_err31, label %after_check32, label %voiderr37
+  br i1 %not_err33, label %after_check34, label %voiderr39
 
-after_check32:                                    ; preds = %if.exit24
+after_check34:                                    ; preds = %if.exit25
-  %27 = insertvalue %variant undef, ptr %a, 0
+  %24 = insertvalue %variant undef, ptr %a, 0
-  %28 = insertvalue %variant %27, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %29 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
+  %26 = getelementptr inbounds [1 x %variant], ptr %varargslots31, i64 0, i64 0
-  store %variant %28, ptr %29, align 16
+  store %variant %25, ptr %26, align 16
-  %30 = getelementptr inbounds %"variant[]", ptr %vararg29, i32 0, i32 1
+  %27 = getelementptr inbounds %"variant[]", ptr %vararg30, i32 0, i32 1
-  store i64 1, ptr %30, align 8
+  store i64 1, ptr %27, align 8
-  %31 = getelementptr inbounds %"variant[]", ptr %vararg29, i32 0, i32 0
+  %28 = getelementptr inbounds %"variant[]", ptr %vararg30, i32 0, i32 0
-  store ptr %varargslots30, ptr %31, align 8
+  store ptr %varargslots31, ptr %28, align 8
-  %32 = getelementptr inbounds { ptr, i64 }, ptr %vararg29, i32 0, i32 0
+  %29 = getelementptr inbounds { ptr, i64 }, ptr %vararg30, i32 0, i32 0
-  %lo33 = load ptr, ptr %32, align 8
+  %lo35 = load ptr, ptr %29, align 8
-  %33 = getelementptr inbounds { ptr, i64 }, ptr %vararg29, i32 0, i32 1
+  %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg30, i32 0, i32 1
-  %hi34 = load i64, ptr %33, align 8
+  %hi36 = load i64, ptr %30, align 8
-  %34 = call i64 @std_io_printfln(ptr %retparam25, ptr %lo27, i64 %hi28, ptr %lo33, i64 %hi34)
+  %31 = call i64 @std_io_printfln(ptr %retparam26, ptr %lo28, i64 %hi29, ptr %lo35, i64 %hi36)
-  %not_err35 = icmp eq i64 %34, 0
+  %not_err37 = icmp eq i64 %31, 0
-  br i1 %not_err35, label %after_check36, label %voiderr37
+  br i1 %not_err37, label %after_check38, label %voiderr39
 
-after_check36:                                    ; preds = %after_check32
+after_check38:                                    ; preds = %after_check34
-  br label %voiderr37
+  br label %voiderr39
 
-voiderr37:                                        ; preds = %after_check36, %after_check32, %if.exit24
+voiderr39:                                        ; preds = %after_check38, %after_check34, %if.exit25
-  store %"char[]" { ptr @.str.3, i64 9 }, ptr %taddr39, align 8
+  store %"char[]" { ptr @.str.3, i64 9 }, ptr %taddr41, align 8
-  %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr39, i32 0, i32 0
+  %32 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 0
-  %lo40 = load ptr, ptr %35, align 8
+  %lo42 = load ptr, ptr %32, align 8
-  %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr39, i32 0, i32 1
+  %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 1
-  %hi41 = load i64, ptr %36, align 8
+  %hi43 = load i64, ptr %33, align 8
-  %37 = load i64, ptr %b.f, align 8
+  %optval46 = load i64, ptr %b.f, align 8
-  %not_err44 = icmp eq i64 %37, 0
+  %not_err47 = icmp eq i64 %optval46, 0
-  br i1 %not_err44, label %after_check45, label %voiderr50
+  br i1 %not_err47, label %after_check48, label %voiderr53
 
-after_check45:                                    ; preds = %voiderr37
+after_check48:                                    ; preds = %voiderr39
-  %38 = insertvalue %variant undef, ptr %b, 0
+  %34 = insertvalue %variant undef, ptr %b, 0
-  %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %40 = getelementptr inbounds [1 x %variant], ptr %varargslots43, i64 0, i64 0
+  %36 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0
-  store %variant %39, ptr %40, align 16
+  store %variant %35, ptr %36, align 16
-  %41 = getelementptr inbounds %"variant[]", ptr %vararg42, i32 0, i32 1
+  %37 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 1
-  store i64 1, ptr %41, align 8
+  store i64 1, ptr %37, align 8
-  %42 = getelementptr inbounds %"variant[]", ptr %vararg42, i32 0, i32 0
+  %38 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 0
-  store ptr %varargslots43, ptr %42, align 8
+  store ptr %varargslots45, ptr %38, align 8
-  %43 = getelementptr inbounds { ptr, i64 }, ptr %vararg42, i32 0, i32 0
+  %39 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 0
-  %lo46 = load ptr, ptr %43, align 8
+  %lo49 = load ptr, ptr %39, align 8
-  %44 = getelementptr inbounds { ptr, i64 }, ptr %vararg42, i32 0, i32 1
+  %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 1
-  %hi47 = load i64, ptr %44, align 8
+  %hi50 = load i64, ptr %40, align 8
-  %45 = call i64 @std_io_printfln(ptr %retparam38, ptr %lo40, i64 %hi41, ptr %lo46, i64 %hi47)
+  %41 = call i64 @std_io_printfln(ptr %retparam40, ptr %lo42, i64 %hi43, ptr %lo49, i64 %hi50)
-  %not_err48 = icmp eq i64 %45, 0
+  %not_err51 = icmp eq i64 %41, 0
-  br i1 %not_err48, label %after_check49, label %voiderr50
+  br i1 %not_err51, label %after_check52, label %voiderr53
 
-after_check49:                                    ; preds = %after_check45
+after_check52:                                    ; preds = %after_check48
-  br label %voiderr50
+  br label %voiderr53
 
-voiderr50:                                        ; preds = %after_check49, %after_check45, %voiderr37
+voiderr53:                                        ; preds = %after_check52, %after_check48, %voiderr39
   ret void
 }
 
@@ -252,33 +252,33 @@ entry:
   %taddr = alloca %"char[]", align 8
   %vararg = alloca %"variant[]", align 8
   %varargslots = alloca [1 x %variant], align 16
-  %err9 = alloca i64, align 8
+  %err10 = alloca i64, align 8
-  %retparam17 = alloca i64, align 8
+  %retparam19 = alloca i64, align 8
-  %taddr18 = alloca %"char[]", align 8
+  %taddr20 = alloca %"char[]", align 8
-  %vararg21 = alloca %"variant[]", align 8
+  %vararg23 = alloca %"variant[]", align 8
-  %varargslots22 = alloca [1 x %variant], align 16
+  %varargslots24 = alloca [1 x %variant], align 16
-  %retparam29 = alloca i64, align 8
+  %retparam31 = alloca i64, align 8
-  %taddr30 = alloca %"char[]", align 8
+  %taddr32 = alloca %"char[]", align 8
-  %vararg33 = alloca %"variant[]", align 8
+  %vararg35 = alloca %"variant[]", align 8
-  %varargslots34 = alloca [1 x %variant], align 16
+  %varargslots36 = alloca [1 x %variant], align 16
-  %retparam42 = alloca i64, align 8
+  %retparam45 = alloca i64, align 8
-  %taddr43 = alloca %"char[]", align 8
+  %taddr46 = alloca %"char[]", align 8
-  %vararg46 = alloca %"variant[]", align 8
+  %vararg49 = alloca %"variant[]", align 8
-  %varargslots47 = alloca [1 x %variant], align 16
+  %varargslots50 = alloca [1 x %variant], align 16
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %x.f, align 8
   store i32 1, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
-  %0 = load i64, ptr %x.f, align 8
+  %optval = load i64, ptr %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, ptr %a.f, align 8
+  store i64 %optval, ptr %a.f, align 8
   br label %optional_assign_jump
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, ptr %x, align 4
+  %0 = load i32, ptr %x, align 4
-  store i32 %1, ptr %a, align 4
+  store i32 %0, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
   br label %after_assign
 
@@ -288,7 +288,7 @@ optional_assign_jump:                             ; preds = %assign_optional
   br label %after_assign1
 
 after_assign:                                     ; preds = %after_check
-  store i32 %1, ptr %b, align 4
+  store i32 %0, ptr %b, align 4
   store i64 0, ptr %b.f, align 8
   br label %after_assign1
 
@@ -296,161 +296,161 @@ after_assign1:                                    ; preds = %after_assign, %opti
   br label %testblock
 
 testblock:                                        ; preds = %after_assign1
-  %2 = load i64, ptr %a.f, align 8
+  %optval2 = load i64, ptr %a.f, align 8
-  %not_err2 = icmp eq i64 %2, 0
+  %not_err3 = icmp eq i64 %optval2, 0
-  br i1 %not_err2, label %after_check4, label %assign_optional3
+  br i1 %not_err3, label %after_check5, label %assign_optional4
 
-assign_optional3:                                 ; preds = %testblock
+assign_optional4:                                 ; preds = %testblock
-  store i64 %2, ptr %err, align 8
+  store i64 %optval2, ptr %err, align 8
   br label %end_block
 
-after_check4:                                     ; preds = %testblock
+after_check5:                                     ; preds = %testblock
   store i64 0, ptr %err, align 8
   br label %end_block
 
-end_block:                                        ; preds = %after_check4, %assign_optional3
+end_block:                                        ; preds = %after_check5, %assign_optional4
-  %3 = load i64, ptr %err, align 8
+  %1 = load i64, ptr %err, align 8
-  %neq = icmp ne i64 %3, 0
+  %neq = icmp ne i64 %1, 0
   br i1 %neq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_block
   store %"char[]" { ptr @.str.4, i64 13 }, ptr %taddr, align 8
-  %4 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
+  %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
-  %lo = load ptr, ptr %4, align 8
+  %lo = load ptr, ptr %2, align 8
-  %5 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
+  %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
-  %hi = load i64, ptr %5, align 8
+  %hi = load i64, ptr %3, align 8
-  %6 = insertvalue %variant undef, ptr %err, 0
+  %4 = insertvalue %variant undef, ptr %err, 0
-  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %8 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
+  %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
-  store %variant %7, ptr %8, align 16
+  store %variant %5, ptr %6, align 16
-  %9 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
+  %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
-  store i64 1, ptr %9, align 8
+  store i64 1, ptr %7, align 8
-  %10 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
+  %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
-  store ptr %varargslots, ptr %10, align 8
+  store ptr %varargslots, ptr %8, align 8
-  %11 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
+  %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
-  %lo5 = load ptr, ptr %11, align 8
+  %lo6 = load ptr, ptr %9, align 8
-  %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
+  %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
-  %hi6 = load i64, ptr %12, align 8
+  %hi7 = load i64, ptr %10, align 8
-  %13 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo5, i64 %hi6)
+  %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo6, i64 %hi7)
-  %not_err7 = icmp eq i64 %13, 0
+  %not_err8 = icmp eq i64 %11, 0
-  br i1 %not_err7, label %after_check8, label %voiderr
+  br i1 %not_err8, label %after_check9, label %voiderr
 
-after_check8:                                     ; preds = %if.then
+after_check9:                                     ; preds = %if.then
   br label %voiderr
 
-voiderr:                                          ; preds = %after_check8, %if.then
+voiderr:                                          ; preds = %after_check9, %if.then
   br label %if.exit
 
 if.exit:                                          ; preds = %voiderr, %end_block
-  br label %testblock10
+  br label %testblock11
 
-testblock10:                                      ; preds = %if.exit
+testblock11:                                      ; preds = %if.exit
-  %14 = load i64, ptr %b.f, align 8
+  %optval12 = load i64, ptr %b.f, align 8
-  %not_err11 = icmp eq i64 %14, 0
+  %not_err13 = icmp eq i64 %optval12, 0
-  br i1 %not_err11, label %after_check13, label %assign_optional12
+  br i1 %not_err13, label %after_check15, label %assign_optional14
 
-assign_optional12:                                ; preds = %testblock10
+assign_optional14:                                ; preds = %testblock11
-  store i64 %14, ptr %err9, align 8
+  store i64 %optval12, ptr %err10, align 8
-  br label %end_block14
+  br label %end_block16
 
-after_check13:                                    ; preds = %testblock10
+after_check15:                                    ; preds = %testblock11
-  store i64 0, ptr %err9, align 8
+  store i64 0, ptr %err10, align 8
-  br label %end_block14
+  br label %end_block16
 
-end_block14:                                      ; preds = %after_check13, %assign_optional12
+end_block16:                                      ; preds = %after_check15, %assign_optional14
-  %15 = load i64, ptr %err9, align 8
+  %12 = load i64, ptr %err10, align 8
-  %neq15 = icmp ne i64 %15, 0
+  %neq17 = icmp ne i64 %12, 0
-  br i1 %neq15, label %if.then16, label %if.exit28
+  br i1 %neq17, label %if.then18, label %if.exit30
 
-if.then16:                                        ; preds = %end_block14
+if.then18:                                        ; preds = %end_block16
-  store %"char[]" { ptr @.str.5, i64 13 }, ptr %taddr18, align 8
+  store %"char[]" { ptr @.str.5, i64 13 }, ptr %taddr20, align 8
-  %16 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 0
+  %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0
-  %lo19 = load ptr, ptr %16, align 8
+  %lo21 = load ptr, ptr %13, align 8
-  %17 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 1
+  %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1
-  %hi20 = load i64, ptr %17, align 8
+  %hi22 = load i64, ptr %14, align 8
-  %18 = insertvalue %variant undef, ptr %err9, 0
+  %15 = insertvalue %variant undef, ptr %err10, 0
-  %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %20 = getelementptr inbounds [1 x %variant], ptr %varargslots22, i64 0, i64 0
+  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
-  store %variant %19, ptr %20, align 16
+  store %variant %16, ptr %17, align 16
-  %21 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 1
+  %18 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1
-  store i64 1, ptr %21, align 8
+  store i64 1, ptr %18, align 8
-  %22 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 0
+  %19 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0
-  store ptr %varargslots22, ptr %22, align 8
+  store ptr %varargslots24, ptr %19, align 8
-  %23 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 0
+  %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0
-  %lo23 = load ptr, ptr %23, align 8
+  %lo25 = load ptr, ptr %20, align 8
-  %24 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 1
+  %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1
-  %hi24 = load i64, ptr %24, align 8
+  %hi26 = load i64, ptr %21, align 8
-  %25 = call i64 @std_io_printfln(ptr %retparam17, ptr %lo19, i64 %hi20, ptr %lo23, i64 %hi24)
+  %22 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26)
-  %not_err25 = icmp eq i64 %25, 0
+  %not_err27 = icmp eq i64 %22, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
+  br i1 %not_err27, label %after_check28, label %voiderr29
 
-after_check26:                                    ; preds = %if.then16
+after_check28:                                    ; preds = %if.then18
-  br label %voiderr27
+  br label %voiderr29
 
-voiderr27:                                        ; preds = %after_check26, %if.then16
+voiderr29:                                        ; preds = %after_check28, %if.then18
-  br label %if.exit28
+  br label %if.exit30
 
-if.exit28:                                        ; preds = %voiderr27, %end_block14
+if.exit30:                                        ; preds = %voiderr29, %end_block16
-  store %"char[]" { ptr @.str.6, i64 9 }, ptr %taddr30, align 8
+  store %"char[]" { ptr @.str.6, i64 9 }, ptr %taddr32, align 8
-  %26 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 0
+  %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 0
-  %lo31 = load ptr, ptr %26, align 8
+  %lo33 = load ptr, ptr %23, align 8
-  %27 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 1
+  %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 1
-  %hi32 = load i64, ptr %27, align 8
+  %hi34 = load i64, ptr %24, align 8
-  %28 = load i64, ptr %a.f, align 8
+  %optval37 = load i64, ptr %a.f, align 8
-  %not_err35 = icmp eq i64 %28, 0
+  %not_err38 = icmp eq i64 %optval37, 0
-  br i1 %not_err35, label %after_check36, label %voiderr41
+  br i1 %not_err38, label %after_check39, label %voiderr44
 
-after_check36:                                    ; preds = %if.exit28
+after_check39:                                    ; preds = %if.exit30
-  %29 = insertvalue %variant undef, ptr %a, 0
+  %25 = insertvalue %variant undef, ptr %a, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots34, i64 0, i64 0
+  %27 = getelementptr inbounds [1 x %variant], ptr %varargslots36, i64 0, i64 0
-  store %variant %30, ptr %31, align 16
+  store %variant %26, ptr %27, align 16
-  %32 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 1
+  %28 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 1
-  store i64 1, ptr %32, align 8
+  store i64 1, ptr %28, align 8
-  %33 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 0
+  %29 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 0
-  store ptr %varargslots34, ptr %33, align 8
+  store ptr %varargslots36, ptr %29, align 8
-  %34 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 0
+  %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 0
-  %lo37 = load ptr, ptr %34, align 8
+  %lo40 = load ptr, ptr %30, align 8
-  %35 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 1
+  %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 1
-  %hi38 = load i64, ptr %35, align 8
+  %hi41 = load i64, ptr %31, align 8
-  %36 = call i64 @std_io_printfln(ptr %retparam29, ptr %lo31, i64 %hi32, ptr %lo37, i64 %hi38)
+  %32 = call i64 @std_io_printfln(ptr %retparam31, ptr %lo33, i64 %hi34, ptr %lo40, i64 %hi41)
-  %not_err39 = icmp eq i64 %36, 0
+  %not_err42 = icmp eq i64 %32, 0
-  br i1 %not_err39, label %after_check40, label %voiderr41
+  br i1 %not_err42, label %after_check43, label %voiderr44
 
-after_check40:                                    ; preds = %after_check36
+after_check43:                                    ; preds = %after_check39
-  br label %voiderr41
+  br label %voiderr44
 
-voiderr41:                                        ; preds = %after_check40, %after_check36, %if.exit28
+voiderr44:                                        ; preds = %after_check43, %after_check39, %if.exit30
-  store %"char[]" { ptr @.str.7, i64 9 }, ptr %taddr43, align 8
+  store %"char[]" { ptr @.str.7, i64 9 }, ptr %taddr46, align 8
-  %37 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 0
+  %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 0
-  %lo44 = load ptr, ptr %37, align 8
+  %lo47 = load ptr, ptr %33, align 8
-  %38 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 1
+  %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 1
-  %hi45 = load i64, ptr %38, align 8
+  %hi48 = load i64, ptr %34, align 8
-  %39 = load i64, ptr %b.f, align 8
+  %optval51 = load i64, ptr %b.f, align 8
-  %not_err48 = icmp eq i64 %39, 0
+  %not_err52 = icmp eq i64 %optval51, 0
-  br i1 %not_err48, label %after_check49, label %voiderr54
+  br i1 %not_err52, label %after_check53, label %voiderr58
 
-after_check49:                                    ; preds = %voiderr41
+after_check53:                                    ; preds = %voiderr44
-  %40 = insertvalue %variant undef, ptr %b, 0
+  %35 = insertvalue %variant undef, ptr %b, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots47, i64 0, i64 0
+  %37 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0
-  store %variant %41, ptr %42, align 16
+  store %variant %36, ptr %37, align 16
-  %43 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 1
+  %38 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 1
-  store i64 1, ptr %43, align 8
+  store i64 1, ptr %38, align 8
-  %44 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 0
+  %39 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 0
-  store ptr %varargslots47, ptr %44, align 8
+  store ptr %varargslots50, ptr %39, align 8
-  %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 0
+  %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 0
-  %lo50 = load ptr, ptr %45, align 8
+  %lo54 = load ptr, ptr %40, align 8
-  %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 1
+  %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 1
-  %hi51 = load i64, ptr %46, align 8
+  %hi55 = load i64, ptr %41, align 8
-  %47 = call i64 @std_io_printfln(ptr %retparam42, ptr %lo44, i64 %hi45, ptr %lo50, i64 %hi51)
+  %42 = call i64 @std_io_printfln(ptr %retparam45, ptr %lo47, i64 %hi48, ptr %lo54, i64 %hi55)
-  %not_err52 = icmp eq i64 %47, 0
+  %not_err56 = icmp eq i64 %42, 0
-  br i1 %not_err52, label %after_check53, label %voiderr54
+  br i1 %not_err56, label %after_check57, label %voiderr58
 
-after_check53:                                    ; preds = %after_check49
+after_check57:                                    ; preds = %after_check53
-  br label %voiderr54
+  br label %voiderr58
 
-voiderr54:                                        ; preds = %after_check53, %after_check49, %voiderr41
+voiderr58:                                        ; preds = %after_check57, %after_check53, %voiderr44
   ret void
 }
 
@@ -468,34 +468,34 @@ entry:
   %taddr = alloca %"char[]", align 8
   %vararg = alloca %"variant[]", align 8
   %varargslots = alloca [1 x %variant], align 16
-  %err9 = alloca i64, align 8
+  %err10 = alloca i64, align 8
-  %retparam17 = alloca i64, align 8
+  %retparam19 = alloca i64, align 8
-  %taddr18 = alloca %"char[]", align 8
+  %taddr20 = alloca %"char[]", align 8
-  %vararg21 = alloca %"variant[]", align 8
+  %vararg23 = alloca %"variant[]", align 8
-  %varargslots22 = alloca [1 x %variant], align 16
+  %varargslots24 = alloca [1 x %variant], align 16
-  %retparam29 = alloca i64, align 8
+  %retparam31 = alloca i64, align 8
-  %taddr30 = alloca %"char[]", align 8
+  %taddr32 = alloca %"char[]", align 8
-  %vararg33 = alloca %"variant[]", align 8
+  %vararg35 = alloca %"variant[]", align 8
-  %varargslots34 = alloca [1 x %variant], align 16
+  %varargslots36 = alloca [1 x %variant], align 16
-  %retparam42 = alloca i64, align 8
+  %retparam45 = alloca i64, align 8
-  %taddr43 = alloca %"char[]", align 8
+  %taddr46 = alloca %"char[]", align 8
-  %vararg46 = alloca %"variant[]", align 8
+  %vararg49 = alloca %"variant[]", align 8
-  %varargslots47 = alloca [1 x %variant], align 16
+  %varargslots50 = alloca [1 x %variant], align 16
   store i32 23, ptr %x, align 4
   store i64 0, ptr %x.f, align 8
   store i32 1, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
-  %0 = load i64, ptr %x.f, align 8
+  %optval = load i64, ptr %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, ptr %a.f, align 8
+  store i64 %optval, ptr %a.f, align 8
   br label %optional_assign_jump
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, ptr %x, align 4
+  %0 = load i32, ptr %x, align 4
-  store i32 %1, ptr %a, align 4
+  store i32 %0, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
   br label %after_assign
 
@@ -505,7 +505,7 @@ optional_assign_jump:                             ; preds = %assign_optional
   br label %after_assign1
 
 after_assign:                                     ; preds = %after_check
-  store i32 %1, ptr %b, align 4
+  store i32 %0, ptr %b, align 4
   store i64 0, ptr %b.f, align 8
   br label %after_assign1
 
@@ -513,160 +513,160 @@ after_assign1:                                    ; preds = %after_assign, %opti
   br label %testblock
 
 testblock:                                        ; preds = %after_assign1
-  %2 = load i64, ptr %a.f, align 8
+  %optval2 = load i64, ptr %a.f, align 8
-  %not_err2 = icmp eq i64 %2, 0
+  %not_err3 = icmp eq i64 %optval2, 0
-  br i1 %not_err2, label %after_check4, label %assign_optional3
+  br i1 %not_err3, label %after_check5, label %assign_optional4
 
-assign_optional3:                                 ; preds = %testblock
+assign_optional4:                                 ; preds = %testblock
-  store i64 %2, ptr %err, align 8
+  store i64 %optval2, ptr %err, align 8
   br label %end_block
 
-after_check4:                                     ; preds = %testblock
+after_check5:                                     ; preds = %testblock
   store i64 0, ptr %err, align 8
   br label %end_block
 
-end_block:                                        ; preds = %after_check4, %assign_optional3
+end_block:                                        ; preds = %after_check5, %assign_optional4
-  %3 = load i64, ptr %err, align 8
+  %1 = load i64, ptr %err, align 8
-  %neq = icmp ne i64 %3, 0
+  %neq = icmp ne i64 %1, 0
   br i1 %neq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_block
   store %"char[]" { ptr @.str.8, i64 13 }, ptr %taddr, align 8
-  %4 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
+  %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0
-  %lo = load ptr, ptr %4, align 8
+  %lo = load ptr, ptr %2, align 8
-  %5 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
+  %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1
-  %hi = load i64, ptr %5, align 8
+  %hi = load i64, ptr %3, align 8
-  %6 = insertvalue %variant undef, ptr %err, 0
+  %4 = insertvalue %variant undef, ptr %err, 0
-  %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %8 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
+  %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
-  store %variant %7, ptr %8, align 16
+  store %variant %5, ptr %6, align 16
-  %9 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
+  %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1
-  store i64 1, ptr %9, align 8
+  store i64 1, ptr %7, align 8
-  %10 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
+  %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0
-  store ptr %varargslots, ptr %10, align 8
+  store ptr %varargslots, ptr %8, align 8
-  %11 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
+  %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0
-  %lo5 = load ptr, ptr %11, align 8
+  %lo6 = load ptr, ptr %9, align 8
-  %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
+  %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1
-  %hi6 = load i64, ptr %12, align 8
+  %hi7 = load i64, ptr %10, align 8
-  %13 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo5, i64 %hi6)
+  %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo6, i64 %hi7)
-  %not_err7 = icmp eq i64 %13, 0
+  %not_err8 = icmp eq i64 %11, 0
-  br i1 %not_err7, label %after_check8, label %voiderr
+  br i1 %not_err8, label %after_check9, label %voiderr
 
-after_check8:                                     ; preds = %if.then
+after_check9:                                     ; preds = %if.then
   br label %voiderr
 
-voiderr:                                          ; preds = %after_check8, %if.then
+voiderr:                                          ; preds = %after_check9, %if.then
   br label %if.exit
 
 if.exit:                                          ; preds = %voiderr, %end_block
-  br label %testblock10
+  br label %testblock11
 
-testblock10:                                      ; preds = %if.exit
+testblock11:                                      ; preds = %if.exit
-  %14 = load i64, ptr %b.f, align 8
+  %optval12 = load i64, ptr %b.f, align 8
-  %not_err11 = icmp eq i64 %14, 0
+  %not_err13 = icmp eq i64 %optval12, 0
-  br i1 %not_err11, label %after_check13, label %assign_optional12
+  br i1 %not_err13, label %after_check15, label %assign_optional14
 
-assign_optional12:                                ; preds = %testblock10
+assign_optional14:                                ; preds = %testblock11
-  store i64 %14, ptr %err9, align 8
+  store i64 %optval12, ptr %err10, align 8
-  br label %end_block14
+  br label %end_block16
 
-after_check13:                                    ; preds = %testblock10
+after_check15:                                    ; preds = %testblock11
-  store i64 0, ptr %err9, align 8
+  store i64 0, ptr %err10, align 8
-  br label %end_block14
+  br label %end_block16
 
-end_block14:                                      ; preds = %after_check13, %assign_optional12
+end_block16:                                      ; preds = %after_check15, %assign_optional14
-  %15 = load i64, ptr %err9, align 8
+  %12 = load i64, ptr %err10, align 8
-  %neq15 = icmp ne i64 %15, 0
+  %neq17 = icmp ne i64 %12, 0
-  br i1 %neq15, label %if.then16, label %if.exit28
+  br i1 %neq17, label %if.then18, label %if.exit30
 
-if.then16:                                        ; preds = %end_block14
+if.then18:                                        ; preds = %end_block16
-  store %"char[]" { ptr @.str.9, i64 13 }, ptr %taddr18, align 8
+  store %"char[]" { ptr @.str.9, i64 13 }, ptr %taddr20, align 8
-  %16 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 0
+  %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0
-  %lo19 = load ptr, ptr %16, align 8
+  %lo21 = load ptr, ptr %13, align 8
-  %17 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 1
+  %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1
-  %hi20 = load i64, ptr %17, align 8
+  %hi22 = load i64, ptr %14, align 8
-  %18 = insertvalue %variant undef, ptr %err9, 0
+  %15 = insertvalue %variant undef, ptr %err10, 0
-  %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
+  %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1
-  %20 = getelementptr inbounds [1 x %variant], ptr %varargslots22, i64 0, i64 0
+  %17 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0
-  store %variant %19, ptr %20, align 16
+  store %variant %16, ptr %17, align 16
-  %21 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 1
+  %18 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1
-  store i64 1, ptr %21, align 8
+  store i64 1, ptr %18, align 8
-  %22 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 0
+  %19 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0
-  store ptr %varargslots22, ptr %22, align 8
+  store ptr %varargslots24, ptr %19, align 8
-  %23 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 0
+  %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0
-  %lo23 = load ptr, ptr %23, align 8
+  %lo25 = load ptr, ptr %20, align 8
-  %24 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 1
+  %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1
-  %hi24 = load i64, ptr %24, align 8
+  %hi26 = load i64, ptr %21, align 8
-  %25 = call i64 @std_io_printfln(ptr %retparam17, ptr %lo19, i64 %hi20, ptr %lo23, i64 %hi24)
+  %22 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26)
-  %not_err25 = icmp eq i64 %25, 0
+  %not_err27 = icmp eq i64 %22, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
+  br i1 %not_err27, label %after_check28, label %voiderr29
 
-after_check26:                                    ; preds = %if.then16
+after_check28:                                    ; preds = %if.then18
-  br label %voiderr27
+  br label %voiderr29
 
-voiderr27:                                        ; preds = %after_check26, %if.then16
+voiderr29:                                        ; preds = %after_check28, %if.then18
-  br label %if.exit28
+  br label %if.exit30
 
-if.exit28:                                        ; preds = %voiderr27, %end_block14
+if.exit30:                                        ; preds = %voiderr29, %end_block16
-  store %"char[]" { ptr @.str.10, i64 9 }, ptr %taddr30, align 8
+  store %"char[]" { ptr @.str.10, i64 9 }, ptr %taddr32, align 8
-  %26 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 0
+  %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 0
-  %lo31 = load ptr, ptr %26, align 8
+  %lo33 = load ptr, ptr %23, align 8
-  %27 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 1
+  %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 1
-  %hi32 = load i64, ptr %27, align 8
+  %hi34 = load i64, ptr %24, align 8
-  %28 = load i64, ptr %a.f, align 8
+  %optval37 = load i64, ptr %a.f, align 8
-  %not_err35 = icmp eq i64 %28, 0
+  %not_err38 = icmp eq i64 %optval37, 0
-  br i1 %not_err35, label %after_check36, label %voiderr41
+  br i1 %not_err38, label %after_check39, label %voiderr44
 
-after_check36:                                    ; preds = %if.exit28
+after_check39:                                    ; preds = %if.exit30
-  %29 = insertvalue %variant undef, ptr %a, 0
+  %25 = insertvalue %variant undef, ptr %a, 0
-  %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %31 = getelementptr inbounds [1 x %variant], ptr %varargslots34, i64 0, i64 0
+  %27 = getelementptr inbounds [1 x %variant], ptr %varargslots36, i64 0, i64 0
-  store %variant %30, ptr %31, align 16
+  store %variant %26, ptr %27, align 16
-  %32 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 1
+  %28 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 1
-  store i64 1, ptr %32, align 8
+  store i64 1, ptr %28, align 8
-  %33 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 0
+  %29 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 0
-  store ptr %varargslots34, ptr %33, align 8
+  store ptr %varargslots36, ptr %29, align 8
-  %34 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 0
+  %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 0
-  %lo37 = load ptr, ptr %34, align 8
+  %lo40 = load ptr, ptr %30, align 8
-  %35 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 1
+  %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 1
-  %hi38 = load i64, ptr %35, align 8
+  %hi41 = load i64, ptr %31, align 8
-  %36 = call i64 @std_io_printfln(ptr %retparam29, ptr %lo31, i64 %hi32, ptr %lo37, i64 %hi38)
+  %32 = call i64 @std_io_printfln(ptr %retparam31, ptr %lo33, i64 %hi34, ptr %lo40, i64 %hi41)
-  %not_err39 = icmp eq i64 %36, 0
+  %not_err42 = icmp eq i64 %32, 0
-  br i1 %not_err39, label %after_check40, label %voiderr41
+  br i1 %not_err42, label %after_check43, label %voiderr44
 
-after_check40:                                    ; preds = %after_check36
+after_check43:                                    ; preds = %after_check39
-  br label %voiderr41
+  br label %voiderr44
 
-voiderr41:                                        ; preds = %after_check40, %after_check36, %if.exit28
+voiderr44:                                        ; preds = %after_check43, %after_check39, %if.exit30
-  store %"char[]" { ptr @.str.11, i64 9 }, ptr %taddr43, align 8
+  store %"char[]" { ptr @.str.11, i64 9 }, ptr %taddr46, align 8
-  %37 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 0
+  %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 0
-  %lo44 = load ptr, ptr %37, align 8
+  %lo47 = load ptr, ptr %33, align 8
-  %38 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 1
+  %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 1
-  %hi45 = load i64, ptr %38, align 8
+  %hi48 = load i64, ptr %34, align 8
-  %39 = load i64, ptr %b.f, align 8
+  %optval51 = load i64, ptr %b.f, align 8
-  %not_err48 = icmp eq i64 %39, 0
+  %not_err52 = icmp eq i64 %optval51, 0
-  br i1 %not_err48, label %after_check49, label %voiderr54
+  br i1 %not_err52, label %after_check53, label %voiderr58
 
-after_check49:                                    ; preds = %voiderr41
+after_check53:                                    ; preds = %voiderr44
-  %40 = insertvalue %variant undef, ptr %b, 0
+  %35 = insertvalue %variant undef, ptr %b, 0
-  %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$int" to i64), 1
+  %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$int" to i64), 1
-  %42 = getelementptr inbounds [1 x %variant], ptr %varargslots47, i64 0, i64 0
+  %37 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0
-  store %variant %41, ptr %42, align 16
+  store %variant %36, ptr %37, align 16
-  %43 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 1
+  %38 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 1
-  store i64 1, ptr %43, align 8
+  store i64 1, ptr %38, align 8
-  %44 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 0
+  %39 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 0
-  store ptr %varargslots47, ptr %44, align 8
+  store ptr %varargslots50, ptr %39, align 8
-  %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 0
+  %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 0
-  %lo50 = load ptr, ptr %45, align 8
+  %lo54 = load ptr, ptr %40, align 8
-  %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 1
+  %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 1
-  %hi51 = load i64, ptr %46, align 8
+  %hi55 = load i64, ptr %41, align 8
-  %47 = call i64 @std_io_printfln(ptr %retparam42, ptr %lo44, i64 %hi45, ptr %lo50, i64 %hi51)
+  %42 = call i64 @std_io_printfln(ptr %retparam45, ptr %lo47, i64 %hi48, ptr %lo54, i64 %hi55)
-  %not_err52 = icmp eq i64 %47, 0
+  %not_err56 = icmp eq i64 %42, 0
-  br i1 %not_err52, label %after_check53, label %voiderr54
+  br i1 %not_err56, label %after_check57, label %voiderr58
 
-after_check53:                                    ; preds = %after_check49
+after_check57:                                    ; preds = %after_check53
-  br label %voiderr54
+  br label %voiderr58
 
-voiderr54:                                        ; preds = %after_check53, %after_check49, %voiderr41
+voiderr58:                                        ; preds = %after_check57, %after_check53, %voiderr44
   ret void
 }

test/test_suite2/errors/failable_inits.c3t

@@ -41,20 +41,20 @@ entry:
   %error_var = alloca i64, align 8
   %reterr = alloca i64, align 8
   store i64 ptrtoint (ptr @"test_Foo$MY_VAL1" to i64), ptr %x.f, align 8
-  %0 = load i64, ptr %x.f, align 8
+  %optval = load i64, ptr %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, ptr %error_var, align 8
+  store i64 %optval, ptr %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %1 = load i64, ptr %error_var, align 8
+  %0 = load i64, ptr %error_var, align 8
-  ret i64 %1
+  ret i64 %0
 
 noerr_block:                                      ; preds = %after_check
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y, ptr align 4 %x, i32 4, i1 false)
@@ -70,20 +70,20 @@ entry:
   %reterr = alloca i64, align 8
   store i32 0, ptr %x, align 4
   store i64 0, ptr %x.f, align 8
-  %0 = load i64, ptr %x.f, align 8
+  %optval = load i64, ptr %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, ptr %error_var, align 8
+  store i64 %optval, ptr %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %1 = load i64, ptr %error_var, align 8
+  %0 = load i64, ptr %error_var, align 8
-  ret i64 %1
+  ret i64 %0
 
 noerr_block:                                      ; preds = %after_check
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %y, ptr align 4 %x, i32 4, i1 false)

test/test_suite2/errors/failable_taddr_and_access.c3t

@@ -44,77 +44,77 @@ entry:
   %w = alloca ptr, align 8
   %w.f = alloca i64, align 8
   %literal = alloca %Foo, align 4
-  %literal5 = alloca %Foo, align 4
+  %literal6 = alloca %Foo, align 4
   store i32 2, ptr %z, align 4
   store i64 0, ptr %z.f, align 8
   %0 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 0
-  %1 = load i64, ptr %z.f, align 8
+  %optval = load i64, ptr %z.f, align 8
-  %not_err = icmp eq i64 %1, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %1, ptr %w.f, align 8
+  store i64 %optval, ptr %w.f, align 8
   br label %after_assign
 
 after_check:                                      ; preds = %entry
-  %2 = load i32, ptr %z, align 4
+  %1 = load i32, ptr %z, align 4
-  store i32 %2, ptr %0, align 4
+  store i32 %1, ptr %0, align 4
-  %3 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
+  %2 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1
-  store i32 0, ptr %3, align 4
+  store i32 0, ptr %2, align 4
   store ptr %literal, ptr %w, align 8
   store i64 0, ptr %w.f, align 8
   br label %after_assign
 
 after_assign:                                     ; preds = %after_check, %assign_optional
-  %4 = load i64, ptr %w.f, align 8
+  %optval1 = load i64, ptr %w.f, align 8
-  %not_err1 = icmp eq i64 %4, 0
+  %not_err2 = icmp eq i64 %optval1, 0
-  br i1 %not_err1, label %after_check2, label %voiderr
+  br i1 %not_err2, label %after_check3, label %voiderr
 
-after_check2:                                     ; preds = %after_assign
+after_check3:                                     ; preds = %after_assign
-  %5 = load ptr, ptr %w, align 8
+  %3 = load ptr, ptr %w, align 8
-  %6 = getelementptr inbounds %Foo, ptr %5, i32 0, i32 0
+  %4 = getelementptr inbounds %Foo, ptr %3, i32 0, i32 0
-  %7 = load i32, ptr %6, align 8
+  %5 = load i32, ptr %4, align 8
-  %8 = call i32 (ptr, ...) @printf(ptr @.str, i32 %7)
+  %6 = call i32 (ptr, ...) @printf(ptr @.str, i32 %5)
   br label %voiderr
 
-voiderr:                                          ; preds = %after_check2, %after_assign
+voiderr:                                          ; preds = %after_check3, %after_assign
   store i64 ptrtoint (ptr @"test_MyErr$FOO" to i64), ptr %z.f, align 8
-  br label %voiderr4
+  br label %voiderr5
 
-voiderr4:                                         ; preds = %voiderr
+voiderr5:                                         ; preds = %voiderr
-  %9 = getelementptr inbounds %Foo, ptr %literal5, i32 0, i32 0
+  %7 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 0
-  %10 = load i64, ptr %z.f, align 8
+  %optval7 = load i64, ptr %z.f, align 8
-  %not_err6 = icmp eq i64 %10, 0
+  %not_err8 = icmp eq i64 %optval7, 0
-  br i1 %not_err6, label %after_check8, label %assign_optional7
+  br i1 %not_err8, label %after_check10, label %assign_optional9
 
-assign_optional7:                                 ; preds = %voiderr4
+assign_optional9:                                 ; preds = %voiderr5
-  store i64 %10, ptr %w.f, align 8
+  store i64 %optval7, ptr %w.f, align 8
-  br label %after_assign9
+  br label %after_assign11
 
-after_check8:                                     ; preds = %voiderr4
+after_check10:                                    ; preds = %voiderr5
-  %11 = load i32, ptr %z, align 4
+  %8 = load i32, ptr %z, align 4
-  store i32 %11, ptr %9, align 4
+  store i32 %8, ptr %7, align 4
-  %12 = getelementptr inbounds %Foo, ptr %literal5, i32 0, i32 1
+  %9 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 1
-  store i32 0, ptr %12, align 4
+  store i32 0, ptr %9, align 4
-  store ptr %literal5, ptr %w, align 8
+  store ptr %literal6, ptr %w, align 8
   store i64 0, ptr %w.f, align 8
-  br label %after_assign9
+  br label %after_assign11
 
-after_assign9:                                    ; preds = %after_check8, %assign_optional7
+after_assign11:                                   ; preds = %after_check10, %assign_optional9
-  br label %voiderr10
+  br label %voiderr12
 
-voiderr10:                                        ; preds = %after_assign9
+voiderr12:                                        ; preds = %after_assign11
-  %13 = load i64, ptr %w.f, align 8
+  %optval13 = load i64, ptr %w.f, align 8
-  %not_err11 = icmp eq i64 %13, 0
+  %not_err14 = icmp eq i64 %optval13, 0
-  br i1 %not_err11, label %after_check12, label %voiderr13
+  br i1 %not_err14, label %after_check15, label %voiderr16
 
-after_check12:                                    ; preds = %voiderr10
+after_check15:                                    ; preds = %voiderr12
-  %14 = load ptr, ptr %w, align 8
+  %10 = load ptr, ptr %w, align 8
-  %15 = getelementptr inbounds %Foo, ptr %14, i32 0, i32 0
+  %11 = getelementptr inbounds %Foo, ptr %10, i32 0, i32 0
-  %16 = load i32, ptr %15, align 8
+  %12 = load i32, ptr %11, align 8
-  %17 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %16)
+  %13 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %12)
-  br label %voiderr13
+  br label %voiderr16
 
-voiderr13:                                        ; preds = %after_check12, %voiderr10
+voiderr16:                                        ; preds = %after_check15, %voiderr12
   ret void
 }

test/test_suite2/errors/or_err_bool.c3t

@@ -16,19 +16,19 @@ entry:
   %x.f = alloca i64, align 8
   store i8 0, ptr %x, align 1
   store i64 0, ptr %x.f, align 8
-  %0 = load i64, ptr %x.f, align 8
+  %optval = load i64, ptr %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %else_block
 
 after_check:                                      ; preds = %entry
-  %1 = load i8, ptr %x, align 1
+  %0 = load i8, ptr %x, align 1
-  %2 = trunc i8 %1 to i1
+  %1 = trunc i8 %0 to i1
   br label %phi_block
 
 else_block:                                       ; preds = %entry
   br label %phi_block
 
 phi_block:                                        ; preds = %else_block, %after_check
-  %val = phi i1 [ %2, %after_check ], [ true, %else_block ]
+  %val = phi i1 [ %1, %after_check ], [ true, %else_block ]
   ret void
 }

test/test_suite2/errors/rethrow.c3t

@@ -14,20 +14,20 @@ fn void! test()
   %reterr = alloca i64, align 8
   store i64 0, ptr %i.f, align 8
   store i32 0, ptr %i, align 4
-  %0 = load i64, ptr %i.f, align 8
+  %optval = load i64, ptr %i.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, ptr %error_var, align 8
+  store i64 %optval, ptr %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %1 = load i64, ptr %error_var, align 8
+  %0 = load i64, ptr %error_var, align 8
-  ret i64 %1
+  ret i64 %0
 
 noerr_block:                                      ; preds = %after_check
   ret i64 0

test/test_suite2/errors/rethrow_mingw.c3t

@@ -18,20 +18,20 @@ entry:
   %reterr = alloca i64, align 8
   store i64 0, ptr %i.f, align 8
   store i32 0, ptr %i, align 4
-  %0 = load i64, ptr %i.f, align 8
+  %optval = load i64, ptr %i.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %entry
-  store i64 %0, ptr %error_var, align 8
+  store i64 %optval, ptr %error_var, align 8
   br label %guard_block
 
 after_check:                                      ; preds = %entry
   br label %noerr_block
 
 guard_block:                                      ; preds = %assign_optional
-  %1 = load i64, ptr %error_var, align 8
+  %0 = load i64, ptr %error_var, align 8
-  ret i64 %1
+  ret i64 %0
 
 noerr_block:                                      ; preds = %after_check
   ret i64 0

test/test_suite2/errors/try_assign.c3t

@@ -43,13 +43,13 @@ entry:
   store i64 0, ptr %w.f, align 8
   store i32 0, ptr %w, align 4
   store i32 1, ptr %gh, align 4
-  %0 = load i64, ptr %z.f, align 8
+  %optval = load i64, ptr %z.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %catch_landing
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, ptr %z, align 4
+  %0 = load i32, ptr %z, align 4
-  store i32 %1, ptr %x, align 4
+  store i32 %0, ptr %x, align 4
   br label %phi_try_catch
 
 catch_landing:                                    ; preds = %entry
@@ -60,93 +60,93 @@ phi_try_catch:                                    ; preds = %catch_landing, %aft
   br i1 %val, label %chain_next, label %fail_chain
 
 chain_next:                                       ; preds = %phi_try_catch
-  %2 = load i64, ptr %w.f, align 8
+  %optval1 = load i64, ptr %w.f, align 8
-  %not_err1 = icmp eq i64 %2, 0
+  %not_err2 = icmp eq i64 %optval1, 0
-  br i1 %not_err1, label %after_check2, label %catch_landing3
+  br i1 %not_err2, label %after_check3, label %catch_landing4
 
-after_check2:                                     ; preds = %chain_next
+after_check3:                                     ; preds = %chain_next
-  %3 = load i32, ptr %w, align 4
+  %1 = load i32, ptr %w, align 4
-  store i32 %3, ptr %gh, align 4
+  store i32 %1, ptr %gh, align 4
-  br label %phi_try_catch4
+  br label %phi_try_catch5
 
-catch_landing3:                                   ; preds = %chain_next
+catch_landing4:                                   ; preds = %chain_next
-  br label %phi_try_catch4
+  br label %phi_try_catch5
 
-phi_try_catch4:                                   ; preds = %catch_landing3, %after_check2
+phi_try_catch5:                                   ; preds = %catch_landing4, %after_check3
-  %val5 = phi i1 [ true, %after_check2 ], [ false, %catch_landing3 ]
+  %val6 = phi i1 [ true, %after_check3 ], [ false, %catch_landing4 ]
-  br i1 %val5, label %chain_next6, label %fail_chain
+  br i1 %val6, label %chain_next7, label %fail_chain
 
-chain_next6:                                      ; preds = %phi_try_catch4
+chain_next7:                                      ; preds = %phi_try_catch5
   br label %end_chain
 
-fail_chain:                                       ; preds = %phi_try_catch4, %phi_try_catch
+fail_chain:                                       ; preds = %phi_try_catch5, %phi_try_catch
   br label %end_chain
 
-end_chain:                                        ; preds = %fail_chain, %chain_next6
+end_chain:                                        ; preds = %fail_chain, %chain_next7
-  %chain.phi = phi i1 [ true, %chain_next6 ], [ false, %fail_chain ]
+  %chain.phi = phi i1 [ true, %chain_next7 ], [ false, %fail_chain ]
   br i1 %chain.phi, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_chain
-  %4 = load i32, ptr %x, align 4
+  %2 = load i32, ptr %x, align 4
-  %5 = load i32, ptr %gh, align 4
+  %3 = load i32, ptr %gh, align 4
-  %6 = call i32 (ptr, ...) @printf(ptr @.str, i32 %4, i32 %5)
+  %4 = call i32 (ptr, ...) @printf(ptr @.str, i32 %2, i32 %3)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_chain
-  %7 = load i64, ptr %z.f, align 8
+  %optval8 = load i64, ptr %z.f, align 8
-  %not_err7 = icmp eq i64 %7, 0
+  %not_err9 = icmp eq i64 %optval8, 0
-  br i1 %not_err7, label %after_check8, label %catch_landing11
+  br i1 %not_err9, label %after_check10, label %catch_landing14
 
-after_check8:                                     ; preds = %if.exit
+after_check10:                                    ; preds = %if.exit
-  %8 = load i32, ptr %z, align 4
+  %5 = load i32, ptr %z, align 4
-  %9 = load i64, ptr %w.f, align 8
+  %optval11 = load i64, ptr %w.f, align 8
-  %not_err9 = icmp eq i64 %9, 0
+  %not_err12 = icmp eq i64 %optval11, 0
-  br i1 %not_err9, label %after_check10, label %catch_landing11
+  br i1 %not_err12, label %after_check13, label %catch_landing14
 
-after_check10:                                    ; preds = %after_check8
+after_check13:                                    ; preds = %after_check10
-  %10 = load i32, ptr %w, align 4
+  %6 = load i32, ptr %w, align 4
-  %add = add i32 %8, %10
+  %add = add i32 %5, %6
   store i32 %add, ptr %x, align 4
-  br label %phi_try_catch12
+  br label %phi_try_catch15
 
-catch_landing11:                                  ; preds = %after_check8, %if.exit
+catch_landing14:                                  ; preds = %after_check10, %if.exit
-  br label %phi_try_catch12
+  br label %phi_try_catch15
 
-phi_try_catch12:                                  ; preds = %catch_landing11, %after_check10
+phi_try_catch15:                                  ; preds = %catch_landing14, %after_check13
-  %val13 = phi i1 [ true, %after_check10 ], [ false, %catch_landing11 ]
+  %val16 = phi i1 [ true, %after_check13 ], [ false, %catch_landing14 ]
-  br i1 %val13, label %if.then14, label %if.exit15
+  br i1 %val16, label %if.then17, label %if.exit18
 
-if.then14:                                        ; preds = %phi_try_catch12
+if.then17:                                        ; preds = %phi_try_catch15
-  %11 = call i32 (ptr, ...) @printf(ptr @.str.1)
+  %7 = call i32 (ptr, ...) @printf(ptr @.str.1)
-  br label %if.exit15
+  br label %if.exit18
 
-if.exit15:                                        ; preds = %if.then14, %phi_try_catch12
+if.exit18:                                        ; preds = %if.then17, %phi_try_catch15
   store i64 0, ptr %e, align 8
   br label %testblock
 
-testblock:                                        ; preds = %if.exit15
+testblock:                                        ; preds = %if.exit18
-  %12 = load i64, ptr %z.f, align 8
+  %optval19 = load i64, ptr %z.f, align 8
-  %not_err16 = icmp eq i64 %12, 0
+  %not_err20 = icmp eq i64 %optval19, 0
-  br i1 %not_err16, label %after_check17, label %assign_optional
+  br i1 %not_err20, label %after_check21, label %assign_optional
 
 assign_optional:                                  ; preds = %testblock
-  store i64 %12, ptr %e, align 8
+  store i64 %optval19, ptr %e, align 8
   br label %end_block
 
-after_check17:                                    ; preds = %testblock
+after_check21:                                    ; preds = %testblock
   store i64 0, ptr %e, align 8
   br label %end_block
 
-end_block:                                        ; preds = %after_check17, %assign_optional
+end_block:                                        ; preds = %after_check21, %assign_optional
-  %13 = load i64, ptr %e, align 8
+  %8 = load i64, ptr %e, align 8
-  %neq = icmp ne i64 %13, 0
+  %neq = icmp ne i64 %8, 0
-  br i1 %neq, label %if.then18, label %if.exit19
+  br i1 %neq, label %if.then22, label %if.exit23
 
-if.then18:                                        ; preds = %end_block
+if.then22:                                        ; preds = %end_block
-  %14 = call i32 (ptr, ...) @printf(ptr @.str.2)
+  %9 = call i32 (ptr, ...) @printf(ptr @.str.2)
-  br label %if.exit19
+  br label %if.exit23
 
-if.exit19:                                        ; preds = %if.then18, %end_block
+if.exit23:                                        ; preds = %if.then22, %end_block
   ret void
 }
 

test/test_suite2/errors/try_catch_if.c3t

@@ -56,24 +56,24 @@ entry:
   br label %testblock
 
 testblock:                                        ; preds = %entry
-  %0 = load i64, ptr %a.f, align 8
+  %optval = load i64, ptr %a.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %testblock
-  store i64 %0, ptr %err, align 8
+  store i64 %optval, ptr %err, align 8
   br label %end_block
 
 after_check:                                      ; preds = %testblock
   br label %testblock1
 
 testblock1:                                       ; preds = %after_check
-  %1 = call i64 @try_catch_if_tester(ptr %retparam)
+  %0 = call i64 @try_catch_if_tester(ptr %retparam)
-  %not_err2 = icmp eq i64 %1, 0
+  %not_err2 = icmp eq i64 %0, 0
   br i1 %not_err2, label %after_check4, label %assign_optional3
 
 assign_optional3:                                 ; preds = %testblock1
-  store i64 %1, ptr %err, align 8
+  store i64 %0, ptr %err, align 8
   br label %end_block
 
 after_check4:                                     ; preds = %testblock1
@@ -81,17 +81,17 @@ after_check4:                                     ; preds = %testblock1
   br label %end_block
 
 end_block:                                        ; preds = %after_check4, %assign_optional3, %assign_optional
-  %2 = load i64, ptr %err, align 8
+  %1 = load i64, ptr %err, align 8
-  %neq = icmp ne i64 %2, 0
+  %neq = icmp ne i64 %1, 0
   br i1 %neq, label %if.then, label %if.else
 
 if.then:                                          ; preds = %end_block
-  %3 = call i32 (ptr, ...) @printf(ptr @.str.1)
+  %2 = call i32 (ptr, ...) @printf(ptr @.str.1)
   br label %if.exit
 
 if.else:                                          ; preds = %end_block
-  %4 = load i32, ptr %a, align 4
+  %3 = load i32, ptr %a, align 4
-  %5 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %4)
+  %4 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %3)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.else, %if.then

test/test_suite2/errors/try_with_unwrapper.c3t

@@ -74,13 +74,13 @@ entry:
   store i32 11, ptr %a, align 4
   store i64 0, ptr %a.f, align 8
   store i32 0, ptr %b, align 4
-  %0 = load i64, ptr %a.f, align 8
+  %optval = load i64, ptr %a.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %catch_landing
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, ptr %a, align 4
+  %0 = load i32, ptr %a, align 4
-  store i32 %1, ptr %b, align 4
+  store i32 %0, ptr %b, align 4
   br label %phi_try_catch
 
 catch_landing:                                    ; preds = %entry
@@ -92,13 +92,13 @@ phi_try_catch:                                    ; preds = %catch_landing, %aft
 
 chain_next:                                       ; preds = %phi_try_catch
   store i32 0, ptr %c, align 4
-  %2 = call i64 @try_with_unwrapper_tester(ptr %retparam)
+  %1 = call i64 @try_with_unwrapper_tester(ptr %retparam)
-  %not_err1 = icmp eq i64 %2, 0
+  %not_err1 = icmp eq i64 %1, 0
   br i1 %not_err1, label %after_check2, label %catch_landing3
 
 after_check2:                                     ; preds = %chain_next
-  %3 = load i32, ptr %retparam, align 4
+  %2 = load i32, ptr %retparam, align 4
-  store i32 %3, ptr %c, align 4
+  store i32 %2, ptr %c, align 4
   br label %phi_try_catch4
 
 catch_landing3:                                   ; preds = %chain_next
@@ -119,11 +119,11 @@ end_chain:                                        ; preds = %fail_chain, %chain_
   br i1 %chain.phi, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_chain
-  %4 = load i32, ptr %b, align 4
+  %3 = load i32, ptr %b, align 4
-  %5 = call i32 @try_with_unwrapper_hello(i32 %4)
+  %4 = call i32 @try_with_unwrapper_hello(i32 %3)
-  %6 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %5)
+  %5 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %4)
-  %7 = load i32, ptr %c, align 4
+  %6 = load i32, ptr %c, align 4
-  %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %7)
+  %7 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %6)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_chain
@@ -140,13 +140,13 @@ entry:
   store i64 0, ptr %a.f, align 8
   store i32 0, ptr %a, align 4
   store i32 0, ptr %b, align 4
-  %0 = load i64, ptr %a.f, align 8
+  %optval = load i64, ptr %a.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %catch_landing
 
 after_check:                                      ; preds = %entry
-  %1 = load i32, ptr %a, align 4
+  %0 = load i32, ptr %a, align 4
-  store i32 %1, ptr %b, align 4
+  store i32 %0, ptr %b, align 4
   br label %phi_try_catch
 
 catch_landing:                                    ; preds = %entry
@@ -157,9 +157,9 @@ phi_try_catch:                                    ; preds = %catch_landing, %aft
   br i1 %val, label %chain_next, label %fail_chain
 
 chain_next:                                       ; preds = %phi_try_catch
-  %2 = load i32, ptr %b, align 4
+  %1 = load i32, ptr %b, align 4
-  %3 = call i32 @try_with_unwrapper_hello(i32 %2)
+  %2 = call i32 @try_with_unwrapper_hello(i32 %1)
-  %intbool = icmp ne i32 %3, 0
+  %intbool = icmp ne i32 %2, 0
   br i1 %intbool, label %chain_next1, label %fail_chain
 
 chain_next1:                                      ; preds = %chain_next
@@ -173,9 +173,9 @@ end_chain:                                        ; preds = %fail_chain, %chain_
   br i1 %chain.phi, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_chain
-  %4 = load i32, ptr %b, align 4
+  %3 = load i32, ptr %b, align 4
-  %add = add i32 %4, 1
+  %add = add i32 %3, 1
-  %5 = call i32 @try_with_unwrapper_hello(i32 %add)
+  %4 = call i32 @try_with_unwrapper_hello(i32 %add)
   br label %if.exit
 
 if.exit:                                          ; preds = %if.then, %end_chain

test/test_suite2/expressions/chained_ternary.c3t

@@ -19,6 +19,7 @@ fn void test()
 }
 
 /* #expect: test.ll
+
   %0 = load ptr, ptr %a, align 8
   %not = icmp eq ptr %0, null
   br i1 %not, label %cond.lhs, label %cond.rhs
@@ -54,174 +55,175 @@ cond.phi4:                                        ; preds = %cond.phi, %cond.lhs
   br i1 %not6, label %cond.lhs7, label %cond.rhs8
 
 cond.lhs7:                                        ; preds = %cond.phi4
-  %6 = load i64, ptr %x.f, align 8
+  %optval = load i64, ptr %x.f, align 8
-  %not_err = icmp eq i64 %6, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %cond.lhs7
-  store i64 %6, ptr %y.f, align 8
+  store i64 %optval, ptr %y.f, align 8
   br label %after_assign
 
 after_check:                                      ; preds = %cond.lhs7
-  %7 = load ptr, ptr %x, align 8
+  %6 = load ptr, ptr %x, align 8
   br label %cond.phi9
 
 cond.rhs8:                                        ; preds = %cond.phi4
-  %8 = load ptr, ptr %b, align 8
+  %7 = load ptr, ptr %b, align 8
   br label %cond.phi9
 
 cond.phi9:                                        ; preds = %cond.rhs8, %after_check
-  %val10 = phi ptr [ %7, %after_check ], [ %8, %cond.rhs8 ]
+  %val10 = phi ptr [ %6, %after_check ], [ %7, %cond.rhs8 ]
   store ptr %val10, ptr %y, align 8
   store i64 0, ptr %y.f, align 8
   br label %after_assign
 
 after_assign:                                     ; preds = %cond.phi9, %assign_optional
-  %9 = load ptr, ptr %a, align 8
+  %8 = load ptr, ptr %a, align 8
-  %not11 = icmp eq ptr %9, null
+  %not11 = icmp eq ptr %8, null
   br i1 %not11, label %cond.lhs12, label %cond.rhs13
 
 cond.lhs12:                                       ; preds = %after_assign
-  %10 = load ptr, ptr %b, align 8
+  %9 = load ptr, ptr %b, align 8
-  br label %cond.phi17
+  br label %cond.phi18
 
 cond.rhs13:                                       ; preds = %after_assign
-  %11 = load i64, ptr %x.f, align 8
+  %optval14 = load i64, ptr %x.f, align 8
-  %not_err14 = icmp eq i64 %11, 0
+  %not_err15 = icmp eq i64 %optval14, 0
-  br i1 %not_err14, label %after_check16, label %assign_optional15
+  br i1 %not_err15, label %after_check17, label %assign_optional16
 
-assign_optional15:                                ; preds = %cond.rhs13
+assign_optional16:                                ; preds = %cond.rhs13
-  store i64 %11, ptr %y.f, align 8
+  store i64 %optval14, ptr %y.f, align 8
-  br label %after_assign19
+  br label %after_assign20
 
-after_check16:                                    ; preds = %cond.rhs13
+after_check17:                                    ; preds = %cond.rhs13
-  %12 = load ptr, ptr %x, align 8
+  %10 = load ptr, ptr %x, align 8
-  br label %cond.phi17
+  br label %cond.phi18
 
-cond.phi17:                                       ; preds = %after_check16, %cond.lhs12
+cond.phi18:                                       ; preds = %after_check17, %cond.lhs12
-  %val18 = phi ptr [ %10, %cond.lhs12 ], [ %12, %after_check16 ]
+  %val19 = phi ptr [ %9, %cond.lhs12 ], [ %10, %after_check17 ]
-  store ptr %val18, ptr %y, align 8
+  store ptr %val19, ptr %y, align 8
   store i64 0, ptr %y.f, align 8
-  br label %after_assign19
+  br label %after_assign20
 
-after_assign19:                                   ; preds = %cond.phi17, %assign_optional15
+after_assign20:                                   ; preds = %cond.phi18, %assign_optional16
   br label %voiderr
 
-voiderr:                                          ; preds = %after_assign19
+voiderr:                                          ; preds = %after_assign20
-  %13 = load ptr, ptr %a, align 8
+  %11 = load ptr, ptr %a, align 8
-  %not20 = icmp eq ptr %13, null
+  %not21 = icmp eq ptr %11, null
-  br i1 %not20, label %cond.lhs21, label %cond.rhs25
+  br i1 %not21, label %cond.lhs22, label %cond.rhs27
 
-cond.lhs21:                                       ; preds = %voiderr
+cond.lhs22:                                       ; preds = %voiderr
-  %14 = load i64, ptr %x.f, align 8
+  %optval23 = load i64, ptr %x.f, align 8
-  %not_err22 = icmp eq i64 %14, 0
+  %not_err24 = icmp eq i64 %optval23, 0
-  br i1 %not_err22, label %after_check24, label %assign_optional23
+  br i1 %not_err24, label %after_check26, label %assign_optional25
 
-assign_optional23:                                ; preds = %cond.lhs21
+assign_optional25:                                ; preds = %cond.lhs22
-  store i64 %14, ptr %y.f, align 8
+  store i64 %optval23, ptr %y.f, align 8
-  br label %after_assign31
+  br label %after_assign34
 
-after_check24:                                    ; preds = %cond.lhs21
+after_check26:                                    ; preds = %cond.lhs22
+  %12 = load ptr, ptr %x, align 8
+  br label %cond.phi32
+
+cond.rhs27:                                       ; preds = %voiderr
+  %optval28 = load i64, ptr %x.f, align 8
+  %not_err29 = icmp eq i64 %optval28, 0
+  br i1 %not_err29, label %after_check31, label %assign_optional30
+
+assign_optional30:                                ; preds = %cond.rhs27
+  store i64 %optval28, ptr %y.f, align 8
+  br label %after_assign34
+
+after_check31:                                    ; preds = %cond.rhs27
+  %13 = load ptr, ptr %x, align 8
+  br label %cond.phi32
+
+cond.phi32:                                       ; preds = %after_check31, %after_check26
+  %val33 = phi ptr [ %12, %after_check26 ], [ %13, %after_check31 ]
+  store ptr %val33, ptr %y, align 8
+  store i64 0, ptr %y.f, align 8
+  br label %after_assign34
+
+after_assign34:                                   ; preds = %cond.phi32, %assign_optional30, %assign_optional25
+  br label %voiderr35
+
+voiderr35:                                        ; preds = %after_assign34
+  %14 = load ptr, ptr %a, align 8
+  %not36 = icmp eq ptr %14, null
+  br i1 %not36, label %cond.lhs37, label %cond.rhs42
+
+cond.lhs37:                                       ; preds = %voiderr35
+  %optval38 = load i64, ptr %x.f, align 8
+  %not_err39 = icmp eq i64 %optval38, 0
+  br i1 %not_err39, label %after_check41, label %assign_optional40
+
+assign_optional40:                                ; preds = %cond.lhs37
+  store i64 %optval38, ptr %y.f, align 8
+  br label %after_assign44
+
+after_check41:                                    ; preds = %cond.lhs37
   %15 = load ptr, ptr %x, align 8
-  br label %cond.phi29
+  br label %cond.phi43
 
-cond.rhs25:                                       ; preds = %voiderr
+cond.rhs42:                                       ; preds = %voiderr35
-  %16 = load i64, ptr %x.f, align 8
+  store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
-  %not_err26 = icmp eq i64 %16, 0
+  br label %after_assign44
-  br i1 %not_err26, label %after_check28, label %assign_optional27
 
-assign_optional27:                                ; preds = %cond.rhs25
+cond.phi43:                                       ; preds = %after_check41
-  store i64 %16, ptr %y.f, align 8
+  store ptr %15, ptr %y, align 8
-  br label %after_assign31
+  store i64 0, ptr %y.f, align 8
+  br label %after_assign44
 
-after_check28:                                    ; preds = %cond.rhs25
+after_assign44:                                   ; preds = %cond.phi43, %cond.rhs42, %assign_optional40
+  br label %voiderr45
+
+voiderr45:                                        ; preds = %after_assign44
+  %16 = load ptr, ptr %a, align 8
+  %not46 = icmp eq ptr %16, null
+  br i1 %not46, label %cond.lhs47, label %cond.rhs48
+
+cond.lhs47:                                       ; preds = %voiderr45
+  store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
+  br label %after_assign54
+
+cond.rhs48:                                       ; preds = %voiderr45
+  %optval49 = load i64, ptr %x.f, align 8
+  %not_err50 = icmp eq i64 %optval49, 0
+  br i1 %not_err50, label %after_check52, label %assign_optional51
+
+assign_optional51:                                ; preds = %cond.rhs48
+  store i64 %optval49, ptr %y.f, align 8
+  br label %after_assign54
+
+after_check52:                                    ; preds = %cond.rhs48
   %17 = load ptr, ptr %x, align 8
-  br label %cond.phi29
+  br label %cond.phi53
 
-cond.phi29:                                       ; preds = %after_check28, %after_check24
+cond.phi53:                                       ; preds = %after_check52
-  %val30 = phi ptr [ %15, %after_check24 ], [ %17, %after_check28 ]
+  store ptr %17, ptr %y, align 8
-  store ptr %val30, ptr %y, align 8
   store i64 0, ptr %y.f, align 8
-  br label %after_assign31
+  br label %after_assign54
 
-after_assign31:                                   ; preds = %cond.phi29, %assign_optional27, %assign_optional23
+after_assign54:                                   ; preds = %cond.phi53, %assign_optional51, %cond.lhs47
-  br label %voiderr32
+  br label %voiderr55
 
-voiderr32:                                        ; preds = %after_assign31
+voiderr55:                                        ; preds = %after_assign54
   %18 = load ptr, ptr %a, align 8
-  %not33 = icmp eq ptr %18, null
+  %not56 = icmp eq ptr %18, null
-  br i1 %not33, label %cond.lhs34, label %cond.rhs38
+  br i1 %not56, label %cond.lhs57, label %cond.rhs58
 
-cond.lhs34:                                       ; preds = %voiderr32
+cond.lhs57:                                       ; preds = %voiderr55
-  %19 = load i64, ptr %x.f, align 8
-  %not_err35 = icmp eq i64 %19, 0
-  br i1 %not_err35, label %after_check37, label %assign_optional36
-
-assign_optional36:                                ; preds = %cond.lhs34
-  store i64 %19, ptr %y.f, align 8
-  br label %after_assign40
-
-after_check37:                                    ; preds = %cond.lhs34
-  %20 = load ptr, ptr %x, align 8
-  br label %cond.phi39
-
-cond.rhs38:                                       ; preds = %voiderr32
   store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
-  br label %after_assign40
+  br label %after_assign60
 
-cond.phi39:                                       ; preds = %after_check37
+cond.rhs58:                                       ; preds = %voiderr55
-  store ptr %20, ptr %y, align 8
-  store i64 0, ptr %y.f, align 8
-  br label %after_assign40
-
-after_assign40:                                   ; preds = %cond.phi39, %cond.rhs38, %assign_optional36
-  br label %voiderr41
-
-voiderr41:                                        ; preds = %after_assign40
-  %21 = load ptr, ptr %a, align 8
-  %not42 = icmp eq ptr %21, null
-  br i1 %not42, label %cond.lhs43, label %cond.rhs44
-
-cond.lhs43:                                       ; preds = %voiderr41
-  store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
-  br label %after_assign49
-
-cond.rhs44:                                       ; preds = %voiderr41
-  %22 = load i64, ptr %x.f, align 8
-  %not_err45 = icmp eq i64 %22, 0
-  br i1 %not_err45, label %after_check47, label %assign_optional46
-
-assign_optional46:                                ; preds = %cond.rhs44
-  store i64 %22, ptr %y.f, align 8
-  br label %after_assign49
-
-after_check47:                                    ; preds = %cond.rhs44
-  %23 = load ptr, ptr %x, align 8
-  br label %cond.phi48
-
-cond.phi48:                                       ; preds = %after_check47
-  store ptr %23, ptr %y, align 8
-  store i64 0, ptr %y.f, align 8
-  br label %after_assign49
-
-after_assign49:                                   ; preds = %cond.phi48, %assign_optional46, %cond.lhs43
-  br label %voiderr50
-
-voiderr50:                                        ; preds = %after_assign49
-  %24 = load ptr, ptr %a, align 8
-  %not51 = icmp eq ptr %24, null
-  br i1 %not51, label %cond.lhs52, label %cond.rhs53
-
-cond.lhs52:                                       ; preds = %voiderr50
-  store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8
-  br label %after_assign55
-
-cond.rhs53:                                       ; preds = %voiderr50
   store i64 ptrtoint (ptr @"test_Test$BAR" to i64), ptr %y.f, align 8
-  br label %after_assign55
+  br label %after_assign60
 
-after_assign55:                                   ; preds = %cond.rhs53, %cond.lhs52
+after_assign60:                                   ; preds = %cond.rhs58, %cond.lhs57
-  br label %voiderr56
+  br label %voiderr61
 
-voiderr56:                                        ; preds = %after_assign55
+voiderr61:                                        ; preds = %after_assign60
   ret void
+}

test/test_suite2/failable_catch.c3t

@@ -65,13 +65,13 @@ expr_block.exit:                                  ; preds = %if.then
   br label %after_assign
 
 after_assign:                                     ; preds = %expr_block.exit, %if.exit
-  %3 = load i64, ptr %a.f, align 8
+  %optval = load i64, ptr %a.f, align 8
-  %not_err = icmp eq i64 %3, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %else_block
 
 after_check:                                      ; preds = %after_assign
-  %4 = load i32, ptr %a, align 4
+  %3 = load i32, ptr %a, align 4
-  %add = add i32 %4, 3
+  %add = add i32 %3, 3
   br label %phi_block
 
 else_block:                                       ; preds = %after_assign
@@ -80,13 +80,13 @@ else_block:                                       ; preds = %after_assign
 phi_block:                                        ; preds = %else_block, %after_check
   %val = phi i32 [ %add, %after_check ], [ 2, %else_block ]
   store i32 %val, ptr %x1, align 4
-  %5 = load i32, ptr %x1, align 4
+  %4 = load i32, ptr %x1, align 4
-  %intbool3 = icmp ne i32 %5, 0
+  %intbool3 = icmp ne i32 %4, 0
   br i1 %intbool3, label %if.then4, label %if.exit5
 
 if.then4:                                         ; preds = %phi_block
-  %6 = load i32, ptr %x1, align 4
+  %5 = load i32, ptr %x1, align 4
-  store i32 %6, ptr %blockret2, align 4
+  store i32 %5, ptr %blockret2, align 4
   br label %expr_block.exit6
 
 if.exit5:                                         ; preds = %phi_block
@@ -94,20 +94,20 @@ if.exit5:                                         ; preds = %phi_block
   br label %after_assign7
 
 expr_block.exit6:                                 ; preds = %if.then4
-  %7 = load i32, ptr %blockret2, align 4
+  %6 = load i32, ptr %blockret2, align 4
-  store i32 %7, ptr %b, align 4
+  store i32 %6, ptr %b, align 4
   store i64 0, ptr %b.f, align 8
   br label %after_assign7
 
 after_assign7:                                    ; preds = %expr_block.exit6, %if.exit5
   store i32 0, ptr %x8, align 4
-  %8 = load i32, ptr %x8, align 4
+  %7 = load i32, ptr %x8, align 4
-  %intbool10 = icmp ne i32 %8, 0
+  %intbool10 = icmp ne i32 %7, 0
   br i1 %intbool10, label %if.then11, label %if.exit12
 
 if.then11:                                        ; preds = %after_assign7
-  %9 = load i32, ptr %x8, align 4
+  %8 = load i32, ptr %x8, align 4
-  store i32 %9, ptr %blockret9, align 4
+  store i32 %8, ptr %blockret9, align 4
   br label %expr_block.exit13
 
 if.exit12:                                        ; preds = %after_assign7
@@ -115,62 +115,62 @@ if.exit12:                                        ; preds = %after_assign7
   br label %after_assign14
 
 expr_block.exit13:                                ; preds = %if.then11
-  %10 = load i32, ptr %blockret9, align 4
+  %9 = load i32, ptr %blockret9, align 4
-  store i32 %10, ptr %c, align 4
+  store i32 %9, ptr %c, align 4
   store i64 0, ptr %c.f, align 8
   br label %after_assign14
 
 after_assign14:                                   ; preds = %expr_block.exit13, %if.exit12
-  %11 = load i64, ptr %a.f, align 8
+  %optval15 = load i64, ptr %a.f, align 8
-  %not_err15 = icmp eq i64 %11, 0
+  %not_err16 = icmp eq i64 %optval15, 0
-  br i1 %not_err15, label %after_check16, label %voiderr
+  br i1 %not_err16, label %after_check17, label %voiderr
 
-after_check16:                                    ; preds = %after_assign14
+after_check17:                                    ; preds = %after_assign14
-  %12 = load i32, ptr %a, align 4
+  %10 = load i32, ptr %a, align 4
-  call void (ptr, ...) @printf(ptr @.str, i32 %12)
+  call void (ptr, ...) @printf(ptr @.str, i32 %10)
   br label %voiderr
 
-voiderr:                                          ; preds = %after_check16, %after_assign14
+voiderr:                                          ; preds = %after_check17, %after_assign14
-  %13 = load i64, ptr %b.f, align 8
+  %optval18 = load i64, ptr %b.f, align 8
-  %not_err17 = icmp eq i64 %13, 0
+  %not_err19 = icmp eq i64 %optval18, 0
-  br i1 %not_err17, label %after_check18, label %voiderr19
+  br i1 %not_err19, label %after_check20, label %voiderr21
 
-after_check18:                                    ; preds = %voiderr
+after_check20:                                    ; preds = %voiderr
-  %14 = load i32, ptr %b, align 4
+  %11 = load i32, ptr %b, align 4
-  call void (ptr, ...) @printf(ptr @.str.1, i32 %14)
+  call void (ptr, ...) @printf(ptr @.str.1, i32 %11)
-  br label %voiderr19
+  br label %voiderr21
 
-voiderr19:                                        ; preds = %after_check18, %voiderr
+voiderr21:                                        ; preds = %after_check20, %voiderr
-  %15 = load i64, ptr %c.f, align 8
+  %optval22 = load i64, ptr %c.f, align 8
-  %not_err20 = icmp eq i64 %15, 0
+  %not_err23 = icmp eq i64 %optval22, 0
-  br i1 %not_err20, label %after_check21, label %voiderr22
+  br i1 %not_err23, label %after_check24, label %voiderr25
 
-after_check21:                                    ; preds = %voiderr19
+after_check24:                                    ; preds = %voiderr21
-  %16 = load i32, ptr %c, align 4
+  %12 = load i32, ptr %c, align 4
-  call void (ptr, ...) @printf(ptr @.str.2, i32 %16)
+  call void (ptr, ...) @printf(ptr @.str.2, i32 %12)
-  br label %voiderr22
+  br label %voiderr25
 
-voiderr22:                                        ; preds = %after_check21, %voiderr19
+voiderr25:                                        ; preds = %after_check24, %voiderr21
-  %17 = load i64, ptr %c.f, align 8
+  %13 = load i64, ptr %c.f, align 8
-  %neq = icmp ne i64 %17, 0
+  %neq = icmp ne i64 %13, 0
-  br i1 %neq, label %if.then23, label %if.exit24
+  br i1 %neq, label %if.then26, label %if.exit27
 
-if.then23:                                        ; preds = %voiderr22
+if.then26:                                        ; preds = %voiderr25
   call void (ptr, ...) @printf(ptr @.str.3)
-  br label %if.exit24
+  br label %if.exit27
 
-if.exit24:                                        ; preds = %if.then23, %voiderr22
+if.exit27:                                        ; preds = %if.then26, %voiderr25
   store i32 3, ptr %c, align 4
   store i64 0, ptr %c.f, align 8
-  %18 = load i64, ptr %c.f, align 8
+  %optval28 = load i64, ptr %c.f, align 8
-  %not_err25 = icmp eq i64 %18, 0
+  %not_err29 = icmp eq i64 %optval28, 0
-  br i1 %not_err25, label %after_check26, label %voiderr27
+  br i1 %not_err29, label %after_check30, label %voiderr31
 
-after_check26:                                    ; preds = %if.exit24
+after_check30:                                    ; preds = %if.exit27
-  %19 = load i32, ptr %c, align 4
+  %14 = load i32, ptr %c, align 4
-  call void (ptr, ...) @printf(ptr @.str.4, i32 %19)
+  call void (ptr, ...) @printf(ptr @.str.4, i32 %14)
-  br label %voiderr27
+  br label %voiderr31
 
-voiderr27:                                        ; preds = %after_check26, %if.exit24
+voiderr31:                                        ; preds = %after_check30, %if.exit27
   ret i32 0
 }

test/test_suite2/from_docs/examples_if_catch.c3t

@@ -116,12 +116,12 @@ after_assign:                                     ; preds = %after_check, %assig
   br label %testblock
 
 testblock:                                        ; preds = %after_assign
-  %4 = load i64, ptr %ratio.f, align 8
+  %optval = load i64, ptr %ratio.f, align 8
-  %not_err1 = icmp eq i64 %4, 0
+  %not_err1 = icmp eq i64 %optval, 0
   br i1 %not_err1, label %after_check3, label %assign_optional2
 
 assign_optional2:                                 ; preds = %testblock
-  store i64 %4, ptr %err, align 8
+  store i64 %optval, ptr %err, align 8
   br label %end_block
 
 after_check3:                                     ; preds = %testblock
@@ -129,32 +129,32 @@ after_check3:                                     ; preds = %testblock
   br label %end_block
 
 end_block:                                        ; preds = %after_check3, %assign_optional2
-  %5 = load i64, ptr %err, align 8
+  %4 = load i64, ptr %err, align 8
-  %neq = icmp ne i64 %5, 0
+  %neq = icmp ne i64 %4, 0
   br i1 %neq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_block
-  store i64 %5, ptr %switch, align 8
+  store i64 %4, ptr %switch, align 8
   br label %switch.entry
 
 switch.entry:                                     ; preds = %if.then
-  %6 = load i64, ptr %switch, align 8
+  %5 = load i64, ptr %switch, align 8
-  %eq = icmp eq i64 ptrtoint (ptr @"demo_MathError$DIVISION_BY_ZERO" to i64), %6
+  %eq = icmp eq i64 ptrtoint (ptr @"demo_MathError$DIVISION_BY_ZERO" to i64), %5
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
-  %7 = call i32 (ptr, ...) @printf(ptr @.str)
+  %6 = call i32 (ptr, ...) @printf(ptr @.str)
   ret void
 
 next_if:                                          ; preds = %switch.entry
   br label %switch.default
 
 switch.default:                                   ; preds = %next_if
-  %8 = call i32 (ptr, ...) @printf(ptr @.str.1)
+  %7 = call i32 (ptr, ...) @printf(ptr @.str.1)
   ret void
 
 if.exit:                                          ; preds = %end_block
-  %9 = load double, ptr %ratio, align 8
+  %8 = load double, ptr %ratio, align 8
-  %10 = call i32 (ptr, ...) @printf(ptr @.str.2, double %9)
+  %9 = call i32 (ptr, ...) @printf(ptr @.str.2, double %8)
   ret void
 }

test/test_suite2/functions/assorted_tests.c3t

@@ -58,8 +58,8 @@ entry:
   %0 = load i32, ptr %w_cnt, align 4
   %1 = load ptr, ptr %pp, align 8
   %2 = load i8, ptr %1, align 8
-  %uiuiext = zext i8 %2 to i32
+  %zext = zext i8 %2 to i32
-  %add = add i32 %0, %uiuiext
+  %add = add i32 %0, %zext
   store i32 %add, ptr %w_cnt, align 4
   %3 = load i32, ptr %w_cnt, align 4
   ret i32 %3

test/test_suite2/functions/simple_test.c3t

@@ -22,8 +22,8 @@ entry:
   %0 = load i32, ptr %w_cnt, align 4
   %1 = load ptr, ptr %pp, align 8
   %2 = load i8, ptr %1, align 8
-  %uiuiext = zext i8 %2 to i32
+  %zext = zext i8 %2 to i32
-  %add = add i32 %0, %uiuiext
+  %add = add i32 %0, %zext
   store i32 %add, ptr %w_cnt, align 4
   %3 = load i32, ptr %w_cnt, align 4
   ret i32 %3

test/test_suite2/macros/macro_with_body.c3t

@@ -68,36 +68,35 @@ entry:
   %loop = alloca i32, align 4
   call void @llvm.memcpy.p0.p0.i32(ptr align 4 %f, ptr align 4 @.__const, i32 4, i1 false)
   store i32 0, ptr %y, align 4
-  %0 = load %Foo, ptr %f, align 4
+  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %foo, ptr align 4 %f, i32 4, i1 false)
-  store %Foo %0, ptr %foo, align 4
+  %0 = getelementptr inbounds %Foo, ptr %foo, i32 0, i32 0
-  %1 = getelementptr inbounds %Foo, ptr %foo, i32 0, i32 0
+  %1 = load i32, ptr %0, align 4
-  %2 = load i32, ptr %1, align 4
+  store i32 %1, ptr %y, align 4
-  store i32 %2, ptr %y, align 4
+  %2 = call i32 @withbody_Foo_mutate(ptr %foo)
-  %3 = call i32 @withbody_Foo_mutate(ptr %foo)
+  store i32 %2, ptr %x, align 4
-  store i32 %3, ptr %x, align 4
+  %3 = load i32, ptr %y, align 4
-  %4 = load i32, ptr %y, align 4
+  store i32 %3, ptr %dy, align 4
-  store i32 %4, ptr %dy, align 4
+  %4 = load i32, ptr %x, align 4
-  %5 = load i32, ptr %x, align 4
+  %5 = load i32, ptr %dy, align 4
-  %6 = load i32, ptr %dy, align 4
+  %6 = call i32 (ptr, ...) @printf(ptr @.str, i32 %4, i32 %5)
-  %7 = call i32 (ptr, ...) @printf(ptr @.str, i32 %5, i32 %6)
   store i32 10, ptr %times, align 4
   store i32 0, ptr %i, align 4
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %8 = load i32, ptr %i, align 4
+  %7 = load i32, ptr %i, align 4
-  %9 = load i32, ptr %times, align 4
+  %8 = load i32, ptr %times, align 4
-  %lt = icmp slt i32 %8, %9
+  %lt = icmp slt i32 %7, %8
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %10 = load i32, ptr %i, align 4
+  %9 = load i32, ptr %i, align 4
-  %add = add i32 %10, 1
+  %add = add i32 %9, 1
   store i32 %add, ptr %loop, align 4
-  %11 = load i32, ptr %loop, align 4
+  %10 = load i32, ptr %loop, align 4
-  %12 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %11)
+  %11 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %10)
-  %13 = load i32, ptr %i, align 4
+  %12 = load i32, ptr %i, align 4
-  %add1 = add i32 %13, 1
+  %add1 = add i32 %12, 1
   store i32 %add1, ptr %i, align 4
   br label %loop.cond
 

test/test_suite2/macros/userland_bitcast.c3t

@@ -102,35 +102,34 @@ entry:
   store i16 0, ptr %5, align 2
   %6 = getelementptr inbounds %Foo, ptr %z, i32 0, i32 0
   store i16 %0, ptr %6, align 2
-  %7 = load %Foo, ptr %z, align 2
+  call void @llvm.memcpy.p0.p0.i32(ptr align 2 %expr, ptr align 2 %z, i32 8, i1 false)
-  store %Foo %7, ptr %expr, align 2
   store ptr %expr, ptr %b, align 8
   store ptr %x, ptr %to, align 8
   store i64 0, ptr %i, align 8
   br label %loop.cond
 
 loop.cond:                                        ; preds = %loop.body, %entry
-  %8 = load i64, ptr %i, align 8
+  %7 = load i64, ptr %i, align 8
-  %lt = icmp ult i64 %8, 8
+  %lt = icmp ult i64 %7, 8
   br i1 %lt, label %loop.body, label %loop.exit
 
 loop.body:                                        ; preds = %loop.cond
-  %9 = load ptr, ptr %to, align 8
+  %8 = load ptr, ptr %to, align 8
-  %10 = load i64, ptr %i, align 8
+  %9 = load i64, ptr %i, align 8
-  %ptroffset = getelementptr inbounds i16, ptr %9, i64 %10
+  %ptroffset = getelementptr inbounds i16, ptr %8, i64 %9
-  %11 = load ptr, ptr %b, align 8
+  %10 = load ptr, ptr %b, align 8
-  %12 = load i64, ptr %i, align 8
+  %11 = load i64, ptr %i, align 8
-  %ptroffset1 = getelementptr inbounds i16, ptr %11, i64 %12
+  %ptroffset1 = getelementptr inbounds i16, ptr %10, i64 %11
-  %13 = load i16, ptr %ptroffset1, align 2
+  %12 = load i16, ptr %ptroffset1, align 2
-  store i16 %13, ptr %ptroffset, align 2
+  store i16 %12, ptr %ptroffset, align 2
-  %14 = load i64, ptr %i, align 8
+  %13 = load i64, ptr %i, align 8
-  %add = add i64 %14, 2
+  %add = add i64 %13, 2
   store i64 %add, ptr %i, align 8
   br label %loop.cond
 
 loop.exit:                                        ; preds = %loop.cond
-  %15 = load i64, ptr %x, align 8
+  %14 = load i64, ptr %x, align 8
-  ret i64 %15
+  ret i64 %14
 }
 
 define i32 @userland_bitcast_test(float %0) #0 {

test/test_suite2/statements/comparison_widening.c3t

@@ -8,7 +8,7 @@ fn void test1()
     int d = b ?: 1;
 }
 
-// #expect: comparison_widening.ll
+/* #expect: comparison_widening.ll
 
 define void @comparison_widening_test1() #0 {
 entry:
@@ -20,9 +20,9 @@ entry:
   store i32 2, ptr %b, align 4
   %0 = load i32, ptr %b, align 4
   %1 = load i8, ptr %a, align 1
-  %uiuiext = zext i8 %1 to i32
+  %zext = zext i8 %1 to i32
-  %gt = icmp sgt i32 %0, %uiuiext
+  %gt = icmp sgt i32 %0, %zext
-  %check = icmp sge i32 %uiuiext, 0
+  %check = icmp sge i32 %zext, 0
   %siui-gt = and i1 %check, %gt
   %ternary = select i1 %siui-gt, i8 1, i8 0
   store i8 %ternary, ptr %c, align 1

test/test_suite2/statements/foreach_common.c3t

@@ -212,8 +212,8 @@ loop.cond26:                                      ; preds = %loop.body28, %loop.
 
 loop.body28:                                      ; preds = %loop.cond26
   %29 = load i64, ptr %anon25, align 8
-  %uiuitrunc = trunc i64 %29 to i8
+  %ztrunc = trunc i64 %29 to i8
-  store i8 %uiuitrunc, ptr %i29, align 1
+  store i8 %ztrunc, ptr %i29, align 1
   %30 = load i64, ptr %anon25, align 8
   %31 = getelementptr inbounds [3 x float], ptr %foo, i64 0, i64 %30
   %32 = load float, ptr %31, align 4
@@ -314,8 +314,8 @@ loop.cond62:                                      ; preds = %loop.body64, %loop.
 
 loop.body64:                                      ; preds = %loop.cond62
   %60 = load i64, ptr %anon60, align 8
-  %uiuitrunc66 = trunc i64 %60 to i8
+  %ztrunc66 = trunc i64 %60 to i8
-  store i8 %uiuitrunc66, ptr %i65, align 1
+  store i8 %ztrunc66, ptr %i65, align 1
   %61 = load <3 x float>, ptr %foo2, align 16
   %62 = load i64, ptr %anon60, align 8
   %63 = extractelement <3 x float> %61, i64 %62

test/test_suite2/statements/various_switching.c3t

@@ -86,12 +86,12 @@ entry:
   br label %testblock
 
 testblock:                                        ; preds = %entry
-  %0 = load i64, ptr %x.f, align 8
+  %optval = load i64, ptr %x.f, align 8
-  %not_err = icmp eq i64 %0, 0
+  %not_err = icmp eq i64 %optval, 0
   br i1 %not_err, label %after_check, label %assign_optional
 
 assign_optional:                                  ; preds = %testblock
-  store i64 %0, ptr %err, align 8
+  store i64 %optval, ptr %err, align 8
   br label %end_block
 
 after_check:                                      ; preds = %testblock
@@ -99,17 +99,17 @@ after_check:                                      ; preds = %testblock
   br label %end_block
 
 end_block:                                        ; preds = %after_check, %assign_optional
-  %1 = load i64, ptr %err, align 8
+  %0 = load i64, ptr %err, align 8
-  %neq = icmp ne i64 %1, 0
+  %neq = icmp ne i64 %0, 0
   br i1 %neq, label %if.then, label %if.exit
 
 if.then:                                          ; preds = %end_block
-  store i64 %1, ptr %switch, align 8
+  store i64 %0, ptr %switch, align 8
   br label %switch.entry
 
 switch.entry:                                     ; preds = %if.then
-  %2 = load i64, ptr %switch, align 8
+  %1 = load i64, ptr %switch, align 8
-  %eq = icmp eq i64 ptrtoint (ptr @"mymodule_HelloErr$FOO" to i64), %2
+  %eq = icmp eq i64 ptrtoint (ptr @"mymodule_HelloErr$FOO" to i64), %1
   br i1 %eq, label %switch.case, label %next_if
 
 switch.case:                                      ; preds = %switch.entry
@@ -117,7 +117,7 @@ switch.case:                                      ; preds = %switch.entry
   br label %switch.exit
 
 next_if:                                          ; preds = %switch.entry
-  %eq1 = icmp eq i64 ptrtoint (ptr @"mymodule_ByeErr$BAR" to i64), %2
+  %eq1 = icmp eq i64 ptrtoint (ptr @"mymodule_ByeErr$BAR" to i64), %1
   br i1 %eq1, label %switch.case2, label %next_if3
 
 switch.case2:                                     ; preds = %next_if
@@ -135,13 +135,13 @@ switch.exit:                                      ; preds = %switch.default, %sw
   br label %if.exit
 
 if.exit:                                          ; preds = %switch.exit, %end_block
-  %3 = load i64, ptr %z, align 8
+  %2 = load i64, ptr %z, align 8
-  store i64 %3, ptr %switch4, align 8
+  store i64 %2, ptr %switch4, align 8
   br label %switch.entry5
 
 switch.entry5:                                    ; preds = %if.exit
-  %4 = load i64, ptr %switch4, align 8
+  %3 = load i64, ptr %switch4, align 8
-  %eq6 = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4
+  %eq6 = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %3
   br i1 %eq6, label %switch.case7, label %next_if8
 
 switch.case7:                                     ; preds = %switch.entry5
@@ -149,14 +149,14 @@ switch.case7:                                     ; preds = %switch.entry5
   br label %switch.exit16
 
 next_if8:                                         ; preds = %switch.entry5
-  %eq9 = icmp eq i64 ptrtoint (ptr @"ct$bool" to i64), %4
+  %eq9 = icmp eq i64 ptrtoint (ptr @"ct$bool" to i64), %3
   br i1 %eq9, label %switch.case10, label %next_if11
 
 switch.case10:                                    ; preds = %next_if8
   br label %switch.case13
 
 next_if11:                                        ; preds = %next_if8
-  %eq12 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %4
+  %eq12 = icmp eq i64 ptrtoint (ptr @"ct$double" to i64), %3
   br i1 %eq12, label %switch.case13, label %next_if14
 
 switch.case13:                                    ; preds = %next_if11, %switch.case10
@@ -172,18 +172,18 @@ switch.default15:                                 ; preds = %next_if14, %switch.
 switch.exit16:                                    ; preds = %switch.default15, %switch.case7
   store i32 1, ptr %a, align 4
   store i32 2, ptr %b, align 4
-  %5 = load i32, ptr %b, align 4
+  %4 = load i32, ptr %b, align 4
-  %6 = load i32, ptr %a, align 4
+  %5 = load i32, ptr %a, align 4
-  %add = add i32 %5, %6
+  %add = add i32 %4, %5
   store i32 %add, ptr %zy, align 4
-  %7 = load i32, ptr %zy, align 4
+  %6 = load i32, ptr %zy, align 4
-  store i32 %7, ptr %switch17, align 4
+  store i32 %6, ptr %switch17, align 4
   br label %switch.entry18
 
 switch.entry18:                                   ; preds = %switch.exit16
-  %8 = load i32, ptr %switch17, align 4
+  %7 = load i32, ptr %switch17, align 4
-  %9 = load i32, ptr %a, align 4
+  %8 = load i32, ptr %a, align 4
-  %eq19 = icmp eq i32 %9, %8
+  %eq19 = icmp eq i32 %8, %7
   br i1 %eq19, label %switch.case20, label %next_if21
 
 switch.case20:                                    ; preds = %switch.entry18
@@ -191,8 +191,8 @@ switch.case20:                                    ; preds = %switch.entry18
   br label %switch.exit26
 
 next_if21:                                        ; preds = %switch.entry18
-  %10 = load i32, ptr %b, align 4
+  %9 = load i32, ptr %b, align 4
-  %eq22 = icmp eq i32 %10, %8
+  %eq22 = icmp eq i32 %9, %7
   br i1 %eq22, label %switch.case23, label %next_if24
 
 switch.case23:                                    ; preds = %next_if21
@@ -211,11 +211,11 @@ switch.exit26:                                    ; preds = %switch.default25, %
   br label %switch.entry28
 
 switch.entry28:                                   ; preds = %switch.exit26
-  %11 = load i8, ptr %switch27, align 1
+  %10 = load i8, ptr %switch27, align 1
-  %12 = trunc i8 %11 to i1
+  %11 = trunc i8 %10 to i1
-  %13 = load i32, ptr %a, align 4
+  %12 = load i32, ptr %a, align 4
-  %lt = icmp slt i32 %13, 0
+  %lt = icmp slt i32 %12, 0
-  %eq29 = icmp eq i1 %lt, %12
+  %eq29 = icmp eq i1 %lt, %11
   br i1 %eq29, label %switch.case30, label %next_if31
 
 switch.case30:                                    ; preds = %switch.entry28
@@ -223,9 +223,9 @@ switch.case30:                                    ; preds = %switch.entry28
   br label %switch.exit37
 
 next_if31:                                        ; preds = %switch.entry28
-  %14 = load i32, ptr %a, align 4
+  %13 = load i32, ptr %a, align 4
-  %eq32 = icmp eq i32 %14, 1
+  %eq32 = icmp eq i32 %13, 1
-  %eq33 = icmp eq i1 %eq32, %12
+  %eq33 = icmp eq i1 %eq32, %11
   br i1 %eq33, label %switch.case34, label %next_if35
 
 switch.case34:                                    ; preds = %next_if31