From 44df6eb75be299ba04f69c5efab7733a71d6d352 Mon Sep 17 00:00:00 2001 From: Christoffer Lerno Date: Fri, 12 Aug 2022 10:46:11 +0200 Subject: [PATCH] Cleanup. --- src/compiler/llvm_codegen.c | 2 +- src/compiler/llvm_codegen_debug_info.c | 31 +- src/compiler/llvm_codegen_expr.c | 226 +- src/compiler/llvm_codegen_function.c | 32 +- src/compiler/llvm_codegen_instr.c | 18 +- src/compiler/llvm_codegen_internal.h | 146 +- src/compiler/llvm_codegen_stmt.c | 33 +- src/compiler/llvm_codegen_storeload.c | 57 +- src/compiler/llvm_codegen_type.c | 2 +- src/compiler/llvm_codegen_value.c | 17 +- test/src/tester.py | 6 +- test/test_suite/arrays/array_literal.c3t | 6 +- .../bitstruct/array_with_boolean.c3t | 70 +- test/test_suite/bitstruct/bitfield_access.c3t | 94 +- .../bitstruct/bitstruct_access_signed.c3t | 96 +- .../test_suite/bitstruct/bitstruct_arrays.c3t | 1894 ++++++++--------- .../bitstruct/bitstruct_arrays_be.c3t | 180 +- .../bitstruct/bitstruct_intcontainer.c3t | 80 +- .../test_suite/bitstruct/bitstruct_to_int.c3t | 30 +- .../bitstruct/embedded_bitstruct.c3t | 36 +- test/test_suite/cast/top_down_casts.c3t | 50 +- test/test_suite/clang/2002-04.c3t | 4 +- test/test_suite/enumerations/enum_cast.c3t | 11 +- test/test_suite/errors/error_regression_2.c3t | 303 +-- .../errors/failable_chained_init.c3t | 929 ++++---- test/test_suite/errors/failable_inits.c3t | 32 +- .../errors/failable_taddr_and_access.c3t | 92 +- test/test_suite/errors/or_err_bool.c3t | 10 +- test/test_suite/errors/rethrow.c3t | 10 +- test/test_suite/errors/rethrow_mingw.c3t | 10 +- test/test_suite/errors/try_assign.c3t | 116 +- test/test_suite/errors/try_catch_if.c3t | 22 +- test/test_suite/errors/try_with_unwrapper.c3t | 46 +- .../expressions/chained_ternary.c3t | 244 +-- test/test_suite/failable_catch.c3t | 106 +- .../from_docs/examples_if_catch.c3t | 24 +- test/test_suite/functions/assorted_tests.c3t | 6 +- test/test_suite/functions/simple_test.c3t | 4 +- test/test_suite/macros/macro_with_body.c3t | 43 +- test/test_suite/macros/userland_bitcast.c3t | 33 +- .../statements/comparison_widening.c3t | 8 +- test/test_suite/statements/foreach_common.c3t | 124 +- .../statements/various_switching.c3t | 66 +- test/test_suite2/arrays/array_literal.c3t | 4 +- .../bitstruct/array_with_boolean.c3t | 70 +- .../test_suite2/bitstruct/bitfield_access.c3t | 94 +- .../bitstruct/bitstruct_access_signed.c3t | 96 +- .../bitstruct/bitstruct_arrays.c3t | 1894 ++++++++--------- .../bitstruct/bitstruct_arrays_be.c3t | 178 +- .../bitstruct/bitstruct_intcontainer.c3t | 80 +- .../bitstruct/bitstruct_to_int.c3t | 30 +- .../bitstruct/embedded_bitstruct.c3t | 32 +- test/test_suite2/cast/top_down_casts.c3t | 50 +- test/test_suite2/clang/2002-04.c3t | 4 +- test/test_suite2/enumerations/enum_cast.c3t | 10 +- .../test_suite2/errors/error_regression_2.c3t | 247 ++- .../errors/failable_chained_init.c3t | 830 ++++---- test/test_suite2/errors/failable_inits.c3t | 20 +- .../errors/failable_taddr_and_access.c3t | 92 +- test/test_suite2/errors/or_err_bool.c3t | 10 +- test/test_suite2/errors/rethrow.c3t | 10 +- test/test_suite2/errors/rethrow_mingw.c3t | 10 +- test/test_suite2/errors/try_assign.c3t | 116 +- test/test_suite2/errors/try_catch_if.c3t | 22 +- .../test_suite2/errors/try_with_unwrapper.c3t | 46 +- .../expressions/chained_ternary.c3t | 246 +-- test/test_suite2/failable_catch.c3t | 106 +- .../from_docs/examples_if_catch.c3t | 24 +- test/test_suite2/functions/assorted_tests.c3t | 4 +- test/test_suite2/functions/simple_test.c3t | 4 +- test/test_suite2/macros/macro_with_body.c3t | 41 +- test/test_suite2/macros/userland_bitcast.c3t | 31 +- .../statements/comparison_widening.c3t | 8 +- .../test_suite2/statements/foreach_common.c3t | 8 +- .../statements/various_switching.c3t | 66 +- 75 files changed, 5022 insertions(+), 4810 deletions(-) diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c index 979df16d2..eb85029ec 100644 --- a/src/compiler/llvm_codegen.c +++ b/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); diff --git a/src/compiler/llvm_codegen_debug_info.c b/src/compiler/llvm_codegen_debug_info.c index 8e70656f1..8bd2771c4 100644 --- a/src/compiler/llvm_codegen_debug_info.c +++ b/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); - if (oldloc && context->last_emitted_loc.a == location.a) return; - LLVMMetadataRef scope = llvm_debug_current_scope(context); + LLVMMetadataRef oldloc = LLVMGetCurrentDebugLocation2(c->builder); + if (oldloc && c->last_emitted_loc.a == location.a) return; + LLVMMetadataRef scope = llvm_debug_current_scope(c); unsigned row = location.row; unsigned col = location.col; - context->last_emitted_loc.a = location.a; - LLVMMetadataRef loc = LLVMDIBuilderCreateDebugLocation(context->context, + c->last_emitted_loc.a = location.a; + 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); } diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c index 9dd1c4e24..699857f8e 100644 --- a/src/compiler/llvm_codegen_expr.c +++ b/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_emit_bitcast(c, value->value, type_get_ptr(found->type)), - found->type, - value->alignment); + llvm_value_bitcast(c, value, found->type); 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_emit_bitcast(c, value->value, type_get_ptr(found->type)), - found->type, - value->alignment); + llvm_value_bitcast(c, value, found->type); 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 = LLVMBuildAShr(c->builder, res, shift, ""); + res = llvm_emit_shl(c, 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)); - value->type = to_type; + llvm_value_bitcast(c, value, 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)); - value->type = to_type; + llvm_value_bitcast(c, value, 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) - ? LLVMBuildTrunc(c->builder, value->value, llvm_get_type(c, to_type), "uiuitrunc") - : LLVMBuildZExt(c->builder, value->value, llvm_get_type(c, to_type), "uiuiext"); + value->value = llvm_zext_trunc(c, value->value, llvm_get_type(c, to_type)); 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); - mask = LLVMBuildLShr(c->builder, mask, LLVMConstInt(llvm_base_type, base_type_bitsize - bit_size, 0), ""); + LLVMValueRef mask = llvm_emit_lshr_fixed(c, LLVMConstAllOnes(llvm_base_type), base_type_bitsize - bit_size); 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_value_raw(c, - &pointer_addr, - llvm_emit_bitcast(c, value.value, type_get_ptr(type->pointer->array.base))); + llvm_store_raw(c, &len_addr, llvm_const_int(c, type_usize, type->pointer->array.len)); + llvm_store_raw(c, &pointer_addr, llvm_emit_bitcast_ptr(c, value.value, 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_value_raw(c, &pointer_addr, llvm_emit_bitcast(c, array_ref, array_as_pointer_type)); + llvm_store_raw(c, &pointer_addr, llvm_emit_bitcast_ptr(c, array_ref, pointee_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)); diff --git a/src/compiler/llvm_codegen_function.c b/src/compiler/llvm_codegen_function.c index 90a4ed694..f40841fd0 100644 --- a/src/compiler/llvm_codegen_function.c +++ b/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)); } } diff --git a/src/compiler/llvm_codegen_instr.c b/src/compiler/llvm_codegen_instr.c index 71ee806f4..15e5a4bab 100644 --- a/src/compiler/llvm_codegen_instr.c +++ b/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 LLVMBuildLShr(c->builder, data, LLVMConstInt(type, (unsigned)shift, false), ""); - } - return LLVMBuildLShr(c->builder, data, LLVMConstInt(type, (unsigned)shift, false), ""); + return llvm_emit_lshr(c, data, LLVMConstInt(type, (unsigned)shift, false)); +} + +LLVMValueRef llvm_emit_ashr_fixed(GenContext *c, LLVMValueRef data, int shift) +{ + 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)); } diff --git a/src/compiler/llvm_codegen_internal.h b/src/compiler/llvm_codegen_internal.h index 8664a8ea7..532f84644 100644 --- a/src/compiler/llvm_codegen_internal.h +++ b/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); -INLINE bool llvm_is_local_eval(GenContext *c); -void LLVMEnableOpaquePointers(LLVMContextRef ctx); +// Patched functions 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); diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c index 998a32f75..78f174b6f 100644 --- a/src/compiler/llvm_codegen_stmt.c +++ b/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)); - llvm_value_set(value, LLVMConstNull(alloc_type), type); + LLVMValueRef zero = llvm_get_zero(c, var_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) }; diff --git a/src/compiler/llvm_codegen_storeload.c b/src/compiler/llvm_codegen_storeload.c index c3f81852e..9ab863b3b 100644 --- a/src/compiler/llvm_codegen_storeload.c +++ b/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) -{ - 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) +LLVMValueRef llvm_store_to_ptr_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; + return llvm_store_raw(c, ref, llvm_get_zero(c, type)); } Type *single_type = type_abi_find_single_struct_element(type); if (single_type && !type_is_abi_aggregate(single_type)) { - BEValue element; - llvm_value_set_address(&element, - llvm_emit_bitcast(c, ref->value, type_get_ptr(single_type)), - single_type, - (unsigned)ref->alignment); - llvm_store_zero(c, &element); - return; + BEValue element = *ref; + llvm_value_bitcast(c, &element, single_type); + return llvm_store_zero(c, &element); } 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); } diff --git a/src/compiler/llvm_codegen_type.c b/src/compiler/llvm_codegen_type.c index 2e99060da..b50957b92 100644 --- a/src/compiler/llvm_codegen_type.c +++ b/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 { diff --git a/src/compiler/llvm_codegen_value.c b/src/compiler/llvm_codegen_value.c index 9068571f3..f495de47f 100644 --- a/src/compiler/llvm_codegen_value.c +++ b/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, ref, value->type); + llvm_value_set_address_abi_aligned(value, llvm_emit_bitcast_ptr(c, ref, value->type), 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; } } diff --git a/test/src/tester.py b/test/src/tester.py index c1a8f1ad1..a144e3c7e 100644 --- a/test/src/tester.py +++ b/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 diff --git a/test/test_suite/arrays/array_literal.c3t b/test/test_suite/arrays/array_literal.c3t index 1af6a5c2f..10a74df30 100644 --- a/test/test_suite/arrays/array_literal.c3t +++ b/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 - %2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %uiuiext + %zext = zext i32 %0 to i64 + %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 } diff --git a/test/test_suite/bitstruct/array_with_boolean.c3t b/test/test_suite/bitstruct/array_with_boolean.c3t index f61746601..8437695c6 100644 --- a/test/test_suite/bitstruct/array_with_boolean.c3t +++ b/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 - %3 = shl i32 %2, 29 - %4 = ashr i32 %3, 29 - %5 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %6 = load i8, i8* %5, align 1 - %7 = zext i8 %6 to i32 - %8 = lshr i32 %7, 3 - %9 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %zext = zext i8 %1 to i32 + %shl = shl i32 %zext, 29 + %ashr = ashr i32 %shl, 29 + %2 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %3 = load i8, i8* %2, align 1 + %zext1 = zext i8 %3 to i32 + %lshrl = lshr i32 %zext1, 3 + %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 - %12 = shl i32 %11, 5 - %13 = or i32 %12, %8 - %14 = shl i32 %13, 26 - %15 = ashr i32 %14, 26 - %16 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %17 = load i8, i8* %16, align 1 - %18 = zext i8 %17 to i32 - %19 = lshr i32 %18, 1 - %20 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %21 = load i8, i8* %20, align 1 - %22 = zext i8 %21 to i32 - %23 = shl i32 %22, 7 - %24 = or i32 %23, %19 - %25 = shl i32 %24, 22 - %26 = ashr i32 %25, 22 - %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) + %zext8 = zext i8 %10 to i32 + %shl9 = shl i32 %zext8, 7 + %11 = or i32 %shl9, %lshrl7 + %shl10 = shl i32 %11, 22 + %ashr11 = ashr i32 %shl10, 22 + %12 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %13 = load i8, i8* %12, align 1 + %lshrl12 = lshr i8 %13, 3 + %14 = trunc i8 %lshrl12 to i1 + %boolsi = zext i1 %14 to i32 + %15 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %16 = load i8, i8* %15, align 1 + %lshrl13 = lshr i8 %16, 4 + %17 = trunc i8 %lshrl13 to i1 + %boolsi14 = zext i1 %17 to i32 + 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) ret void } \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitfield_access.c3t b/test/test_suite/bitstruct/bitfield_access.c3t index cbdab9caf..65c190e9e 100644 --- a/test/test_suite/bitstruct/bitfield_access.c3t +++ b/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 - %3 = shl i32 %2, 29 - %4 = ashr i32 %3, 29 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %4) - %5 = getelementptr inbounds [3 x i8], [3 x i8]* %e2, i64 0, i64 0 - %6 = load i8, i8* %5, align 1 - %7 = zext i8 %6 to i32 - %8 = shl i32 %7, 29 - %9 = ashr i32 %8, 29 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %9) - %10 = getelementptr inbounds [3 x i8], [3 x i8]* %e3, i64 0, i64 0 - %11 = load i8, i8* %10, align 1 - %12 = zext i8 %11 to i32 - %13 = shl i32 %12, 29 - %14 = ashr i32 %13, 29 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %14) + %zext = zext i8 %1 to i32 + %shl = shl i32 %zext, 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 %ashr) + %2 = getelementptr inbounds [3 x i8], [3 x i8]* %e2, i64 0, i64 0 + %3 = load i8, i8* %2, align 1 + %zext1 = zext i8 %3 to i32 + %shl2 = shl i32 %zext1, 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 %ashr3) + %4 = getelementptr inbounds [3 x i8], [3 x i8]* %e3, i64 0, i64 0 + %5 = load i8, i8* %4, align 1 + %zext4 = zext i8 %5 to i32 + %shl5 = shl i32 %zext4, 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 %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 - %16 = load i8, i8* %15, align 1 - %17 = zext i8 %16 to i32 - %18 = and i32 7, %17 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i32 %18) - %19 = getelementptr inbounds [3 x i8], [3 x i8]* %z2, i64 0, i64 0 - %20 = load i8, i8* %19, align 1 - %21 = zext i8 %20 to i32 - %22 = and i32 7, %21 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i32 0, i32 0), i32 %22) - %23 = getelementptr inbounds [3 x i8], [3 x i8]* %z3, i64 0, i64 0 - %24 = load i8, i8* %23, align 1 - %25 = zext i8 %24 to i32 - %26 = and i32 7, %25 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i32 0, i32 0), i32 %26) + %6 = getelementptr inbounds [3 x i8], [3 x i8]* %z1, i64 0, i64 0 + %7 = load i8, i8* %6, align 1 + %zext7 = zext i8 %7 to i32 + %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 %8) + %9 = getelementptr inbounds [3 x i8], [3 x i8]* %z2, i64 0, i64 0 + %10 = load i8, i8* %9, align 1 + %zext8 = zext i8 %10 to i32 + %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 %11) + %12 = getelementptr inbounds [3 x i8], [3 x i8]* %z3, i64 0, i64 0 + %13 = load i8, i8* %12, align 1 + %zext9 = zext i8 %13 to i32 + %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 %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 - %28 = load i8, i8* %27, align 1 - %29 = zext i8 %28 to i32 - %30 = lshr i32 %29, 5 - %31 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 1 - %32 = load i8, i8* %31, align 1 - %33 = zext i8 %32 to i32 - %34 = shl i32 %33, 3 - %35 = or i32 %34, %30 - %36 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 2 - %37 = load i8, i8* %36, align 1 - %38 = zext i8 %37 to i32 - %39 = shl i32 %38, 11 - %40 = or i32 %39, %35 - %41 = and i32 262143, %40 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i32 0, i32 0), i32 %41) + %15 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 0 + %16 = load i8, i8* %15, align 1 + %zext10 = zext i8 %16 to i32 + %lshrl = lshr i32 %zext10, 5 + %17 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 1 + %18 = load i8, i8* %17, align 1 + %zext11 = zext i8 %18 to i32 + %shl12 = shl i32 %zext11, 3 + %19 = or i32 %shl12, %lshrl + %20 = getelementptr inbounds [5 x i8], [5 x i8]* %xx, i64 0, i64 2 + %21 = load i8, i8* %20, align 1 + %zext13 = zext i8 %21 to i32 + %shl14 = shl i32 %zext13, 11 + %22 = or i32 %shl14, %19 + %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 %23) ret void } \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitstruct_access_signed.c3t b/test/test_suite/bitstruct/bitstruct_access_signed.c3t index ee37a01c3..d769244ab 100644 --- a/test/test_suite/bitstruct/bitstruct_access_signed.c3t +++ b/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 - %3 = lshr i32 %2, 5 - %4 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %5 = load i8, i8* %4, align 1 - %6 = zext i8 %5 to i32 - %7 = shl i32 %6, 3 - %8 = or i32 %7, %3 - %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 - %12 = shl i32 %11, 11 - %13 = or i32 %12, %8 - %14 = shl i32 %13, 14 - %15 = ashr i32 %14, 14 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %15) + %zext = zext i8 %1 to i32 + %lshrl = lshr i32 %zext, 5 + %2 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %3 = load i8, i8* %2, align 1 + %zext1 = zext i8 %3 to i32 + %shl = shl i32 %zext1, 3 + %4 = or i32 %shl, %lshrl + %5 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %6 = load i8, i8* %5, align 1 + %zext2 = zext i8 %6 to i32 + %shl3 = shl i32 %zext2, 11 + %7 = or i32 %shl3, %4 + %shl4 = shl i32 %7, 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 %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 - %17 = load i8, i8* %16, align 1 - %18 = zext i8 %17 to i32 - %19 = lshr i32 %18, 5 - %20 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %21 = load i8, i8* %20, align 1 - %22 = zext i8 %21 to i32 - %23 = shl i32 %22, 3 - %24 = or i32 %23, %19 - %25 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %26 = load i8, i8* %25, align 1 - %27 = zext i8 %26 to i32 - %28 = shl i32 %27, 11 - %29 = or i32 %28, %24 - %30 = shl i32 %29, 14 - %31 = ashr i32 %30, 14 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %31) + %8 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %9 = load i8, i8* %8, align 1 + %zext5 = zext i8 %9 to i32 + %lshrl6 = lshr i32 %zext5, 5 + %10 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %11 = load i8, i8* %10, align 1 + %zext7 = zext i8 %11 to i32 + %shl8 = shl i32 %zext7, 3 + %12 = or i32 %shl8, %lshrl6 + %13 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %14 = load i8, i8* %13, align 1 + %zext9 = zext i8 %14 to i32 + %shl10 = shl i32 %zext9, 11 + %15 = or i32 %shl10, %12 + %shl11 = shl i32 %15, 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 %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 - %33 = load i8, i8* %32, align 1 - %34 = zext i8 %33 to i32 - %35 = lshr i32 %34, 5 - %36 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 1 - %37 = load i8, i8* %36, align 1 - %38 = zext i8 %37 to i32 - %39 = shl i32 %38, 3 - %40 = or i32 %39, %35 - %41 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 2 - %42 = load i8, i8* %41, align 1 - %43 = zext i8 %42 to i32 - %44 = shl i32 %43, 11 - %45 = or i32 %44, %40 - %46 = and i32 262143, %45 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %46) + %16 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 0 + %17 = load i8, i8* %16, align 1 + %zext13 = zext i8 %17 to i32 + %lshrl14 = lshr i32 %zext13, 5 + %18 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 1 + %19 = load i8, i8* %18, align 1 + %zext15 = zext i8 %19 to i32 + %shl16 = shl i32 %zext15, 3 + %20 = or i32 %shl16, %lshrl14 + %21 = getelementptr inbounds [3 x i8], [3 x i8]* %xxu, i64 0, i64 2 + %22 = load i8, i8* %21, align 1 + %zext17 = zext i8 %22 to i32 + %shl18 = shl i32 %zext17, 11 + %23 = or i32 %shl18, %20 + %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 %24) ret void } diff --git a/test/test_suite/bitstruct/bitstruct_arrays.c3t b/test/test_suite/bitstruct/bitstruct_arrays.c3t index 822be4033..af2d9b83f 100644 --- a/test/test_suite/bitstruct/bitstruct_arrays.c3t +++ b/test/test_suite/bitstruct/bitstruct_arrays.c3t @@ -140,204 +140,204 @@ entry: %2 = or i64 %1, 3 store i64 %2, i64* %xx, align 8 %3 = load i64, i64* %xx, align 8 - %4 = shl i64 %3, 61 - %5 = ashr i64 %4, 61 - %6 = trunc i64 %5 to i32 + %shl = shl i64 %3, 61 + %ashr = ashr i64 %shl, 61 + %4 = trunc i64 %ashr to i32 + %5 = load i64, i64* %xx, align 8 + %shl1 = shl i64 %5, 55 + %ashr2 = ashr i64 %shl1, 58 + %6 = trunc i64 %ashr2 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 %4, i32 %6) %7 = load i64, i64* %xx, align 8 - %8 = shl i64 %7, 55 - %9 = ashr i64 %8, 58 - %10 = trunc i64 %9 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i32 %6, i32 %10) - %11 = load i64, i64* %xx, align 8 - %12 = shl i64 %11, 61 - %13 = ashr i64 %12, 61 - %14 = trunc i64 %13 to i32 - %sub = sub i32 %14, 1 + %shl3 = shl i64 %7, 61 + %ashr4 = ashr i64 %shl3, 61 + %8 = trunc i64 %ashr4 to i32 + %sub = sub i32 %8, 1 + %9 = load i64, i64* %xx, align 8 + %zext = zext i32 %sub to i64 + %10 = and i64 %zext, 7 + %11 = and i64 %9, -8 + %12 = or i64 %11, %10 + store i64 %12, i64* %xx, align 8 + %13 = load i64, i64* %xx, align 8 + %shl5 = shl i64 %13, 61 + %ashr6 = ashr i64 %shl5, 61 + %14 = trunc i64 %ashr6 to i32 %15 = load i64, i64* %xx, align 8 - %16 = zext i32 %sub to i64 - %17 = and i64 %16, 7 - %18 = and i64 %15, -8 - %19 = or i64 %18, %17 - store i64 %19, i64* %xx, align 8 - %20 = load i64, i64* %xx, align 8 - %21 = shl i64 %20, 61 - %22 = ashr i64 %21, 61 - %23 = trunc i64 %22 to i32 - %24 = load i64, i64* %xx, align 8 - %25 = shl i64 %24, 55 - %26 = ashr i64 %25, 58 - %27 = trunc i64 %26 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i32 0, i32 0), i32 %23, i32 %27) - %28 = load i64, i64* %xx, align 8 - %29 = shl i64 %28, 55 - %30 = ashr i64 %29, 58 - %31 = trunc i64 %30 to i32 - %mul = mul i32 %31, 2 - %32 = load i64, i64* %xx, align 8 - %33 = zext i32 %mul to i64 - %34 = shl i64 %33, 3 - %35 = and i64 %34, 504 - %36 = and i64 %32, -505 - %37 = or i64 %36, %35 - store i64 %37, i64* %xx, align 8 - %38 = load i64, i64* %xx, align 8 - %39 = shl i64 %38, 61 - %40 = ashr i64 %39, 61 - %41 = trunc i64 %40 to i32 - %42 = load i64, i64* %xx, align 8 - %43 = shl i64 %42, 55 - %44 = ashr i64 %43, 58 - %45 = trunc i64 %44 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0), i32 %41, i32 %45) - %46 = load i64, i64* %xx, align 8 - %47 = shl i64 %46, 55 - %48 = ashr i64 %47, 58 - %49 = trunc i64 %48 to i32 - %xor = xor i32 %49, 4 + %shl7 = shl i64 %15, 55 + %ashr8 = ashr i64 %shl7, 58 + %16 = trunc i64 %ashr8 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i32 0, i32 0), i32 %14, i32 %16) + %17 = load i64, i64* %xx, align 8 + %shl9 = shl i64 %17, 55 + %ashr10 = ashr i64 %shl9, 58 + %18 = trunc i64 %ashr10 to i32 + %mul = mul i32 %18, 2 + %19 = load i64, i64* %xx, align 8 + %zext11 = zext i32 %mul to i64 + %shl12 = shl i64 %zext11, 3 + %20 = and i64 %shl12, 504 + %21 = and i64 %19, -505 + %22 = or i64 %21, %20 + store i64 %22, i64* %xx, align 8 + %23 = load i64, i64* %xx, align 8 + %shl13 = shl i64 %23, 61 + %ashr14 = ashr i64 %shl13, 61 + %24 = trunc i64 %ashr14 to i32 + %25 = load i64, i64* %xx, align 8 + %shl15 = shl i64 %25, 55 + %ashr16 = ashr i64 %shl15, 58 + %26 = trunc i64 %ashr16 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0), i32 %24, i32 %26) + %27 = load i64, i64* %xx, align 8 + %shl17 = shl i64 %27, 55 + %ashr18 = ashr i64 %shl17, 58 + %28 = trunc i64 %ashr18 to i32 + %xor = xor i32 %28, 4 + %29 = load i64, i64* %xx, align 8 + %zext19 = zext i32 %xor to i64 + %shl20 = shl i64 %zext19, 3 + %30 = and i64 %shl20, 504 + %31 = and i64 %29, -505 + %32 = or i64 %31, %30 + store i64 %32, i64* %xx, align 8 + %33 = load i64, i64* %xx, align 8 + %shl21 = shl i64 %33, 61 + %ashr22 = ashr i64 %shl21, 61 + %34 = trunc i64 %ashr22 to i32 + %35 = load i64, i64* %xx, align 8 + %shl23 = shl i64 %35, 55 + %ashr24 = ashr i64 %shl23, 58 + %36 = trunc i64 %ashr24 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i32 %34, i32 %36) + %37 = load i64, i64* %xx, align 8 + %shl25 = shl i64 %37, 55 + %ashr26 = ashr i64 %shl25, 58 + %38 = trunc i64 %ashr26 to i32 + %or = or i32 %38, 4 + %39 = load i64, i64* %xx, align 8 + %zext27 = zext i32 %or to i64 + %shl28 = shl i64 %zext27, 3 + %40 = and i64 %shl28, 504 + %41 = and i64 %39, -505 + %42 = or i64 %41, %40 + store i64 %42, i64* %xx, align 8 + %43 = load i64, i64* %xx, align 8 + %shl29 = shl i64 %43, 61 + %ashr30 = ashr i64 %shl29, 61 + %44 = trunc i64 %ashr30 to i32 + %45 = load i64, i64* %xx, align 8 + %shl31 = shl i64 %45, 55 + %ashr32 = ashr i64 %shl31, 58 + %46 = trunc i64 %ashr32 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i32 0, i32 0), i32 %44, i32 %46) + %47 = load i64, i64* %xx, align 8 + %shl33 = shl i64 %47, 55 + %ashr34 = ashr i64 %shl33, 58 + %48 = trunc i64 %ashr34 to i32 + %shl35 = shl i32 %48, 1 + %49 = freeze i32 %shl35 %50 = load i64, i64* %xx, align 8 - %51 = zext i32 %xor to i64 - %52 = shl i64 %51, 3 - %53 = and i64 %52, 504 - %54 = and i64 %50, -505 - %55 = or i64 %54, %53 - store i64 %55, i64* %xx, align 8 + %zext36 = zext i32 %49 to i64 + %shl37 = shl i64 %zext36, 3 + %51 = and i64 %shl37, 504 + %52 = and i64 %50, -505 + %53 = or i64 %52, %51 + store i64 %53, i64* %xx, align 8 + %54 = load i64, i64* %xx, align 8 + %shl38 = shl i64 %54, 61 + %ashr39 = ashr i64 %shl38, 61 + %55 = trunc i64 %ashr39 to i32 %56 = load i64, i64* %xx, align 8 - %57 = shl i64 %56, 61 - %58 = ashr i64 %57, 61 - %59 = trunc i64 %58 to i32 - %60 = load i64, i64* %xx, align 8 - %61 = shl i64 %60, 55 - %62 = ashr i64 %61, 58 - %63 = trunc i64 %62 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i32 0, i32 0), i32 %59, i32 %63) - %64 = load i64, i64* %xx, align 8 - %65 = shl i64 %64, 55 - %66 = ashr i64 %65, 58 - %67 = trunc i64 %66 to i32 - %or = or i32 %67, 4 - %68 = load i64, i64* %xx, align 8 - %69 = zext i32 %or to i64 - %70 = shl i64 %69, 3 - %71 = and i64 %70, 504 - %72 = and i64 %68, -505 - %73 = or i64 %72, %71 - store i64 %73, i64* %xx, align 8 - %74 = load i64, i64* %xx, align 8 - %75 = shl i64 %74, 61 - %76 = ashr i64 %75, 61 - %77 = trunc i64 %76 to i32 - %78 = load i64, i64* %xx, align 8 - %79 = shl i64 %78, 55 - %80 = ashr i64 %79, 58 - %81 = trunc i64 %80 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i32 0, i32 0), i32 %77, i32 %81) - %82 = load i64, i64* %xx, align 8 - %83 = shl i64 %82, 55 - %84 = ashr i64 %83, 58 - %85 = trunc i64 %84 to i32 - %shl = shl i32 %85, 1 - %86 = freeze i32 %shl + %shl40 = shl i64 %56, 55 + %ashr41 = ashr i64 %shl40, 58 + %57 = trunc i64 %ashr41 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i32 0, i32 0), i32 %55, i32 %57) + %58 = load i64, i64* %xx, align 8 + %shl42 = shl i64 %58, 55 + %ashr43 = ashr i64 %shl42, 58 + %59 = trunc i64 %ashr43 to i32 + %ashr44 = ashr i32 %59, 1 + %60 = freeze i32 %ashr44 + %61 = load i64, i64* %xx, align 8 + %zext45 = zext i32 %60 to i64 + %shl46 = shl i64 %zext45, 3 + %62 = and i64 %shl46, 504 + %63 = and i64 %61, -505 + %64 = or i64 %63, %62 + store i64 %64, i64* %xx, align 8 + %65 = load i64, i64* %xx, align 8 + %shl47 = shl i64 %65, 61 + %ashr48 = ashr i64 %shl47, 61 + %66 = trunc i64 %ashr48 to i32 + %67 = load i64, i64* %xx, align 8 + %shl49 = shl i64 %67, 55 + %ashr50 = ashr i64 %shl49, 58 + %68 = trunc i64 %ashr50 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i32 0, i32 0), i32 %66, i32 %68) + %69 = load i64, i64* %xx, align 8 + %shl51 = shl i64 %69, 55 + %ashr52 = ashr i64 %shl51, 58 + %70 = trunc i64 %ashr52 to i32 + %sdiv = sdiv i32 %70, 2 + %71 = load i64, i64* %xx, align 8 + %zext53 = zext i32 %sdiv to i64 + %shl54 = shl i64 %zext53, 3 + %72 = and i64 %shl54, 504 + %73 = and i64 %71, -505 + %74 = or i64 %73, %72 + store i64 %74, i64* %xx, align 8 + %75 = load i64, i64* %xx, align 8 + %shl55 = shl i64 %75, 61 + %ashr56 = ashr i64 %shl55, 61 + %76 = trunc i64 %ashr56 to i32 + %77 = load i64, i64* %xx, align 8 + %shl57 = shl i64 %77, 55 + %ashr58 = ashr i64 %shl57, 58 + %78 = trunc i64 %ashr58 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i32 0, i32 0), i32 %76, i32 %78) + %79 = load i64, i64* %xx, align 8 + %shl59 = shl i64 %79, 55 + %ashr60 = ashr i64 %shl59, 58 + %80 = trunc i64 %ashr60 to i32 + %smod = srem i32 %80, 2 + %81 = load i64, i64* %xx, align 8 + %zext61 = zext i32 %smod to i64 + %shl62 = shl i64 %zext61, 3 + %82 = and i64 %shl62, 504 + %83 = and i64 %81, -505 + %84 = or i64 %83, %82 + store i64 %84, i64* %xx, align 8 + %85 = load i64, i64* %xx, align 8 + %shl63 = shl i64 %85, 61 + %ashr64 = ashr i64 %shl63, 61 + %86 = trunc i64 %ashr64 to i32 %87 = load i64, i64* %xx, align 8 - %88 = zext i32 %86 to i64 - %89 = shl i64 %88, 3 - %90 = and i64 %89, 504 - %91 = and i64 %87, -505 - %92 = or i64 %91, %90 - store i64 %92, i64* %xx, align 8 - %93 = load i64, i64* %xx, align 8 - %94 = shl i64 %93, 61 - %95 = ashr i64 %94, 61 - %96 = trunc i64 %95 to i32 - %97 = load i64, i64* %xx, align 8 - %98 = shl i64 %97, 55 - %99 = ashr i64 %98, 58 - %100 = trunc i64 %99 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.5, i32 0, i32 0), i32 %96, i32 %100) - %101 = load i64, i64* %xx, align 8 - %102 = shl i64 %101, 55 - %103 = ashr i64 %102, 58 - %104 = trunc i64 %103 to i32 - %ashr = ashr i32 %104, 1 - %105 = freeze i32 %ashr - %106 = load i64, i64* %xx, align 8 - %107 = zext i32 %105 to i64 - %108 = shl i64 %107, 3 - %109 = and i64 %108, 504 - %110 = and i64 %106, -505 - %111 = or i64 %110, %109 - store i64 %111, i64* %xx, align 8 - %112 = load i64, i64* %xx, align 8 - %113 = shl i64 %112, 61 - %114 = ashr i64 %113, 61 - %115 = trunc i64 %114 to i32 - %116 = load i64, i64* %xx, align 8 - %117 = shl i64 %116, 55 - %118 = ashr i64 %117, 58 - %119 = trunc i64 %118 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i32 0, i32 0), i32 %115, i32 %119) - %120 = load i64, i64* %xx, align 8 - %121 = shl i64 %120, 55 - %122 = ashr i64 %121, 58 - %123 = trunc i64 %122 to i32 - %sdiv = sdiv i32 %123, 2 - %124 = load i64, i64* %xx, align 8 - %125 = zext i32 %sdiv to i64 - %126 = shl i64 %125, 3 - %127 = and i64 %126, 504 - %128 = and i64 %124, -505 - %129 = or i64 %128, %127 - store i64 %129, i64* %xx, align 8 - %130 = load i64, i64* %xx, align 8 - %131 = shl i64 %130, 61 - %132 = ashr i64 %131, 61 - %133 = trunc i64 %132 to i32 - %134 = load i64, i64* %xx, align 8 - %135 = shl i64 %134, 55 - %136 = ashr i64 %135, 58 - %137 = trunc i64 %136 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i32 0, i32 0), i32 %133, i32 %137) - %138 = load i64, i64* %xx, align 8 - %139 = shl i64 %138, 55 - %140 = ashr i64 %139, 58 - %141 = trunc i64 %140 to i32 - %smod = srem i32 %141, 2 - %142 = load i64, i64* %xx, align 8 - %143 = zext i32 %smod to i64 - %144 = shl i64 %143, 3 - %145 = and i64 %144, 504 - %146 = and i64 %142, -505 - %147 = or i64 %146, %145 - store i64 %147, i64* %xx, align 8 - %148 = load i64, i64* %xx, align 8 - %149 = shl i64 %148, 61 - %150 = ashr i64 %149, 61 - %151 = trunc i64 %150 to i32 - %152 = load i64, i64* %xx, align 8 - %153 = shl i64 %152, 55 - %154 = ashr i64 %153, 58 - %155 = trunc i64 %154 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i32 0, i32 0), i32 %151, i32 %155) - %156 = load i64, i64* %xx, align 8 - %157 = and i64 %156, -1048577 - %158 = or i64 %157, 1048576 - store i64 %158, i64* %xx, align 8 - %159 = load i64, i64* %xx, align 8 - %160 = lshr i64 %159, 20 - %161 = and i64 1, %160 - %162 = trunc i64 %161 to i8 - %163 = trunc i8 %162 to i1 - %boolsi = zext i1 %163 to i32 + %shl65 = shl i64 %87, 55 + %ashr66 = ashr i64 %shl65, 58 + %88 = trunc i64 %ashr66 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.8, i32 0, i32 0), i32 %86, i32 %88) + %89 = load i64, i64* %xx, align 8 + %90 = and i64 %89, -1048577 + %91 = or i64 %90, 1048576 + store i64 %91, i64* %xx, align 8 + %92 = load i64, i64* %xx, align 8 + %lshrl = lshr i64 %92, 20 + %93 = and i64 1, %lshrl + %ztrunc = trunc i64 %93 to i8 + %94 = trunc i8 %ztrunc to i1 + %boolsi = zext i1 %94 to i32 call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i32 0, i32 0), i32 %boolsi) - %164 = load i64, i64* %xx, align 8 - %165 = and i64 %164, -1048577 - store i64 %165, i64* %xx, align 8 - %166 = load i64, i64* %xx, align 8 - %167 = lshr i64 %166, 20 - %168 = and i64 1, %167 - %169 = trunc i64 %168 to i8 - %170 = trunc i8 %169 to i1 - %boolsi1 = zext i1 %170 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i32 0, i32 0), i32 %boolsi1) + %95 = load i64, i64* %xx, align 8 + %96 = and i64 %95, -1048577 + store i64 %96, i64* %xx, align 8 + %97 = load i64, i64* %xx, align 8 + %lshrl67 = lshr i64 %97, 20 + %98 = and i64 1, %lshrl67 + %ztrunc68 = trunc i64 %98 to i8 + %99 = trunc i8 %ztrunc68 to i1 + %boolsi69 = zext i1 %99 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i32 0, i32 0), i32 %boolsi69) ret void } @@ -353,388 +353,388 @@ entry: store i8 %3, i8* %0, align 1 %4 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 %5 = load i8, i8* %4, align 1 - %6 = zext i8 %5 to i32 - %7 = shl i32 %6, 29 - %8 = ashr i32 %7, 29 - %9 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %10 = load i8, i8* %9, align 1 - %11 = zext i8 %10 to i32 - %12 = lshr i32 %11, 3 - %13 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %14 = load i8, i8* %13, align 1 - %15 = zext i8 %14 to i32 - %16 = shl i32 %15, 5 - %17 = or i32 %16, %12 - %18 = shl i32 %17, 26 - %19 = ashr i32 %18, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.11, i32 0, i32 0), i32 %8, i32 %19) + %zext = zext i8 %5 to i32 + %shl = shl i32 %zext, 29 + %ashr = ashr i32 %shl, 29 + %6 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %7 = load i8, i8* %6, align 1 + %zext1 = zext i8 %7 to i32 + %lshrl = lshr i32 %zext1, 3 + %8 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %9 = load i8, i8* %8, align 1 + %zext2 = zext i8 %9 to i32 + %shl3 = shl i32 %zext2, 5 + %10 = or i32 %shl3, %lshrl + %shl4 = shl i32 %10, 26 + %ashr5 = ashr i32 %shl4, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.11, i32 0, i32 0), i32 %ashr, i32 %ashr5) + %11 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %12 = load i8, i8* %11, align 1 + %zext6 = zext i8 %12 to i32 + %shl7 = shl i32 %zext6, 29 + %ashr8 = ashr i32 %shl7, 29 + %sub = sub i32 %ashr8, 1 + %13 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %ztrunc = trunc i32 %sub to i8 + %14 = and i8 %ztrunc, 7 + %15 = load i8, i8* %13, align 1 + %16 = and i8 %15, -8 + %17 = or i8 %16, %14 + store i8 %17, i8* %13, align 1 + %18 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %19 = load i8, i8* %18, align 1 + %zext9 = zext i8 %19 to i32 + %shl10 = shl i32 %zext9, 29 + %ashr11 = ashr i32 %shl10, 29 %20 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 %21 = load i8, i8* %20, align 1 - %22 = zext i8 %21 to i32 - %23 = shl i32 %22, 29 - %24 = ashr i32 %23, 29 - %sub = sub i32 %24, 1 + %zext12 = zext i8 %21 to i32 + %lshrl13 = lshr i32 %zext12, 3 + %22 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %23 = load i8, i8* %22, align 1 + %zext14 = zext i8 %23 to i32 + %shl15 = shl i32 %zext14, 5 + %24 = or i32 %shl15, %lshrl13 + %shl16 = shl i32 %24, 26 + %ashr17 = ashr i32 %shl16, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.12, i32 0, i32 0), i32 %ashr11, i32 %ashr17) %25 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %26 = trunc i32 %sub to i8 - %27 = and i8 %26, 7 - %28 = load i8, i8* %25, align 1 - %29 = and i8 %28, -8 - %30 = or i8 %29, %27 - store i8 %30, i8* %25, align 1 - %31 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %32 = load i8, i8* %31, align 1 - %33 = zext i8 %32 to i32 - %34 = shl i32 %33, 29 - %35 = ashr i32 %34, 29 - %36 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %37 = load i8, i8* %36, align 1 - %38 = zext i8 %37 to i32 - %39 = lshr i32 %38, 3 - %40 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %41 = load i8, i8* %40, align 1 - %42 = zext i8 %41 to i32 - %43 = shl i32 %42, 5 - %44 = or i32 %43, %39 - %45 = shl i32 %44, 26 - %46 = ashr i32 %45, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.12, i32 0, i32 0), i32 %35, i32 %46) - %47 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %48 = load i8, i8* %47, align 1 - %49 = zext i8 %48 to i32 - %50 = lshr i32 %49, 3 - %51 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %26 = load i8, i8* %25, align 1 + %zext18 = zext i8 %26 to i32 + %lshrl19 = lshr i32 %zext18, 3 + %27 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %28 = load i8, i8* %27, align 1 + %zext20 = zext i8 %28 to i32 + %shl21 = shl i32 %zext20, 5 + %29 = or i32 %shl21, %lshrl19 + %shl22 = shl i32 %29, 26 + %ashr23 = ashr i32 %shl22, 26 + %mul = mul i32 %ashr23, 2 + %30 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl24 = shl i32 %mul, 3 + %ztrunc25 = trunc i32 %shl24 to i8 + %31 = load i8, i8* %30, align 1 + %32 = and i8 %31, 7 + %33 = or i8 %32, %ztrunc25 + store i8 %33, i8* %30, align 1 + %lshrl26 = lshr i32 %mul, 5 + %34 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc27 = trunc i32 %lshrl26 to i8 + %35 = and i8 %ztrunc27, 1 + %36 = load i8, i8* %34, align 1 + %37 = and i8 %36, -2 + %38 = or i8 %37, %35 + store i8 %38, i8* %34, align 1 + %39 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %40 = load i8, i8* %39, align 1 + %zext28 = zext i8 %40 to i32 + %shl29 = shl i32 %zext28, 29 + %ashr30 = ashr i32 %shl29, 29 + %41 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %42 = load i8, i8* %41, align 1 + %zext31 = zext i8 %42 to i32 + %lshrl32 = lshr i32 %zext31, 3 + %43 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %44 = load i8, i8* %43, align 1 + %zext33 = zext i8 %44 to i32 + %shl34 = shl i32 %zext33, 5 + %45 = or i32 %shl34, %lshrl32 + %shl35 = shl i32 %45, 26 + %ashr36 = ashr i32 %shl35, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.13, i32 0, i32 0), i32 %ashr30, i32 %ashr36) + %46 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %47 = load i8, i8* %46, align 1 + %zext37 = zext i8 %47 to i32 + %lshrl38 = lshr i32 %zext37, 3 + %48 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %49 = load i8, i8* %48, align 1 + %zext39 = zext i8 %49 to i32 + %shl40 = shl i32 %zext39, 5 + %50 = or i32 %shl40, %lshrl38 + %shl41 = shl i32 %50, 26 + %ashr42 = ashr i32 %shl41, 26 + %xor = xor i32 %ashr42, 4 + %51 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl43 = shl i32 %xor, 3 + %ztrunc44 = trunc i32 %shl43 to i8 %52 = load i8, i8* %51, align 1 - %53 = zext i8 %52 to i32 - %54 = shl i32 %53, 5 - %55 = or i32 %54, %50 - %56 = shl i32 %55, 26 - %57 = ashr i32 %56, 26 - %mul = mul i32 %57, 2 - %58 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %59 = shl i32 %mul, 3 - %60 = trunc i32 %59 to i8 - %61 = load i8, i8* %58, align 1 - %62 = and i8 %61, 7 - %63 = or i8 %62, %60 - store i8 %63, i8* %58, align 1 - %64 = lshr i32 %mul, 5 - %65 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %66 = trunc i32 %64 to i8 - %67 = and i8 %66, 1 - %68 = load i8, i8* %65, align 1 - %69 = and i8 %68, -2 - %70 = or i8 %69, %67 - store i8 %70, i8* %65, align 1 - %71 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %72 = load i8, i8* %71, align 1 - %73 = zext i8 %72 to i32 - %74 = shl i32 %73, 29 - %75 = ashr i32 %74, 29 - %76 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %77 = load i8, i8* %76, align 1 - %78 = zext i8 %77 to i32 - %79 = lshr i32 %78, 3 - %80 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %81 = load i8, i8* %80, align 1 - %82 = zext i8 %81 to i32 - %83 = shl i32 %82, 5 - %84 = or i32 %83, %79 - %85 = shl i32 %84, 26 - %86 = ashr i32 %85, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.13, i32 0, i32 0), i32 %75, i32 %86) - %87 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %88 = load i8, i8* %87, align 1 - %89 = zext i8 %88 to i32 - %90 = lshr i32 %89, 3 - %91 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %92 = load i8, i8* %91, align 1 - %93 = zext i8 %92 to i32 - %94 = shl i32 %93, 5 - %95 = or i32 %94, %90 - %96 = shl i32 %95, 26 - %97 = ashr i32 %96, 26 - %xor = xor i32 %97, 4 - %98 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %99 = shl i32 %xor, 3 - %100 = trunc i32 %99 to i8 - %101 = load i8, i8* %98, align 1 - %102 = and i8 %101, 7 - %103 = or i8 %102, %100 - store i8 %103, i8* %98, align 1 - %104 = lshr i32 %xor, 5 - %105 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %106 = trunc i32 %104 to i8 - %107 = and i8 %106, 1 - %108 = load i8, i8* %105, align 1 - %109 = and i8 %108, -2 - %110 = or i8 %109, %107 - store i8 %110, i8* %105, align 1 - %111 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %112 = load i8, i8* %111, align 1 - %113 = zext i8 %112 to i32 - %114 = shl i32 %113, 29 - %115 = ashr i32 %114, 29 + %53 = and i8 %52, 7 + %54 = or i8 %53, %ztrunc44 + store i8 %54, i8* %51, align 1 + %lshrl45 = lshr i32 %xor, 5 + %55 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc46 = trunc i32 %lshrl45 to i8 + %56 = and i8 %ztrunc46, 1 + %57 = load i8, i8* %55, align 1 + %58 = and i8 %57, -2 + %59 = or i8 %58, %56 + store i8 %59, i8* %55, align 1 + %60 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %61 = load i8, i8* %60, align 1 + %zext47 = zext i8 %61 to i32 + %shl48 = shl i32 %zext47, 29 + %ashr49 = ashr i32 %shl48, 29 + %62 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %63 = load i8, i8* %62, align 1 + %zext50 = zext i8 %63 to i32 + %lshrl51 = lshr i32 %zext50, 3 + %64 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %65 = load i8, i8* %64, align 1 + %zext52 = zext i8 %65 to i32 + %shl53 = shl i32 %zext52, 5 + %66 = or i32 %shl53, %lshrl51 + %shl54 = shl i32 %66, 26 + %ashr55 = ashr i32 %shl54, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.14, i32 0, i32 0), i32 %ashr49, i32 %ashr55) + %67 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %68 = load i8, i8* %67, align 1 + %zext56 = zext i8 %68 to i32 + %lshrl57 = lshr i32 %zext56, 3 + %69 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %70 = load i8, i8* %69, align 1 + %zext58 = zext i8 %70 to i32 + %shl59 = shl i32 %zext58, 5 + %71 = or i32 %shl59, %lshrl57 + %shl60 = shl i32 %71, 26 + %ashr61 = ashr i32 %shl60, 26 + %or = or i32 %ashr61, 4 + %72 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl62 = shl i32 %or, 3 + %ztrunc63 = trunc i32 %shl62 to i8 + %73 = load i8, i8* %72, align 1 + %74 = and i8 %73, 7 + %75 = or i8 %74, %ztrunc63 + store i8 %75, i8* %72, align 1 + %lshrl64 = lshr i32 %or, 5 + %76 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc65 = trunc i32 %lshrl64 to i8 + %77 = and i8 %ztrunc65, 1 + %78 = load i8, i8* %76, align 1 + %79 = and i8 %78, -2 + %80 = or i8 %79, %77 + store i8 %80, i8* %76, align 1 + %81 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %82 = load i8, i8* %81, align 1 + %zext66 = zext i8 %82 to i32 + %shl67 = shl i32 %zext66, 29 + %ashr68 = ashr i32 %shl67, 29 + %83 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %84 = load i8, i8* %83, align 1 + %zext69 = zext i8 %84 to i32 + %lshrl70 = lshr i32 %zext69, 3 + %85 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %86 = load i8, i8* %85, align 1 + %zext71 = zext i8 %86 to i32 + %shl72 = shl i32 %zext71, 5 + %87 = or i32 %shl72, %lshrl70 + %shl73 = shl i32 %87, 26 + %ashr74 = ashr i32 %shl73, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.15, i32 0, i32 0), i32 %ashr68, i32 %ashr74) + %88 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %89 = load i8, i8* %88, align 1 + %zext75 = zext i8 %89 to i32 + %lshrl76 = lshr i32 %zext75, 3 + %90 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %91 = load i8, i8* %90, align 1 + %zext77 = zext i8 %91 to i32 + %shl78 = shl i32 %zext77, 5 + %92 = or i32 %shl78, %lshrl76 + %shl79 = shl i32 %92, 26 + %ashr80 = ashr i32 %shl79, 26 + %shl81 = shl i32 %ashr80, 1 + %93 = freeze i32 %shl81 + %94 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl82 = shl i32 %93, 3 + %ztrunc83 = trunc i32 %shl82 to i8 + %95 = load i8, i8* %94, align 1 + %96 = and i8 %95, 7 + %97 = or i8 %96, %ztrunc83 + store i8 %97, i8* %94, align 1 + %lshrl84 = lshr i32 %93, 5 + %98 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc85 = trunc i32 %lshrl84 to i8 + %99 = and i8 %ztrunc85, 1 + %100 = load i8, i8* %98, align 1 + %101 = and i8 %100, -2 + %102 = or i8 %101, %99 + store i8 %102, i8* %98, align 1 + %103 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %104 = load i8, i8* %103, align 1 + %zext86 = zext i8 %104 to i32 + %shl87 = shl i32 %zext86, 29 + %ashr88 = ashr i32 %shl87, 29 + %105 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %106 = load i8, i8* %105, align 1 + %zext89 = zext i8 %106 to i32 + %lshrl90 = lshr i32 %zext89, 3 + %107 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %108 = load i8, i8* %107, align 1 + %zext91 = zext i8 %108 to i32 + %shl92 = shl i32 %zext91, 5 + %109 = or i32 %shl92, %lshrl90 + %shl93 = shl i32 %109, 26 + %ashr94 = ashr i32 %shl93, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.16, i32 0, i32 0), i32 %ashr88, i32 %ashr94) + %110 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %111 = load i8, i8* %110, align 1 + %zext95 = zext i8 %111 to i32 + %lshrl96 = lshr i32 %zext95, 3 + %112 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %113 = load i8, i8* %112, align 1 + %zext97 = zext i8 %113 to i32 + %shl98 = shl i32 %zext97, 5 + %114 = or i32 %shl98, %lshrl96 + %shl99 = shl i32 %114, 26 + %ashr100 = ashr i32 %shl99, 26 + %ashr101 = ashr i32 %ashr100, 1 + %115 = freeze i32 %ashr101 %116 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl102 = shl i32 %115, 3 + %ztrunc103 = trunc i32 %shl102 to i8 %117 = load i8, i8* %116, align 1 - %118 = zext i8 %117 to i32 - %119 = lshr i32 %118, 3 + %118 = and i8 %117, 7 + %119 = or i8 %118, %ztrunc103 + store i8 %119, i8* %116, align 1 + %lshrl104 = lshr i32 %115, 5 %120 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %121 = load i8, i8* %120, align 1 - %122 = zext i8 %121 to i32 - %123 = shl i32 %122, 5 - %124 = or i32 %123, %119 - %125 = shl i32 %124, 26 - %126 = ashr i32 %125, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.14, i32 0, i32 0), i32 %115, i32 %126) + %ztrunc105 = trunc i32 %lshrl104 to i8 + %121 = and i8 %ztrunc105, 1 + %122 = load i8, i8* %120, align 1 + %123 = and i8 %122, -2 + %124 = or i8 %123, %121 + store i8 %124, i8* %120, align 1 + %125 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %126 = load i8, i8* %125, align 1 + %zext106 = zext i8 %126 to i32 + %shl107 = shl i32 %zext106, 29 + %ashr108 = ashr i32 %shl107, 29 %127 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 %128 = load i8, i8* %127, align 1 - %129 = zext i8 %128 to i32 - %130 = lshr i32 %129, 3 - %131 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %132 = load i8, i8* %131, align 1 - %133 = zext i8 %132 to i32 - %134 = shl i32 %133, 5 - %135 = or i32 %134, %130 - %136 = shl i32 %135, 26 - %137 = ashr i32 %136, 26 - %or = or i32 %137, 4 - %138 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %139 = shl i32 %or, 3 - %140 = trunc i32 %139 to i8 - %141 = load i8, i8* %138, align 1 - %142 = and i8 %141, 7 - %143 = or i8 %142, %140 - store i8 %143, i8* %138, align 1 - %144 = lshr i32 %or, 5 - %145 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %146 = trunc i32 %144 to i8 - %147 = and i8 %146, 1 - %148 = load i8, i8* %145, align 1 - %149 = and i8 %148, -2 - %150 = or i8 %149, %147 - store i8 %150, i8* %145, align 1 - %151 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %152 = load i8, i8* %151, align 1 - %153 = zext i8 %152 to i32 - %154 = shl i32 %153, 29 - %155 = ashr i32 %154, 29 - %156 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %157 = load i8, i8* %156, align 1 - %158 = zext i8 %157 to i32 - %159 = lshr i32 %158, 3 - %160 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %161 = load i8, i8* %160, align 1 - %162 = zext i8 %161 to i32 - %163 = shl i32 %162, 5 - %164 = or i32 %163, %159 - %165 = shl i32 %164, 26 - %166 = ashr i32 %165, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.15, i32 0, i32 0), i32 %155, i32 %166) + %zext109 = zext i8 %128 to i32 + %lshrl110 = lshr i32 %zext109, 3 + %129 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %130 = load i8, i8* %129, align 1 + %zext111 = zext i8 %130 to i32 + %shl112 = shl i32 %zext111, 5 + %131 = or i32 %shl112, %lshrl110 + %shl113 = shl i32 %131, 26 + %ashr114 = ashr i32 %shl113, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.17, i32 0, i32 0), i32 %ashr108, i32 %ashr114) + %132 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %133 = load i8, i8* %132, align 1 + %zext115 = zext i8 %133 to i32 + %lshrl116 = lshr i32 %zext115, 3 + %134 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %135 = load i8, i8* %134, align 1 + %zext117 = zext i8 %135 to i32 + %shl118 = shl i32 %zext117, 5 + %136 = or i32 %shl118, %lshrl116 + %shl119 = shl i32 %136, 26 + %ashr120 = ashr i32 %shl119, 26 + %sdiv = sdiv i32 %ashr120, 2 + %137 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl121 = shl i32 %sdiv, 3 + %ztrunc122 = trunc i32 %shl121 to i8 + %138 = load i8, i8* %137, align 1 + %139 = and i8 %138, 7 + %140 = or i8 %139, %ztrunc122 + store i8 %140, i8* %137, align 1 + %lshrl123 = lshr i32 %sdiv, 5 + %141 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc124 = trunc i32 %lshrl123 to i8 + %142 = and i8 %ztrunc124, 1 + %143 = load i8, i8* %141, align 1 + %144 = and i8 %143, -2 + %145 = or i8 %144, %142 + store i8 %145, i8* %141, align 1 + %146 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %147 = load i8, i8* %146, align 1 + %zext125 = zext i8 %147 to i32 + %shl126 = shl i32 %zext125, 29 + %ashr127 = ashr i32 %shl126, 29 + %148 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %149 = load i8, i8* %148, align 1 + %zext128 = zext i8 %149 to i32 + %lshrl129 = lshr i32 %zext128, 3 + %150 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %151 = load i8, i8* %150, align 1 + %zext130 = zext i8 %151 to i32 + %shl131 = shl i32 %zext130, 5 + %152 = or i32 %shl131, %lshrl129 + %shl132 = shl i32 %152, 26 + %ashr133 = ashr i32 %shl132, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i32 0, i32 0), i32 %ashr127, i32 %ashr133) + %153 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %154 = load i8, i8* %153, align 1 + %zext134 = zext i8 %154 to i32 + %lshrl135 = lshr i32 %zext134, 3 + %155 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %156 = load i8, i8* %155, align 1 + %zext136 = zext i8 %156 to i32 + %shl137 = shl i32 %zext136, 5 + %157 = or i32 %shl137, %lshrl135 + %shl138 = shl i32 %157, 26 + %ashr139 = ashr i32 %shl138, 26 + %smod = srem i32 %ashr139, 2 + %158 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl140 = shl i32 %smod, 3 + %ztrunc141 = trunc i32 %shl140 to i8 + %159 = load i8, i8* %158, align 1 + %160 = and i8 %159, 7 + %161 = or i8 %160, %ztrunc141 + store i8 %161, i8* %158, align 1 + %lshrl142 = lshr i32 %smod, 5 + %162 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc143 = trunc i32 %lshrl142 to i8 + %163 = and i8 %ztrunc143, 1 + %164 = load i8, i8* %162, align 1 + %165 = and i8 %164, -2 + %166 = or i8 %165, %163 + store i8 %166, i8* %162, align 1 %167 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 %168 = load i8, i8* %167, align 1 - %169 = zext i8 %168 to i32 - %170 = lshr i32 %169, 3 + %zext144 = zext i8 %168 to i32 + %shl145 = shl i32 %zext144, 29 + %ashr146 = ashr i32 %shl145, 29 + %169 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %170 = load i8, i8* %169, align 1 + %zext147 = zext i8 %170 to i32 + %lshrl148 = lshr i32 %zext147, 3 %171 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 %172 = load i8, i8* %171, align 1 - %173 = zext i8 %172 to i32 - %174 = shl i32 %173, 5 - %175 = or i32 %174, %170 - %176 = shl i32 %175, 26 - %177 = ashr i32 %176, 26 - %shl = shl i32 %177, 1 - %178 = freeze i32 %shl - %179 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %180 = shl i32 %178, 3 - %181 = trunc i32 %180 to i8 - %182 = load i8, i8* %179, align 1 - %183 = and i8 %182, 7 - %184 = or i8 %183, %181 - store i8 %184, i8* %179, align 1 - %185 = lshr i32 %178, 5 - %186 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %187 = trunc i32 %185 to i8 - %188 = and i8 %187, 1 - %189 = load i8, i8* %186, align 1 - %190 = and i8 %189, -2 - %191 = or i8 %190, %188 - store i8 %191, i8* %186, align 1 - %192 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %193 = load i8, i8* %192, align 1 - %194 = zext i8 %193 to i32 - %195 = shl i32 %194, 29 - %196 = ashr i32 %195, 29 - %197 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %198 = load i8, i8* %197, align 1 - %199 = zext i8 %198 to i32 - %200 = lshr i32 %199, 3 - %201 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %202 = load i8, i8* %201, align 1 - %203 = zext i8 %202 to i32 - %204 = shl i32 %203, 5 - %205 = or i32 %204, %200 - %206 = shl i32 %205, 26 - %207 = ashr i32 %206, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.16, i32 0, i32 0), i32 %196, i32 %207) - %208 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %209 = load i8, i8* %208, align 1 - %210 = zext i8 %209 to i32 - %211 = lshr i32 %210, 3 - %212 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %213 = load i8, i8* %212, align 1 - %214 = zext i8 %213 to i32 - %215 = shl i32 %214, 5 - %216 = or i32 %215, %211 - %217 = shl i32 %216, 26 - %218 = ashr i32 %217, 26 - %ashr = ashr i32 %218, 1 - %219 = freeze i32 %ashr - %220 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %221 = shl i32 %219, 3 - %222 = trunc i32 %221 to i8 - %223 = load i8, i8* %220, align 1 - %224 = and i8 %223, 7 - %225 = or i8 %224, %222 - store i8 %225, i8* %220, align 1 - %226 = lshr i32 %219, 5 - %227 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %228 = trunc i32 %226 to i8 - %229 = and i8 %228, 1 - %230 = load i8, i8* %227, align 1 - %231 = and i8 %230, -2 - %232 = or i8 %231, %229 - store i8 %232, i8* %227, align 1 - %233 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %234 = load i8, i8* %233, align 1 - %235 = zext i8 %234 to i32 - %236 = shl i32 %235, 29 - %237 = ashr i32 %236, 29 - %238 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %239 = load i8, i8* %238, align 1 - %240 = zext i8 %239 to i32 - %241 = lshr i32 %240, 3 - %242 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %243 = load i8, i8* %242, align 1 - %244 = zext i8 %243 to i32 - %245 = shl i32 %244, 5 - %246 = or i32 %245, %241 - %247 = shl i32 %246, 26 - %248 = ashr i32 %247, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.17, i32 0, i32 0), i32 %237, i32 %248) - %249 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %250 = load i8, i8* %249, align 1 - %251 = zext i8 %250 to i32 - %252 = lshr i32 %251, 3 - %253 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %254 = load i8, i8* %253, align 1 - %255 = zext i8 %254 to i32 - %256 = shl i32 %255, 5 - %257 = or i32 %256, %252 - %258 = shl i32 %257, 26 - %259 = ashr i32 %258, 26 - %sdiv = sdiv i32 %259, 2 - %260 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %261 = shl i32 %sdiv, 3 - %262 = trunc i32 %261 to i8 - %263 = load i8, i8* %260, align 1 - %264 = and i8 %263, 7 - %265 = or i8 %264, %262 - store i8 %265, i8* %260, align 1 - %266 = lshr i32 %sdiv, 5 - %267 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %268 = trunc i32 %266 to i8 - %269 = and i8 %268, 1 - %270 = load i8, i8* %267, align 1 - %271 = and i8 %270, -2 - %272 = or i8 %271, %269 - store i8 %272, i8* %267, align 1 - %273 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %274 = load i8, i8* %273, align 1 - %275 = zext i8 %274 to i32 - %276 = shl i32 %275, 29 - %277 = ashr i32 %276, 29 - %278 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %279 = load i8, i8* %278, align 1 - %280 = zext i8 %279 to i32 - %281 = lshr i32 %280, 3 - %282 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %283 = load i8, i8* %282, align 1 - %284 = zext i8 %283 to i32 - %285 = shl i32 %284, 5 - %286 = or i32 %285, %281 - %287 = shl i32 %286, 26 - %288 = ashr i32 %287, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i32 0, i32 0), i32 %277, i32 %288) - %289 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %290 = load i8, i8* %289, align 1 - %291 = zext i8 %290 to i32 - %292 = lshr i32 %291, 3 - %293 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %294 = load i8, i8* %293, align 1 - %295 = zext i8 %294 to i32 - %296 = shl i32 %295, 5 - %297 = or i32 %296, %292 - %298 = shl i32 %297, 26 - %299 = ashr i32 %298, 26 - %smod = srem i32 %299, 2 - %300 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %301 = shl i32 %smod, 3 - %302 = trunc i32 %301 to i8 - %303 = load i8, i8* %300, align 1 - %304 = and i8 %303, 7 - %305 = or i8 %304, %302 - store i8 %305, i8* %300, align 1 - %306 = lshr i32 %smod, 5 - %307 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %308 = trunc i32 %306 to i8 - %309 = and i8 %308, 1 - %310 = load i8, i8* %307, align 1 - %311 = and i8 %310, -2 - %312 = or i8 %311, %309 - store i8 %312, i8* %307, align 1 - %313 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %314 = load i8, i8* %313, align 1 - %315 = zext i8 %314 to i32 - %316 = shl i32 %315, 29 - %317 = ashr i32 %316, 29 - %318 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %319 = load i8, i8* %318, align 1 - %320 = zext i8 %319 to i32 - %321 = lshr i32 %320, 3 - %322 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %323 = load i8, i8* %322, align 1 - %324 = zext i8 %323 to i32 - %325 = shl i32 %324, 5 - %326 = or i32 %325, %321 - %327 = shl i32 %326, 26 - %328 = ashr i32 %327, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i32 0, i32 0), i32 %317, i32 %328) - %329 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %330 = load i8, i8* %329, align 1 - %331 = lshr i8 %330, 4 - %332 = trunc i8 %331 to i1 - %boolsi = zext i1 %332 to i32 + %zext149 = zext i8 %172 to i32 + %shl150 = shl i32 %zext149, 5 + %173 = or i32 %shl150, %lshrl148 + %shl151 = shl i32 %173, 26 + %ashr152 = ashr i32 %shl151, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i32 0, i32 0), i32 %ashr146, i32 %ashr152) + %174 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %175 = load i8, i8* %174, align 1 + %lshrl153 = lshr i8 %175, 4 + %176 = trunc i8 %lshrl153 to i1 + %boolsi = zext i1 %176 to i32 call void (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i32 0, i32 0), i32 %boolsi) - %333 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %334 = load i8, i8* %333, align 1 - %335 = and i8 %334, -17 - %336 = or i8 %335, 16 - store i8 %336, i8* %333, align 1 - %337 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %338 = load i8, i8* %337, align 1 - %339 = lshr i8 %338, 4 - %340 = trunc i8 %339 to i1 - %boolsi1 = zext i1 %340 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i32 0, i32 0), i32 %boolsi1) - %341 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %342 = load i8, i8* %341, align 1 - %343 = and i8 %342, -17 - store i8 %343, i8* %341, align 1 - %344 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %345 = load i8, i8* %344, align 1 - %346 = lshr i8 %345, 4 - %347 = trunc i8 %346 to i1 - %boolsi2 = zext i1 %347 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.22, i32 0, i32 0), i32 %boolsi2) + %177 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %178 = load i8, i8* %177, align 1 + %179 = and i8 %178, -17 + %180 = or i8 %179, 16 + store i8 %180, i8* %177, align 1 + %181 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %182 = load i8, i8* %181, align 1 + %lshrl154 = lshr i8 %182, 4 + %183 = trunc i8 %lshrl154 to i1 + %boolsi155 = zext i1 %183 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i32 0, i32 0), i32 %boolsi155) + %184 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %185 = load i8, i8* %184, align 1 + %186 = and i8 %185, -17 + store i8 %186, i8* %184, align 1 + %187 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %188 = load i8, i8* %187, align 1 + %lshrl156 = lshr i8 %188, 4 + %189 = trunc i8 %lshrl156 to i1 + %boolsi157 = zext i1 %189 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.22, i32 0, i32 0), i32 %boolsi157) ret void } @@ -750,399 +750,399 @@ entry: store i8 %3, i8* %0, align 1 %4 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 %5 = load i8, i8* %4, align 1 - %6 = zext i8 %5 to i32 - %7 = lshr i32 %6, 1 - %8 = shl i32 %7, 29 - %9 = ashr i32 %8, 29 - %10 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %11 = load i8, i8* %10, align 1 - %12 = zext i8 %11 to i32 - %13 = lshr i32 %12, 4 - %14 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %15 = load i8, i8* %14, align 1 - %16 = zext i8 %15 to i32 - %17 = shl i32 %16, 4 - %18 = or i32 %17, %13 - %19 = shl i32 %18, 26 - %20 = ashr i32 %19, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.23, i32 0, i32 0), i32 %9, i32 %20) - %21 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %22 = load i8, i8* %21, align 1 - %23 = zext i8 %22 to i32 - %24 = lshr i32 %23, 1 - %25 = shl i32 %24, 29 - %26 = ashr i32 %25, 29 - %sub = sub i32 %26, 1 - %27 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %28 = shl i32 %sub, 1 - %29 = trunc i32 %28 to i8 - %30 = and i8 %29, 15 - %31 = load i8, i8* %27, align 1 - %32 = and i8 %31, -15 - %33 = or i8 %32, %30 - store i8 %33, i8* %27, align 1 - %34 = lshr i32 %sub, 7 - %35 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %36 = load i8, i8* %35, align 1 - %37 = zext i8 %36 to i32 - %38 = lshr i32 %37, 1 - %39 = shl i32 %38, 29 - %40 = ashr i32 %39, 29 + %zext = zext i8 %5 to i32 + %lshrl = lshr i32 %zext, 1 + %shl = shl i32 %lshrl, 29 + %ashr = ashr i32 %shl, 29 + %6 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %7 = load i8, i8* %6, align 1 + %zext1 = zext i8 %7 to i32 + %lshrl2 = lshr i32 %zext1, 4 + %8 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %9 = load i8, i8* %8, align 1 + %zext3 = zext i8 %9 to i32 + %shl4 = shl i32 %zext3, 4 + %10 = or i32 %shl4, %lshrl2 + %shl5 = shl i32 %10, 26 + %ashr6 = ashr i32 %shl5, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.23, i32 0, i32 0), i32 %ashr, i32 %ashr6) + %11 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %12 = load i8, i8* %11, align 1 + %zext7 = zext i8 %12 to i32 + %lshrl8 = lshr i32 %zext7, 1 + %shl9 = shl i32 %lshrl8, 29 + %ashr10 = ashr i32 %shl9, 29 + %sub = sub i32 %ashr10, 1 + %13 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl11 = shl i32 %sub, 1 + %ztrunc = trunc i32 %shl11 to i8 + %14 = and i8 %ztrunc, 15 + %15 = load i8, i8* %13, align 1 + %16 = and i8 %15, -15 + %17 = or i8 %16, %14 + store i8 %17, i8* %13, align 1 + %lshrl12 = lshr i32 %sub, 7 + %18 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %19 = load i8, i8* %18, align 1 + %zext13 = zext i8 %19 to i32 + %lshrl14 = lshr i32 %zext13, 1 + %shl15 = shl i32 %lshrl14, 29 + %ashr16 = ashr i32 %shl15, 29 + %20 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %21 = load i8, i8* %20, align 1 + %zext17 = zext i8 %21 to i32 + %lshrl18 = lshr i32 %zext17, 4 + %22 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %23 = load i8, i8* %22, align 1 + %zext19 = zext i8 %23 to i32 + %shl20 = shl i32 %zext19, 4 + %24 = or i32 %shl20, %lshrl18 + %shl21 = shl i32 %24, 26 + %ashr22 = ashr i32 %shl21, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.24, i32 0, i32 0), i32 %ashr16, i32 %ashr22) + %25 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %26 = load i8, i8* %25, align 1 + %zext23 = zext i8 %26 to i32 + %lshrl24 = lshr i32 %zext23, 4 + %27 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %28 = load i8, i8* %27, align 1 + %zext25 = zext i8 %28 to i32 + %shl26 = shl i32 %zext25, 4 + %29 = or i32 %shl26, %lshrl24 + %shl27 = shl i32 %29, 26 + %ashr28 = ashr i32 %shl27, 26 + %mul = mul i32 %ashr28, 2 + %30 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl29 = shl i32 %mul, 4 + %ztrunc30 = trunc i32 %shl29 to i8 + %31 = load i8, i8* %30, align 1 + %32 = and i8 %31, 15 + %33 = or i8 %32, %ztrunc30 + store i8 %33, i8* %30, align 1 + %lshrl31 = lshr i32 %mul, 4 + %34 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc32 = trunc i32 %lshrl31 to i8 + %35 = and i8 %ztrunc32, 3 + %36 = load i8, i8* %34, align 1 + %37 = and i8 %36, -4 + %38 = or i8 %37, %35 + store i8 %38, i8* %34, align 1 + %39 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %40 = load i8, i8* %39, align 1 + %zext33 = zext i8 %40 to i32 + %lshrl34 = lshr i32 %zext33, 1 + %shl35 = shl i32 %lshrl34, 29 + %ashr36 = ashr i32 %shl35, 29 %41 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 %42 = load i8, i8* %41, align 1 - %43 = zext i8 %42 to i32 - %44 = lshr i32 %43, 4 - %45 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %46 = load i8, i8* %45, align 1 - %47 = zext i8 %46 to i32 - %48 = shl i32 %47, 4 - %49 = or i32 %48, %44 - %50 = shl i32 %49, 26 - %51 = ashr i32 %50, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.24, i32 0, i32 0), i32 %40, i32 %51) - %52 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %53 = load i8, i8* %52, align 1 - %54 = zext i8 %53 to i32 - %55 = lshr i32 %54, 4 - %56 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %57 = load i8, i8* %56, align 1 - %58 = zext i8 %57 to i32 - %59 = shl i32 %58, 4 - %60 = or i32 %59, %55 - %61 = shl i32 %60, 26 - %62 = ashr i32 %61, 26 - %mul = mul i32 %62, 2 - %63 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %64 = shl i32 %mul, 4 - %65 = trunc i32 %64 to i8 - %66 = load i8, i8* %63, align 1 - %67 = and i8 %66, 15 - %68 = or i8 %67, %65 - store i8 %68, i8* %63, align 1 - %69 = lshr i32 %mul, 4 - %70 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %71 = trunc i32 %69 to i8 - %72 = and i8 %71, 3 - %73 = load i8, i8* %70, align 1 - %74 = and i8 %73, -4 - %75 = or i8 %74, %72 - store i8 %75, i8* %70, align 1 - %76 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %77 = load i8, i8* %76, align 1 - %78 = zext i8 %77 to i32 - %79 = lshr i32 %78, 1 - %80 = shl i32 %79, 29 - %81 = ashr i32 %80, 29 - %82 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %83 = load i8, i8* %82, align 1 - %84 = zext i8 %83 to i32 - %85 = lshr i32 %84, 4 - %86 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %87 = load i8, i8* %86, align 1 - %88 = zext i8 %87 to i32 - %89 = shl i32 %88, 4 - %90 = or i32 %89, %85 - %91 = shl i32 %90, 26 - %92 = ashr i32 %91, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.25, i32 0, i32 0), i32 %81, i32 %92) - %93 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %94 = load i8, i8* %93, align 1 - %95 = zext i8 %94 to i32 - %96 = lshr i32 %95, 4 - %97 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %98 = load i8, i8* %97, align 1 - %99 = zext i8 %98 to i32 - %100 = shl i32 %99, 4 - %101 = or i32 %100, %96 - %102 = shl i32 %101, 26 - %103 = ashr i32 %102, 26 - %xor = xor i32 %103, 4 - %104 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %105 = shl i32 %xor, 4 - %106 = trunc i32 %105 to i8 - %107 = load i8, i8* %104, align 1 - %108 = and i8 %107, 15 - %109 = or i8 %108, %106 - store i8 %109, i8* %104, align 1 - %110 = lshr i32 %xor, 4 - %111 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %112 = trunc i32 %110 to i8 - %113 = and i8 %112, 3 - %114 = load i8, i8* %111, align 1 - %115 = and i8 %114, -4 - %116 = or i8 %115, %113 - store i8 %116, i8* %111, align 1 - %117 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %118 = load i8, i8* %117, align 1 - %119 = zext i8 %118 to i32 - %120 = lshr i32 %119, 1 - %121 = shl i32 %120, 29 - %122 = ashr i32 %121, 29 - %123 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %124 = load i8, i8* %123, align 1 - %125 = zext i8 %124 to i32 - %126 = lshr i32 %125, 4 - %127 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %zext37 = zext i8 %42 to i32 + %lshrl38 = lshr i32 %zext37, 4 + %43 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %44 = load i8, i8* %43, align 1 + %zext39 = zext i8 %44 to i32 + %shl40 = shl i32 %zext39, 4 + %45 = or i32 %shl40, %lshrl38 + %shl41 = shl i32 %45, 26 + %ashr42 = ashr i32 %shl41, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.25, i32 0, i32 0), i32 %ashr36, i32 %ashr42) + %46 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %47 = load i8, i8* %46, align 1 + %zext43 = zext i8 %47 to i32 + %lshrl44 = lshr i32 %zext43, 4 + %48 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %49 = load i8, i8* %48, align 1 + %zext45 = zext i8 %49 to i32 + %shl46 = shl i32 %zext45, 4 + %50 = or i32 %shl46, %lshrl44 + %shl47 = shl i32 %50, 26 + %ashr48 = ashr i32 %shl47, 26 + %xor = xor i32 %ashr48, 4 + %51 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl49 = shl i32 %xor, 4 + %ztrunc50 = trunc i32 %shl49 to i8 + %52 = load i8, i8* %51, align 1 + %53 = and i8 %52, 15 + %54 = or i8 %53, %ztrunc50 + store i8 %54, i8* %51, align 1 + %lshrl51 = lshr i32 %xor, 4 + %55 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc52 = trunc i32 %lshrl51 to i8 + %56 = and i8 %ztrunc52, 3 + %57 = load i8, i8* %55, align 1 + %58 = and i8 %57, -4 + %59 = or i8 %58, %56 + store i8 %59, i8* %55, align 1 + %60 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %61 = load i8, i8* %60, align 1 + %zext53 = zext i8 %61 to i32 + %lshrl54 = lshr i32 %zext53, 1 + %shl55 = shl i32 %lshrl54, 29 + %ashr56 = ashr i32 %shl55, 29 + %62 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %63 = load i8, i8* %62, align 1 + %zext57 = zext i8 %63 to i32 + %lshrl58 = lshr i32 %zext57, 4 + %64 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %65 = load i8, i8* %64, align 1 + %zext59 = zext i8 %65 to i32 + %shl60 = shl i32 %zext59, 4 + %66 = or i32 %shl60, %lshrl58 + %shl61 = shl i32 %66, 26 + %ashr62 = ashr i32 %shl61, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.26, i32 0, i32 0), i32 %ashr56, i32 %ashr62) + %67 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %68 = load i8, i8* %67, align 1 + %zext63 = zext i8 %68 to i32 + %lshrl64 = lshr i32 %zext63, 4 + %69 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %70 = load i8, i8* %69, align 1 + %zext65 = zext i8 %70 to i32 + %shl66 = shl i32 %zext65, 4 + %71 = or i32 %shl66, %lshrl64 + %shl67 = shl i32 %71, 26 + %ashr68 = ashr i32 %shl67, 26 + %or = or i32 %ashr68, 4 + %72 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl69 = shl i32 %or, 4 + %ztrunc70 = trunc i32 %shl69 to i8 + %73 = load i8, i8* %72, align 1 + %74 = and i8 %73, 15 + %75 = or i8 %74, %ztrunc70 + store i8 %75, i8* %72, align 1 + %lshrl71 = lshr i32 %or, 4 + %76 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc72 = trunc i32 %lshrl71 to i8 + %77 = and i8 %ztrunc72, 3 + %78 = load i8, i8* %76, align 1 + %79 = and i8 %78, -4 + %80 = or i8 %79, %77 + store i8 %80, i8* %76, align 1 + %81 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %82 = load i8, i8* %81, align 1 + %zext73 = zext i8 %82 to i32 + %lshrl74 = lshr i32 %zext73, 1 + %shl75 = shl i32 %lshrl74, 29 + %ashr76 = ashr i32 %shl75, 29 + %83 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %84 = load i8, i8* %83, align 1 + %zext77 = zext i8 %84 to i32 + %lshrl78 = lshr i32 %zext77, 4 + %85 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %86 = load i8, i8* %85, align 1 + %zext79 = zext i8 %86 to i32 + %shl80 = shl i32 %zext79, 4 + %87 = or i32 %shl80, %lshrl78 + %shl81 = shl i32 %87, 26 + %ashr82 = ashr i32 %shl81, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.27, i32 0, i32 0), i32 %ashr76, i32 %ashr82) + %88 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %89 = load i8, i8* %88, align 1 + %zext83 = zext i8 %89 to i32 + %lshrl84 = lshr i32 %zext83, 4 + %90 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %91 = load i8, i8* %90, align 1 + %zext85 = zext i8 %91 to i32 + %shl86 = shl i32 %zext85, 4 + %92 = or i32 %shl86, %lshrl84 + %shl87 = shl i32 %92, 26 + %ashr88 = ashr i32 %shl87, 26 + %shl89 = shl i32 %ashr88, 1 + %93 = freeze i32 %shl89 + %94 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl90 = shl i32 %93, 4 + %ztrunc91 = trunc i32 %shl90 to i8 + %95 = load i8, i8* %94, align 1 + %96 = and i8 %95, 15 + %97 = or i8 %96, %ztrunc91 + store i8 %97, i8* %94, align 1 + %lshrl92 = lshr i32 %93, 4 + %98 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc93 = trunc i32 %lshrl92 to i8 + %99 = and i8 %ztrunc93, 3 + %100 = load i8, i8* %98, align 1 + %101 = and i8 %100, -4 + %102 = or i8 %101, %99 + store i8 %102, i8* %98, align 1 + %103 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %104 = load i8, i8* %103, align 1 + %zext94 = zext i8 %104 to i32 + %lshrl95 = lshr i32 %zext94, 1 + %shl96 = shl i32 %lshrl95, 29 + %ashr97 = ashr i32 %shl96, 29 + %105 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %106 = load i8, i8* %105, align 1 + %zext98 = zext i8 %106 to i32 + %lshrl99 = lshr i32 %zext98, 4 + %107 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %108 = load i8, i8* %107, align 1 + %zext100 = zext i8 %108 to i32 + %shl101 = shl i32 %zext100, 4 + %109 = or i32 %shl101, %lshrl99 + %shl102 = shl i32 %109, 26 + %ashr103 = ashr i32 %shl102, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i32 0, i32 0), i32 %ashr97, i32 %ashr103) + %110 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %111 = load i8, i8* %110, align 1 + %zext104 = zext i8 %111 to i32 + %lshrl105 = lshr i32 %zext104, 4 + %112 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %113 = load i8, i8* %112, align 1 + %zext106 = zext i8 %113 to i32 + %shl107 = shl i32 %zext106, 4 + %114 = or i32 %shl107, %lshrl105 + %shl108 = shl i32 %114, 26 + %ashr109 = ashr i32 %shl108, 26 + %ashr110 = ashr i32 %ashr109, 1 + %115 = freeze i32 %ashr110 + %116 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl111 = shl i32 %115, 4 + %ztrunc112 = trunc i32 %shl111 to i8 + %117 = load i8, i8* %116, align 1 + %118 = and i8 %117, 15 + %119 = or i8 %118, %ztrunc112 + store i8 %119, i8* %116, align 1 + %lshrl113 = lshr i32 %115, 4 + %120 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc114 = trunc i32 %lshrl113 to i8 + %121 = and i8 %ztrunc114, 3 + %122 = load i8, i8* %120, align 1 + %123 = and i8 %122, -4 + %124 = or i8 %123, %121 + store i8 %124, i8* %120, align 1 + %125 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %126 = load i8, i8* %125, align 1 + %zext115 = zext i8 %126 to i32 + %lshrl116 = lshr i32 %zext115, 1 + %shl117 = shl i32 %lshrl116, 29 + %ashr118 = ashr i32 %shl117, 29 + %127 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 %128 = load i8, i8* %127, align 1 - %129 = zext i8 %128 to i32 - %130 = shl i32 %129, 4 - %131 = or i32 %130, %126 - %132 = shl i32 %131, 26 - %133 = ashr i32 %132, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.26, i32 0, i32 0), i32 %122, i32 %133) - %134 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %zext119 = zext i8 %128 to i32 + %lshrl120 = lshr i32 %zext119, 4 + %129 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %130 = load i8, i8* %129, align 1 + %zext121 = zext i8 %130 to i32 + %shl122 = shl i32 %zext121, 4 + %131 = or i32 %shl122, %lshrl120 + %shl123 = shl i32 %131, 26 + %ashr124 = ashr i32 %shl123, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.29, i32 0, i32 0), i32 %ashr118, i32 %ashr124) + %132 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %133 = load i8, i8* %132, align 1 + %zext125 = zext i8 %133 to i32 + %lshrl126 = lshr i32 %zext125, 4 + %134 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 %135 = load i8, i8* %134, align 1 - %136 = zext i8 %135 to i32 - %137 = lshr i32 %136, 4 - %138 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %139 = load i8, i8* %138, align 1 - %140 = zext i8 %139 to i32 - %141 = shl i32 %140, 4 - %142 = or i32 %141, %137 - %143 = shl i32 %142, 26 - %144 = ashr i32 %143, 26 - %or = or i32 %144, 4 - %145 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %146 = shl i32 %or, 4 - %147 = trunc i32 %146 to i8 - %148 = load i8, i8* %145, align 1 - %149 = and i8 %148, 15 - %150 = or i8 %149, %147 - store i8 %150, i8* %145, align 1 - %151 = lshr i32 %or, 4 - %152 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %153 = trunc i32 %151 to i8 - %154 = and i8 %153, 3 - %155 = load i8, i8* %152, align 1 - %156 = and i8 %155, -4 - %157 = or i8 %156, %154 - store i8 %157, i8* %152, align 1 + %zext127 = zext i8 %135 to i32 + %shl128 = shl i32 %zext127, 4 + %136 = or i32 %shl128, %lshrl126 + %shl129 = shl i32 %136, 26 + %ashr130 = ashr i32 %shl129, 26 + %sdiv = sdiv i32 %ashr130, 2 + %137 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl131 = shl i32 %sdiv, 4 + %ztrunc132 = trunc i32 %shl131 to i8 + %138 = load i8, i8* %137, align 1 + %139 = and i8 %138, 15 + %140 = or i8 %139, %ztrunc132 + store i8 %140, i8* %137, align 1 + %lshrl133 = lshr i32 %sdiv, 4 + %141 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc134 = trunc i32 %lshrl133 to i8 + %142 = and i8 %ztrunc134, 3 + %143 = load i8, i8* %141, align 1 + %144 = and i8 %143, -4 + %145 = or i8 %144, %142 + store i8 %145, i8* %141, align 1 + %146 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %147 = load i8, i8* %146, align 1 + %zext135 = zext i8 %147 to i32 + %lshrl136 = lshr i32 %zext135, 1 + %shl137 = shl i32 %lshrl136, 29 + %ashr138 = ashr i32 %shl137, 29 + %148 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %149 = load i8, i8* %148, align 1 + %zext139 = zext i8 %149 to i32 + %lshrl140 = lshr i32 %zext139, 4 + %150 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %151 = load i8, i8* %150, align 1 + %zext141 = zext i8 %151 to i32 + %shl142 = shl i32 %zext141, 4 + %152 = or i32 %shl142, %lshrl140 + %shl143 = shl i32 %152, 26 + %ashr144 = ashr i32 %shl143, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i32 0, i32 0), i32 %ashr138, i32 %ashr144) + %153 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %154 = load i8, i8* %153, align 1 + %zext145 = zext i8 %154 to i32 + %lshrl146 = lshr i32 %zext145, 4 + %155 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %156 = load i8, i8* %155, align 1 + %zext147 = zext i8 %156 to i32 + %shl148 = shl i32 %zext147, 4 + %157 = or i32 %shl148, %lshrl146 + %shl149 = shl i32 %157, 26 + %ashr150 = ashr i32 %shl149, 26 + %smod = srem i32 %ashr150, 2 %158 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %shl151 = shl i32 %smod, 4 + %ztrunc152 = trunc i32 %shl151 to i8 %159 = load i8, i8* %158, align 1 - %160 = zext i8 %159 to i32 - %161 = lshr i32 %160, 1 - %162 = shl i32 %161, 29 - %163 = ashr i32 %162, 29 - %164 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %165 = load i8, i8* %164, align 1 - %166 = zext i8 %165 to i32 - %167 = lshr i32 %166, 4 - %168 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %169 = load i8, i8* %168, align 1 - %170 = zext i8 %169 to i32 - %171 = shl i32 %170, 4 - %172 = or i32 %171, %167 - %173 = shl i32 %172, 26 - %174 = ashr i32 %173, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.27, i32 0, i32 0), i32 %163, i32 %174) - %175 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %176 = load i8, i8* %175, align 1 - %177 = zext i8 %176 to i32 - %178 = lshr i32 %177, 4 - %179 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %180 = load i8, i8* %179, align 1 - %181 = zext i8 %180 to i32 - %182 = shl i32 %181, 4 - %183 = or i32 %182, %178 - %184 = shl i32 %183, 26 - %185 = ashr i32 %184, 26 - %shl = shl i32 %185, 1 - %186 = freeze i32 %shl - %187 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %188 = shl i32 %186, 4 - %189 = trunc i32 %188 to i8 - %190 = load i8, i8* %187, align 1 - %191 = and i8 %190, 15 - %192 = or i8 %191, %189 - store i8 %192, i8* %187, align 1 - %193 = lshr i32 %186, 4 - %194 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %195 = trunc i32 %193 to i8 - %196 = and i8 %195, 3 - %197 = load i8, i8* %194, align 1 - %198 = and i8 %197, -4 - %199 = or i8 %198, %196 - store i8 %199, i8* %194, align 1 - %200 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %201 = load i8, i8* %200, align 1 - %202 = zext i8 %201 to i32 - %203 = lshr i32 %202, 1 - %204 = shl i32 %203, 29 - %205 = ashr i32 %204, 29 - %206 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %207 = load i8, i8* %206, align 1 - %208 = zext i8 %207 to i32 - %209 = lshr i32 %208, 4 - %210 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %211 = load i8, i8* %210, align 1 - %212 = zext i8 %211 to i32 - %213 = shl i32 %212, 4 - %214 = or i32 %213, %209 - %215 = shl i32 %214, 26 - %216 = ashr i32 %215, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i32 0, i32 0), i32 %205, i32 %216) - %217 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %218 = load i8, i8* %217, align 1 - %219 = zext i8 %218 to i32 - %220 = lshr i32 %219, 4 - %221 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %222 = load i8, i8* %221, align 1 - %223 = zext i8 %222 to i32 - %224 = shl i32 %223, 4 - %225 = or i32 %224, %220 - %226 = shl i32 %225, 26 - %227 = ashr i32 %226, 26 - %ashr = ashr i32 %227, 1 - %228 = freeze i32 %ashr - %229 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %230 = shl i32 %228, 4 - %231 = trunc i32 %230 to i8 - %232 = load i8, i8* %229, align 1 - %233 = and i8 %232, 15 - %234 = or i8 %233, %231 - store i8 %234, i8* %229, align 1 - %235 = lshr i32 %228, 4 - %236 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %237 = trunc i32 %235 to i8 - %238 = and i8 %237, 3 - %239 = load i8, i8* %236, align 1 - %240 = and i8 %239, -4 - %241 = or i8 %240, %238 - store i8 %241, i8* %236, align 1 - %242 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %243 = load i8, i8* %242, align 1 - %244 = zext i8 %243 to i32 - %245 = lshr i32 %244, 1 - %246 = shl i32 %245, 29 - %247 = ashr i32 %246, 29 - %248 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %249 = load i8, i8* %248, align 1 - %250 = zext i8 %249 to i32 - %251 = lshr i32 %250, 4 - %252 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %253 = load i8, i8* %252, align 1 - %254 = zext i8 %253 to i32 - %255 = shl i32 %254, 4 - %256 = or i32 %255, %251 - %257 = shl i32 %256, 26 - %258 = ashr i32 %257, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.29, i32 0, i32 0), i32 %247, i32 %258) - %259 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %260 = load i8, i8* %259, align 1 - %261 = zext i8 %260 to i32 - %262 = lshr i32 %261, 4 - %263 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %264 = load i8, i8* %263, align 1 - %265 = zext i8 %264 to i32 - %266 = shl i32 %265, 4 - %267 = or i32 %266, %262 - %268 = shl i32 %267, 26 - %269 = ashr i32 %268, 26 - %sdiv = sdiv i32 %269, 2 - %270 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %271 = shl i32 %sdiv, 4 - %272 = trunc i32 %271 to i8 - %273 = load i8, i8* %270, align 1 - %274 = and i8 %273, 15 - %275 = or i8 %274, %272 - store i8 %275, i8* %270, align 1 - %276 = lshr i32 %sdiv, 4 - %277 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %278 = trunc i32 %276 to i8 - %279 = and i8 %278, 3 - %280 = load i8, i8* %277, align 1 - %281 = and i8 %280, -4 - %282 = or i8 %281, %279 - store i8 %282, i8* %277, align 1 - %283 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %284 = load i8, i8* %283, align 1 - %285 = zext i8 %284 to i32 - %286 = lshr i32 %285, 1 - %287 = shl i32 %286, 29 - %288 = ashr i32 %287, 29 - %289 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %290 = load i8, i8* %289, align 1 - %291 = zext i8 %290 to i32 - %292 = lshr i32 %291, 4 - %293 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %294 = load i8, i8* %293, align 1 - %295 = zext i8 %294 to i32 - %296 = shl i32 %295, 4 - %297 = or i32 %296, %292 - %298 = shl i32 %297, 26 - %299 = ashr i32 %298, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i32 0, i32 0), i32 %288, i32 %299) - %300 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %301 = load i8, i8* %300, align 1 - %302 = zext i8 %301 to i32 - %303 = lshr i32 %302, 4 - %304 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %305 = load i8, i8* %304, align 1 - %306 = zext i8 %305 to i32 - %307 = shl i32 %306, 4 - %308 = or i32 %307, %303 - %309 = shl i32 %308, 26 - %310 = ashr i32 %309, 26 - %smod = srem i32 %310, 2 - %311 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %312 = shl i32 %smod, 4 - %313 = trunc i32 %312 to i8 - %314 = load i8, i8* %311, align 1 - %315 = and i8 %314, 15 - %316 = or i8 %315, %313 - store i8 %316, i8* %311, align 1 - %317 = lshr i32 %smod, 4 - %318 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %319 = trunc i32 %317 to i8 - %320 = and i8 %319, 3 - %321 = load i8, i8* %318, align 1 - %322 = and i8 %321, -4 - %323 = or i8 %322, %320 - store i8 %323, i8* %318, align 1 - %324 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %325 = load i8, i8* %324, align 1 - %326 = zext i8 %325 to i32 - %327 = lshr i32 %326, 1 - %328 = shl i32 %327, 29 - %329 = ashr i32 %328, 29 - %330 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 - %331 = load i8, i8* %330, align 1 - %332 = zext i8 %331 to i32 - %333 = lshr i32 %332, 4 - %334 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 - %335 = load i8, i8* %334, align 1 - %336 = zext i8 %335 to i32 - %337 = shl i32 %336, 4 - %338 = or i32 %337, %333 - %339 = shl i32 %338, 26 - %340 = ashr i32 %339, 26 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.31, i32 0, i32 0), i32 %329, i32 %340) - %341 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %342 = load i8, i8* %341, align 1 - %343 = lshr i8 %342, 5 - %344 = trunc i8 %343 to i1 - %boolsi = zext i1 %344 to i32 + %160 = and i8 %159, 15 + %161 = or i8 %160, %ztrunc152 + store i8 %161, i8* %158, align 1 + %lshrl153 = lshr i32 %smod, 4 + %162 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %ztrunc154 = trunc i32 %lshrl153 to i8 + %163 = and i8 %ztrunc154, 3 + %164 = load i8, i8* %162, align 1 + %165 = and i8 %164, -4 + %166 = or i8 %165, %163 + store i8 %166, i8* %162, align 1 + %167 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %168 = load i8, i8* %167, align 1 + %zext155 = zext i8 %168 to i32 + %lshrl156 = lshr i32 %zext155, 1 + %shl157 = shl i32 %lshrl156, 29 + %ashr158 = ashr i32 %shl157, 29 + %169 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 0 + %170 = load i8, i8* %169, align 1 + %zext159 = zext i8 %170 to i32 + %lshrl160 = lshr i32 %zext159, 4 + %171 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 1 + %172 = load i8, i8* %171, align 1 + %zext161 = zext i8 %172 to i32 + %shl162 = shl i32 %zext161, 4 + %173 = or i32 %shl162, %lshrl160 + %shl163 = shl i32 %173, 26 + %ashr164 = ashr i32 %shl163, 26 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.31, i32 0, i32 0), i32 %ashr158, i32 %ashr164) + %174 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %175 = load i8, i8* %174, align 1 + %lshrl165 = lshr i8 %175, 5 + %176 = trunc i8 %lshrl165 to i1 + %boolsi = zext i1 %176 to i32 call void (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.32, i32 0, i32 0), i32 %boolsi) - %345 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %346 = load i8, i8* %345, align 1 - %347 = and i8 %346, -33 - %348 = or i8 %347, 32 - store i8 %348, i8* %345, align 1 - %349 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %350 = load i8, i8* %349, align 1 - %351 = lshr i8 %350, 5 - %352 = trunc i8 %351 to i1 - %boolsi1 = zext i1 %352 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i32 0, i32 0), i32 %boolsi1) - %353 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %354 = load i8, i8* %353, align 1 - %355 = and i8 %354, -33 - store i8 %355, i8* %353, align 1 - %356 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 - %357 = load i8, i8* %356, align 1 - %358 = lshr i8 %357, 5 - %359 = trunc i8 %358 to i1 - %boolsi2 = zext i1 %359 to i32 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i32 0, i32 0), i32 %boolsi2) + %177 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %178 = load i8, i8* %177, align 1 + %179 = and i8 %178, -33 + %180 = or i8 %179, 32 + store i8 %180, i8* %177, align 1 + %181 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %182 = load i8, i8* %181, align 1 + %lshrl166 = lshr i8 %182, 5 + %183 = trunc i8 %lshrl166 to i1 + %boolsi167 = zext i1 %183 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i32 0, i32 0), i32 %boolsi167) + %184 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %185 = load i8, i8* %184, align 1 + %186 = and i8 %185, -33 + store i8 %186, i8* %184, align 1 + %187 = getelementptr inbounds [3 x i8], [3 x i8]* %xx, i64 0, i64 2 + %188 = load i8, i8* %187, align 1 + %lshrl168 = lshr i8 %188, 5 + %189 = trunc i8 %lshrl168 to i1 + %boolsi169 = zext i1 %189 to i32 + call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i32 0, i32 0), i32 %boolsi169) ret void } diff --git a/test/test_suite/bitstruct/bitstruct_arrays_be.c3t b/test/test_suite/bitstruct/bitstruct_arrays_be.c3t index 017d87088..158a7f762 100644 --- a/test/test_suite/bitstruct/bitstruct_arrays_be.c3t +++ b/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 - %3 = lshr i32 %2, 4 - %4 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1 - %5 = load i8, i8* %4, align 1 - %6 = zext i8 %5 to i32 - %7 = shl i32 %6, 4 - %8 = or i32 %7, %3 - %9 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2 - %10 = load i8, i8* %9, align 1 - %11 = zext i8 %10 to i32 - %12 = shl i32 %11, 12 - %13 = or i32 %12, %8 - %14 = shl i32 %13, 16 - %15 = call i32 @llvm.bswap.i32(i32 %14) - %16 = and i32 65535, %15 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i32 0, i32 0), i32 %16) + %zext = zext i8 %1 to i32 + %lshrl = lshr i32 %zext, 4 + %2 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1 + %3 = load i8, i8* %2, align 1 + %zext1 = zext i8 %3 to i32 + %shl = shl i32 %zext1, 4 + %4 = or i32 %shl, %lshrl + %5 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2 + %6 = load i8, i8* %5, align 1 + %zext2 = zext i8 %6 to i32 + %shl3 = shl i32 %zext2, 12 + %7 = or i32 %shl3, %4 + %shl4 = shl i32 %7, 16 + %8 = call i32 @llvm.bswap.i32(i32 %shl4) + %9 = and i32 65535, %8 + 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 - %ptrptr1 = bitcast i8* %17 to [4 x i8]* - store [4 x i8]* %ptrptr1, [4 x i8]** %z, align 8 - %18 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0 - %19 = load i8, i8* %18, align 1 - %20 = zext i8 %19 to i32 - %21 = lshr i32 %20, 4 - %22 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1 - %23 = load i8, i8* %22, align 1 - %24 = zext i8 %23 to i32 - %25 = shl i32 %24, 4 - %26 = or i32 %25, %21 - %27 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2 - %28 = load i8, i8* %27, align 1 - %29 = zext i8 %28 to i32 - %30 = shl i32 %29, 12 - %31 = or i32 %30, %26 - %32 = and i32 65535, %31 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i32 %32) - %33 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0 - %34 = load i8, i8* %33, align 1 - %35 = and i8 %34, 15 - %36 = or i8 %35, -16 - store i8 %36, i8* %33, align 1 - %37 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1 - store i8 -18, i8* %37, align 1 - %38 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2 + %10 = load i8*, i8** %abc, align 8 + %ptrptr5 = bitcast i8* %10 to [4 x i8]* + store [4 x i8]* %ptrptr5, [4 x i8]** %z, align 8 + %11 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0 + %12 = load i8, i8* %11, align 1 + %zext6 = zext i8 %12 to i32 + %lshrl7 = lshr i32 %zext6, 4 + %13 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1 + %14 = load i8, i8* %13, align 1 + %zext8 = zext i8 %14 to i32 + %shl9 = shl i32 %zext8, 4 + %15 = or i32 %shl9, %lshrl7 + %16 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2 + %17 = load i8, i8* %16, align 1 + %zext10 = zext i8 %17 to i32 + %shl11 = shl i32 %zext10, 12 + %18 = or i32 %shl11, %15 + %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 %19) + %20 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 0 + %21 = load i8, i8* %20, align 1 + %22 = and i8 %21, 15 + %23 = or i8 %22, -16 + store i8 %23, i8* %20, align 1 + %24 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1 + store i8 -18, i8* %24, align 1 + %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 - %41 = or i8 %40, 11 + %40 = and i8 %39, 15 + %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 - %43 = load i8, i8* %42, align 1 - %44 = zext i8 %43 to i32 - %45 = lshr i32 %44, 4 - %46 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 1 - %47 = load i8, i8* %46, align 1 - %48 = zext i8 %47 to i32 - %49 = shl i32 %48, 4 - %50 = or i32 %49, %45 - %51 = getelementptr inbounds [4 x i8], [4 x i8]* %xy, i64 0, i64 2 - %52 = load i8, i8* %51, align 1 - %53 = zext i8 %52 to i32 - %54 = shl i32 %53, 12 - %55 = or i32 %54, %50 + %42 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1 + store i8 -5, i8* %42, align 1 + %43 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 2 + %44 = load i8, i8* %43, align 1 + %45 = and i8 %44, -16 + %46 = or i8 %45, 14 + store i8 %46, i8* %43, align 1 + %47 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 0 + %48 = load i8, i8* %47, align 1 + %zext18 = zext i8 %48 to i32 + %lshrl19 = lshr i32 %zext18, 4 + %49 = getelementptr inbounds [4 x i8], [4 x i8]* %xx, i64 0, i64 1 + %50 = load i8, i8* %49, align 1 + %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) - %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) + call void (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i32 0, i32 0), i32 %56) ret void } \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitstruct_intcontainer.c3t b/test/test_suite/bitstruct/bitstruct_intcontainer.c3t index 54eb22041..12580a87f 100644 --- a/test/test_suite/bitstruct/bitstruct_intcontainer.c3t +++ b/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 - %2 = ashr i32 %1, 14 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %2) + %shl = shl i32 %0, 9 + %ashr = ashr i32 %shl, 14 + 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 - %4 = shl i32 %3, 9 - %5 = ashr i32 %4, 14 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %5) + %1 = load i32, i32* %xx, align 4 + %shl1 = shl i32 %1, 9 + %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 %ashr2) store i32 -3485921, i32* %xxu, align 4 - %6 = load i32, i32* %xxu, align 4 - %7 = lshr i32 %6, 5 - %8 = and i32 262143, %7 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i32 %8) + %2 = load i32, i32* %xxu, align 4 + %lshrl = lshr i32 %2, 5 + %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 %3) store i64 1525363991714123551, i64* %xxy, align 8 - %9 = load i64, i64* %xxy, align 8 - %10 = lshr i64 %9, 5 - %11 = and i64 262143, %10 - %12 = trunc i64 %11 to i32 - %13 = load i64, i64* %xxy, align 8 - %14 = lshr i64 %13, 23 - %15 = and i64 262143, %14 - %16 = trunc i64 %15 to i32 - %17 = load i64, i64* %xxy, align 8 - %18 = lshr i64 %17, 41 - %19 = and i64 2097151, %18 - %20 = trunc i64 %19 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) + %4 = load i64, i64* %xxy, align 8 + %lshrl3 = lshr i64 %4, 5 + %5 = and i64 262143, %lshrl3 + %ztrunc = trunc i64 %5 to i32 + %6 = load i64, i64* %xxy, align 8 + %lshrl4 = lshr i64 %6, 23 + %7 = and i64 262143, %lshrl4 + %ztrunc5 = trunc i64 %7 to i32 + %8 = load i64, i64* %xxy, align 8 + %lshrl6 = lshr i64 %8, 41 + %9 = and i64 2097151, %lshrl6 + %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 %ztrunc, i32 %ztrunc5, i32 %ztrunc7) store i64 2292133196431502101, i64* %xxybe, align 8 - %21 = load i64, i64* %xxybe, align 8 - %22 = call i64 @llvm.bswap.i64(i64 %21) - %23 = lshr i64 %22, 5 - %24 = and i64 262143, %23 - %25 = trunc i64 %24 to i32 - %26 = load i64, i64* %xxybe, align 8 - %27 = call i64 @llvm.bswap.i64(i64 %26) - %28 = lshr i64 %27, 23 - %29 = and i64 262143, %28 - %30 = trunc i64 %29 to i32 - %31 = load i64, i64* %xxybe, align 8 - %32 = call i64 @llvm.bswap.i64(i64 %31) - %33 = lshr i64 %32, 41 - %34 = and i64 2097151, %33 - %35 = trunc i64 %34 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) + %10 = load i64, i64* %xxybe, align 8 + %11 = call i64 @llvm.bswap.i64(i64 %10) + %lshrl8 = lshr i64 %11, 5 + %12 = and i64 262143, %lshrl8 + %ztrunc9 = trunc i64 %12 to i32 + %13 = load i64, i64* %xxybe, align 8 + %14 = call i64 @llvm.bswap.i64(i64 %13) + %lshrl10 = lshr i64 %14, 23 + %15 = and i64 262143, %lshrl10 + %ztrunc11 = trunc i64 %15 to i32 + %16 = load i64, i64* %xxybe, align 8 + %17 = call i64 @llvm.bswap.i64(i64 %16) + %lshrl12 = lshr i64 %17, 41 + %18 = and i64 2097151, %lshrl12 + %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 %ztrunc9, i32 %ztrunc11, i32 %ztrunc13) ret void } \ No newline at end of file diff --git a/test/test_suite/bitstruct/bitstruct_to_int.c3t b/test/test_suite/bitstruct/bitstruct_to_int.c3t index 4391cb79b..8b45c964e 100644 --- a/test/test_suite/bitstruct/bitstruct_to_int.c3t +++ b/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 - %6 = ashr i32 %5, 29 - %7 = load i32*, i32** %c, align 8 - store i32* %7, i32** %x2, align 8 - %8 = load i32*, i32** %c, align 8 - %ptrptr = bitcast i32* %8 to [4 x i8]* + %shl = shl i32 %4, 28 + %ashr = ashr i32 %shl, 29 + %5 = load i32*, i32** %c, align 8 + store i32* %5, i32** %x2, align 8 + %6 = load i32*, i32** %c, align 8 + %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 - %8 = lshr i32 %7, 1 - %9 = shl i32 %8, 29 - %10 = ashr i32 %9, 29 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %10) - %11 = load [4 x i8]*, [4 x i8]** %c, align 8 - %ptrptr = bitcast [4 x i8]* %11 to i32* + %zext = zext i8 %6 to i32 + %lshrl = lshr i32 %zext, 1 + %shl = shl i32 %lshrl, 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 %ashr) + %7 = load [4 x i8]*, [4 x i8]** %c, align 8 + %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 - store [4 x i8]* %12, [4 x i8]** %y2, align 8 + %8 = load [4 x i8]*, [4 x i8]** %c, align 8 + store [4 x i8]* %8, [4 x i8]** %y2, align 8 ret void } diff --git a/test/test_suite/bitstruct/embedded_bitstruct.c3t b/test/test_suite/bitstruct/embedded_bitstruct.c3t index 59ba5f866..a91acad64 100644 --- a/test/test_suite/bitstruct/embedded_bitstruct.c3t +++ b/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 - %8 = ashr i32 %7, 23 - call void (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0), i32 %4, i32 %8) - %9 = 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) - %10 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0 - %11 = getelementptr inbounds %anon.1, %anon.1* %10, i32 0, i32 0 - %12 = getelementptr inbounds %anon.2, %anon.2* %11, i32 0, i32 0 - %13 = load i32, i32* %12, align 4 - %14 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0 - %15 = getelementptr inbounds %anon.1, %anon.1* %14, i32 0, i32 1 - %16 = getelementptr inbounds %anon.3, %anon.3* %15, i32 0, i32 0 - %17 = load i32, i32* %16, align 4 - %18 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0 - %19 = getelementptr inbounds %anon.1, %anon.1* %18, i32 0, i32 2 + %shl = shl i32 %6, 21 + %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 %ashr) + %7 = bitcast %Foo* %f to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %7, i8* align 4 bitcast (%Foo* @.__const.10 to i8*), i32 16, i1 false) + %8 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0 + %9 = getelementptr inbounds %anon.1, %anon.1* %8, i32 0, i32 0 + %10 = getelementptr inbounds %anon.2, %anon.2* %9, i32 0, i32 0 + %11 = load i32, i32* %10, align 4 + %12 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0 + %13 = getelementptr inbounds %anon.1, %anon.1* %12, i32 0, i32 1 + %14 = getelementptr inbounds %anon.3, %anon.3* %13, i32 0, i32 0 + %15 = load i32, i32* %14, align 4 + %16 = getelementptr inbounds %Foo, %Foo* %f, i32 0, i32 0 + %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 - %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) + 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) ret void } diff --git a/test/test_suite/cast/top_down_casts.c3t b/test/test_suite/cast/top_down_casts.c3t index e10553f7f..ac882bf5a 100644 --- a/test/test_suite/cast/top_down_casts.c3t +++ b/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 - %shl = shl i64 %sisiext10, %12 - %13 = freeze i64 %shl - store i64 %13, i64* %z, align 8 - %14 = load i32, i32* %x, align 4 - %sisiext11 = sext i32 %14 to i64 - %15 = load i32, i32* %y, align 4 - %16 = zext i32 %15 to i64 - %ashr = ashr i64 %sisiext11, %16 - %17 = freeze i64 %ashr - store i64 %17, i64* %z, align 8 - %18 = load i32, i32* %x, align 4 - %sisiext12 = sext i32 %18 to i64 - %bnot = xor i64 %sisiext12, -1 + %zext = zext i32 %11 to i64 + %shl = shl i64 %sisiext10, %zext + %12 = freeze i64 %shl + store i64 %12, i64* %z, align 8 + %13 = load i32, i32* %x, align 4 + %sisiext11 = sext i32 %13 to i64 + %14 = load i32, i32* %y, align 4 + %zext12 = zext i32 %14 to i64 + %ashr = ashr i64 %sisiext11, %zext12 + %15 = freeze i64 %ashr + store i64 %15, i64* %z, align 8 + %16 = load i32, i32* %x, align 4 + %sisiext13 = sext i32 %16 to i64 + %bnot = xor i64 %sisiext13, -1 store i64 %bnot, i64* %z, align 8 - %19 = load i32, i32* %x, align 4 - %sisiext13 = sext i32 %19 to i64 - %20 = load i32, i32* %x, align 4 - %sisiext14 = sext i32 %20 to i64 - %neg = sub i64 0, %sisiext14 + %17 = load i32, i32* %x, align 4 + %sisiext14 = sext i32 %17 to i64 + %18 = load i32, i32* %x, align 4 + %sisiext15 = sext i32 %18 to i64 + %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 - %not_err = icmp eq i64 %21, 0 + %optval = load i64, i64* %w.f, align 8 + %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 - %sisiext15 = sext i32 %22 to i64 + %19 = load i32, i32* %w, align 4 + %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 } \ No newline at end of file diff --git a/test/test_suite/clang/2002-04.c3t b/test/test_suite/clang/2002-04.c3t index a54556205..9896ab912 100644 --- a/test/test_suite/clang/2002-04.c3t +++ b/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 - %2 = getelementptr inbounds [30 x double], [30 x double]* %student_t, i64 0, i64 %uiuiext + %zext = zext i32 %0 to i64 + %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 } diff --git a/test/test_suite/enumerations/enum_cast.c3t b/test/test_suite/enumerations/enum_cast.c3t index 36dfe4d52..43a9b3a48 100644 --- a/test/test_suite/enumerations/enum_cast.c3t +++ b/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 - %not_err = icmp eq i64 %3, 0 + %optval = load i64, i64* %xf.f, align 8 + %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 - %uifp1 = uitofp i8 %4 to float + %3 = load i8, i8* %xf, align 1 + %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 diff --git a/test/test_suite/errors/error_regression_2.c3t b/test/test_suite/errors/error_regression_2.c3t index 90d8077ed..5a777863f 100644 --- a/test/test_suite/errors/error_regression_2.c3t +++ b/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 - store %Head %34, %Head* %value, align 8 - %35 = call i8* @std_core_mem_malloc(i64 8) #2 - %ptrptr = bitcast i8* %35 to %Head* + %34 = bitcast %Head* %value to i8* + %35 = bitcast %Head* %literal18 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %34, i8* align 8 %35, i32 8, i1 false) + %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 - %not = icmp eq %Head* %36, null + %37 = load %Head*, %Head** %temp, align 8 + %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 = bitcast %Head* %37 to i8* - %39 = bitcast %Head* %value to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %38, i8* align 8 %39, i32 8, i1 false) + %38 = load %Head*, %Head** %temp, align 8 + %39 = bitcast %Head* %38 to i8* + %40 = bitcast %Head* %value to i8* + 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 - ret i64 %40 + %41 = load i64, i64* %error_var, align 8 + ret i64 %41 noerr_block: ; preds = %if.exit20 - %41 = load %Head*, %Head** %temp, align 8 - store %Head* %41, %Head** %32, align 8 - %42 = bitcast %Doc* %0 to i8* - %43 = bitcast %Doc* %literal17 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %42, i8* align 8 %43, i32 8, i1 false) + %42 = load %Head*, %Head** %temp, align 8 + store %Head* %42, %Head** %32, align 8 + %43 = bitcast %Doc* %0 to i8* + %44 = bitcast %Doc* %literal17 to i8* + 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 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0 - %lo22 = load i8*, i8** %45, align 8 - %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1 - %hi23 = load i64, i64* %46, align 8 + %45 = bitcast %"char[]"* %url to { i8*, i64 }* + %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 + %lo22 = load i8*, i8** %46, align 8 + %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 + %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 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 0 - %lo25 = load i8*, i8** %48, align 8 - %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 1 - %hi26 = load i64, i64* %49, align 8 - %50 = call i8 @test_contains(i8* %lo22, i64 %hi23, i8* %lo25, i64 %hi26) - %51 = trunc i8 %50 to i1 - br i1 %51, label %if.then27, label %if.exit49 + %48 = bitcast %"char[]"* %taddr24 to { i8*, i64 }* + %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 0 + %lo25 = load i8*, i8** %49, align 8 + %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %48, i32 0, i32 1 + %hi26 = load i64, i64* %50, align 8 + %51 = call i8 @test_contains(i8* %lo22, i64 %hi23, i8* %lo25, i64 %hi26) + %52 = trunc i8 %51 to i1 + 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 = bitcast %Head* %literal32 to %"char[]"** - store %"char[]"* null, %"char[]"** %53, align 8 - %54 = getelementptr inbounds %Head, %Head* %literal32, i32 0, i32 0 + %53 = getelementptr inbounds %Doc, %Doc* %literal29, i32 0, i32 0 + %54 = bitcast %Head* %literal32 to %"char[]"** + store %"char[]"* null, %"char[]"** %54, align 8 + %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 - %ptrptr36 = bitcast i8* %55 to %"char[]"* + %56 = call i8* @std_core_mem_malloc(i64 16) #2 + %ptrptr36 = bitcast i8* %56 to %"char[]"* store %"char[]"* %ptrptr36, %"char[]"** %temp35, align 8 - %56 = load %"char[]"*, %"char[]"** %temp35, align 8 - %not37 = icmp eq %"char[]"* %56, null + %57 = load %"char[]"*, %"char[]"** %temp35, align 8 + %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 = bitcast %"char[]"* %57 to i8* - %59 = bitcast %"char[]"* %value34 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %58, i8* align 8 %59, i32 16, i1 false) + %58 = load %"char[]"*, %"char[]"** %temp35, align 8 + %59 = bitcast %"char[]"* %58 to i8* + %60 = bitcast %"char[]"* %value34 to i8* + 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 - ret i64 %60 + %61 = load i64, i64* %error_var33, align 8 + ret i64 %61 noerr_block41: ; preds = %if.exit39 - %61 = load %"char[]"*, %"char[]"** %temp35, align 8 - store %"char[]"* %61, %"char[]"** %54, align 8 - %62 = load %Head, %Head* %literal32, align 8 - store %Head %62, %Head* %value31, align 8 - %63 = call i8* @std_core_mem_malloc(i64 8) #2 - %ptrptr43 = bitcast i8* %63 to %Head* + %62 = load %"char[]"*, %"char[]"** %temp35, align 8 + store %"char[]"* %62, %"char[]"** %55, align 8 + %63 = bitcast %Head* %value31 to i8* + %64 = bitcast %Head* %literal32 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %63, i8* align 8 %64, i32 8, i1 false) + %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 - %not44 = icmp eq %Head* %64, null + %66 = load %Head*, %Head** %temp42, align 8 + %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 - %66 = bitcast %Head* %65 to i8* - %67 = bitcast %Head* %value31 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %66, i8* align 8 %67, i32 8, i1 false) + %67 = load %Head*, %Head** %temp42, align 8 + %68 = bitcast %Head* %67 to i8* + %69 = bitcast %Head* %value31 to i8* + 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 - ret i64 %68 + %70 = load i64, i64* %error_var30, align 8 + ret i64 %70 noerr_block48: ; preds = %if.exit46 - %69 = load %Head*, %Head** %temp42, align 8 - store %Head* %69, %Head** %52, align 8 - %70 = bitcast %Doc* %0 to i8* - %71 = bitcast %Doc* %literal29 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %70, i8* align 8 %71, i32 8, i1 false) + %71 = load %Head*, %Head** %temp42, align 8 + store %Head* %71, %Head** %53, align 8 + %72 = bitcast %Doc* %0 to i8* + %73 = bitcast %Doc* %literal29 to i8* + 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 - %73 = load i64, i64* %72, align 8 - %uisitrunc = trunc i64 %73 to i32 - %74 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 - %75 = load i8*, i8** %74, 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) - store i32 %76, i32* %len, align 4 - %77 = load i32, i32* %len, align 4 - %siuiext = sext i32 %77 to i64 + %74 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %75 = load i64, i64* %74, align 8 + %uisitrunc = trunc i64 %75 to i32 + %76 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %77 = load i8*, i8** %76, align 8 + %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 %78, i32* %len, align 4 + %79 = load i32, i32* %len, align 4 + %siuiext = sext i32 %79 to i64 %add = add i64 %siuiext, 1 - %78 = call i8* @std_core_mem_malloc(i64 %add) #2 - store i8* %78, i8** %str, align 8 - %79 = load i8*, i8** %str, align 8 - %not50 = icmp eq i8* %79, null + %80 = call i8* @std_core_mem_malloc(i64 %add) #2 + store i8* %80, i8** %str, align 8 + %81 = load i8*, i8** %str, align 8 + %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 - %81 = load i32, i32* %len, align 4 - %siuiext53 = sext i32 %81 to i64 + %82 = load i8*, i8** %str, align 8 + %83 = load i32, i32* %len, align 4 + %siuiext53 = sext i32 %83 to i64 %add54 = add i64 %siuiext53, 1 - %82 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 - %83 = load i64, i64* %82, align 8 - %uisitrunc55 = trunc i64 %83 to i32 - %84 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 - %85 = load i8*, i8** %84, 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) - %87 = getelementptr inbounds %Doc, %Doc* %literal57, i32 0, i32 0 - %88 = bitcast %Head* %literal60 to %"char[]"** - store %"char[]"* null, %"char[]"** %88, align 8 - %89 = getelementptr inbounds %Head, %Head* %literal60, i32 0, i32 0 - %90 = load i8*, i8** %str, align 8 - %91 = load i32, i32* %len, align 4 - %sub = sub i32 %91, 1 + %84 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 1 + %85 = load i64, i64* %84, align 8 + %uisitrunc55 = trunc i64 %85 to i32 + %86 = getelementptr inbounds %"char[]", %"char[]"* %url, i32 0, i32 0 + %87 = load i8*, i8** %86, align 8 + %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) + %89 = getelementptr inbounds %Doc, %Doc* %literal57, i32 0, i32 0 + %90 = bitcast %Head* %literal60 to %"char[]"** + store %"char[]"* null, %"char[]"** %90, align 8 + %91 = getelementptr inbounds %Head, %Head* %literal60, i32 0, i32 0 + %92 = load i8*, i8** %str, align 8 + %93 = load i32, i32* %len, align 4 + %sub = sub i32 %93, 1 %sisiext = sext i32 %sub to i64 - %92 = add i64 %sisiext, 1 - %size = sub i64 %92, 0 - %ptroffset = getelementptr inbounds i8, i8* %90, i64 0 - %93 = insertvalue %"char[]" undef, i8* %ptroffset, 0 - %94 = insertvalue %"char[]" %93, i64 %size, 1 - store %"char[]" %94, %"char[]"* %value62, align 8 - %95 = call i8* @std_core_mem_malloc(i64 16) #2 - %ptrptr64 = bitcast i8* %95 to %"char[]"* + %94 = add i64 %sisiext, 1 + %size = sub i64 %94, 0 + %ptroffset = getelementptr inbounds i8, i8* %92, i64 0 + %95 = insertvalue %"char[]" undef, i8* %ptroffset, 0 + %96 = insertvalue %"char[]" %95, i64 %size, 1 + store %"char[]" %96, %"char[]"* %value62, align 8 + %97 = call i8* @std_core_mem_malloc(i64 16) #2 + %ptrptr64 = bitcast i8* %97 to %"char[]"* store %"char[]"* %ptrptr64, %"char[]"** %temp63, align 8 - %96 = load %"char[]"*, %"char[]"** %temp63, align 8 - %not65 = icmp eq %"char[]"* %96, null + %98 = load %"char[]"*, %"char[]"** %temp63, align 8 + %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 - %98 = bitcast %"char[]"* %97 to i8* - %99 = bitcast %"char[]"* %value62 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %98, i8* align 8 %99, i32 16, i1 false) + %99 = load %"char[]"*, %"char[]"** %temp63, align 8 + %100 = bitcast %"char[]"* %99 to i8* + %101 = bitcast %"char[]"* %value62 to i8* + 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 - ret i64 %100 + %102 = load i64, i64* %error_var61, align 8 + ret i64 %102 noerr_block69: ; preds = %if.exit67 - %101 = load %"char[]"*, %"char[]"** %temp63, align 8 - store %"char[]"* %101, %"char[]"** %89, align 8 - %102 = load %Head, %Head* %literal60, align 8 - store %Head %102, %Head* %value59, align 8 - %103 = call i8* @std_core_mem_malloc(i64 8) #2 - %ptrptr71 = bitcast i8* %103 to %Head* + %103 = load %"char[]"*, %"char[]"** %temp63, align 8 + store %"char[]"* %103, %"char[]"** %91, align 8 + %104 = bitcast %Head* %value59 to i8* + %105 = bitcast %Head* %literal60 to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %104, i8* align 8 %105, i32 8, i1 false) + %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 - %not72 = icmp eq %Head* %104, null + %107 = load %Head*, %Head** %temp70, align 8 + %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 - %106 = bitcast %Head* %105 to i8* - %107 = bitcast %Head* %value59 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %106, i8* align 8 %107, i32 8, i1 false) + %108 = load %Head*, %Head** %temp70, align 8 + %109 = bitcast %Head* %108 to i8* + %110 = bitcast %Head* %value59 to i8* + 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 - ret i64 %108 + %111 = load i64, i64* %error_var58, align 8 + ret i64 %111 noerr_block76: ; preds = %if.exit74 - %109 = load %Head*, %Head** %temp70, align 8 - store %Head* %109, %Head** %87, align 8 - %110 = bitcast %Doc* %0 to i8* - %111 = bitcast %Doc* %literal57 to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 8 %110, i8* align 8 %111, i32 8, i1 false) + %112 = load %Head*, %Head** %temp70, align 8 + store %Head* %112, %Head** %89, align 8 + %113 = bitcast %Doc* %0 to i8* + %114 = bitcast %Doc* %literal57 to i8* + 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 - %not_err5 = icmp eq i64 %47, 0 + %optval = load i64, i64* %has_title.f, align 8 + %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 - %49 = call i8* @test_bool_to_string(i8 %48) + %47 = load i8, i8* %has_title, align 1 + %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 - %51 = call i8* @test_nameFromError(i64 %50) + %49 = load i64, i64* %has_title.f, align 8 + %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 ] - %52 = load i64, i64* %has_title.f, align 8 - %not_err8 = icmp eq i64 %52, 0 - br i1 %not_err8, label %after_check9, label %else_block10 + %val7 = phi i8* [ %48, %after_check6 ], [ %50, %else_block ] + %optval8 = load i64, i64* %has_title.f, align 8 + %not_err9 = icmp eq i64 %optval8, 0 + br i1 %not_err9, label %after_check10, label %else_block11 -after_check9: ; preds = %phi_block - %53 = load i8, i8* %has_title, align 1 - %54 = trunc i8 %53 to i1 - br label %phi_block11 +after_check10: ; preds = %phi_block + %51 = load i8, i8* %has_title, align 1 + %52 = trunc i8 %51 to i1 + br label %phi_block12 -else_block10: ; preds = %phi_block - br label %phi_block11 +else_block11: ; preds = %phi_block + br label %phi_block12 -phi_block11: ; preds = %else_block10, %after_check9 - %val12 = phi i1 [ %54, %after_check9 ], [ false, %else_block10 ] - %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) - %55 = 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 - %add = add i64 %56, 1 +phi_block12: ; preds = %else_block11, %after_check10 + %val13 = phi i1 [ %52, %after_check10 ], [ false, %else_block11 ] + %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) + %53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i32 0, i32 0), i8* %val7, i8* %ternary) + %54 = load i64, i64* %anon, align 8 + %add = add i64 %54, 1 store i64 %add, i64* %anon, align 8 br label %loop.cond diff --git a/test/test_suite/errors/failable_chained_init.c3t b/test/test_suite/errors/failable_chained_init.c3t index 278edd939..fb9e69655 100644 --- a/test/test_suite/errors/failable_chained_init.c3t +++ b/test/test_suite/errors/failable_chained_init.c3t @@ -59,18 +59,18 @@ entry: %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 %err5 = alloca i64, align 8 - %retparam13 = alloca i64, align 8 - %taddr14 = alloca %"char[]", align 8 - %vararg17 = alloca %"variant[]", align 8 - %varargslots18 = alloca [1 x %variant], align 16 - %retparam25 = alloca i64, align 8 - %taddr26 = alloca %"char[]", align 8 - %vararg29 = alloca %"variant[]", align 8 - %varargslots30 = alloca [1 x %variant], align 16 - %retparam38 = alloca i64, align 8 - %taddr39 = alloca %"char[]", align 8 - %vararg42 = alloca %"variant[]", align 8 - %varargslots43 = alloca [1 x %variant], align 16 + %retparam14 = alloca i64, align 8 + %taddr15 = alloca %"char[]", align 8 + %vararg18 = alloca %"variant[]", align 8 + %varargslots19 = alloca [1 x %variant], align 16 + %retparam26 = alloca i64, align 8 + %taddr27 = alloca %"char[]", align 8 + %vararg30 = alloca %"variant[]", align 8 + %varargslots31 = alloca [1 x %variant], align 16 + %retparam40 = alloca i64, align 8 + %taddr41 = alloca %"char[]", align 8 + %vararg44 = alloca %"variant[]", align 8 + %varargslots45 = alloca [1 x %variant], align 16 store i32 1, i32* %a, align 4 store i64 0, i64* %a.f, align 8 store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %a.f, align 8 @@ -81,12 +81,12 @@ after_assign: ; preds = %entry br label %testblock testblock: ; preds = %after_assign - %0 = load i64, i64* %a.f, align 8 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %a.f, align 8 + %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 @@ -94,34 +94,34 @@ after_check: ; preds = %testblock br label %end_block end_block: ; preds = %after_check, %assign_optional - %1 = load i64, i64* %err, align 8 - %neq = icmp ne i64 %1, 0 + %0 = load i64, i64* %err, align 8 + %neq = icmp ne i64 %0, 0 br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i32 0, i32 0), i64 13 }, %"char[]"* %taddr, align 8 - %2 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0 - %lo = load i8*, i8** %3, align 8 - %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1 - %hi = load i64, i64* %4, align 8 - %5 = bitcast i64* %err to i8* - %6 = insertvalue %variant undef, i8* %5, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %7, %variant* %8, align 16 - %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %9, align 8 - %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %11 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %11, %variant** %10, align 8 - %12 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0 - %lo1 = load i8*, i8** %13, align 8 - %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1 - %hi2 = load i64, i64* %14, align 8 - %15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) - %not_err3 = icmp eq i64 %15, 0 + %1 = bitcast %"char[]"* %taddr to { i8*, i64 }* + %2 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 0 + %lo = load i8*, i8** %2, align 8 + %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %1, i32 0, i32 1 + %hi = load i64, i64* %3, align 8 + %4 = bitcast i64* %err to i8* + %5 = insertvalue %variant undef, i8* %4, 0 + %6 = insertvalue %variant %5, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %7 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %6, %variant* %7, align 16 + %8 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 + store i64 1, i64* %8, align 8 + %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 + %10 = bitcast [1 x %variant]* %varargslots to %variant* + store %variant* %10, %variant** %9, align 8 + %11 = bitcast %"variant[]"* %vararg to { i8*, i64 }* + %12 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 0 + %lo1 = load i8*, i8** %12, align 8 + %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %11, i32 0, i32 1 + %hi2 = load i64, i64* %13, align 8 + %14 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo1, i64 %hi2) + %not_err3 = icmp eq i64 %14, 0 br i1 %not_err3, label %after_check4, label %voiderr after_check4: ; preds = %if.then @@ -134,124 +134,124 @@ if.exit: ; preds = %voiderr, %end_block br label %testblock6 testblock6: ; preds = %if.exit - %16 = load i64, i64* %b.f, align 8 - %not_err7 = icmp eq i64 %16, 0 - br i1 %not_err7, label %after_check9, label %assign_optional8 + %optval7 = load i64, i64* %b.f, align 8 + %not_err8 = icmp eq i64 %optval7, 0 + br i1 %not_err8, label %after_check10, label %assign_optional9 -assign_optional8: ; preds = %testblock6 - store i64 %16, i64* %err5, align 8 - br label %end_block10 +assign_optional9: ; preds = %testblock6 + store i64 %optval7, i64* %err5, align 8 + br label %end_block11 -after_check9: ; preds = %testblock6 +after_check10: ; preds = %testblock6 store i64 0, i64* %err5, align 8 - br label %end_block10 + br label %end_block11 -end_block10: ; preds = %after_check9, %assign_optional8 - %17 = load i64, i64* %err5, align 8 - %neq11 = icmp ne i64 %17, 0 - br i1 %neq11, label %if.then12, label %if.exit24 +end_block11: ; preds = %after_check10, %assign_optional9 + %15 = load i64, i64* %err5, align 8 + %neq12 = icmp ne i64 %15, 0 + br i1 %neq12, label %if.then13, label %if.exit25 -if.then12: ; preds = %end_block10 - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i32 0, i32 0), i64 13 }, %"char[]"* %taddr14, align 8 - %18 = bitcast %"char[]"* %taddr14 to { i8*, i64 }* - %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 0 - %lo15 = load i8*, i8** %19, align 8 - %20 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %18, i32 0, i32 1 - %hi16 = load i64, i64* %20, align 8 - %21 = bitcast i64* %err5 to i8* - %22 = insertvalue %variant undef, i8* %21, 0 - %23 = insertvalue %variant %22, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %24 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots18, i64 0, i64 0 - store %variant %23, %variant* %24, align 16 - %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg17, i32 0, i32 1 - store i64 1, i64* %25, align 8 - %26 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg17, i32 0, i32 0 - %27 = bitcast [1 x %variant]* %varargslots18 to %variant* - store %variant* %27, %variant** %26, align 8 - %28 = bitcast %"variant[]"* %vararg17 to { i8*, i64 }* - %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 0 - %lo19 = load i8*, i8** %29, align 8 - %30 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %28, i32 0, i32 1 - %hi20 = load i64, i64* %30, align 8 - %31 = call i64 @std_io_printfln(i64* %retparam13, i8* %lo15, i64 %hi16, i8* %lo19, i64 %hi20) - %not_err21 = icmp eq i64 %31, 0 - br i1 %not_err21, label %after_check22, label %voiderr23 +if.then13: ; preds = %end_block11 + store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.1, i32 0, i32 0), i64 13 }, %"char[]"* %taddr15, align 8 + %16 = bitcast %"char[]"* %taddr15 to { i8*, i64 }* + %17 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 0 + %lo16 = load i8*, i8** %17, align 8 + %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %16, i32 0, i32 1 + %hi17 = load i64, i64* %18, align 8 + %19 = bitcast i64* %err5 to i8* + %20 = insertvalue %variant undef, i8* %19, 0 + %21 = insertvalue %variant %20, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %22 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots19, i64 0, i64 0 + store %variant %21, %variant* %22, align 16 + %23 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg18, i32 0, i32 1 + store i64 1, i64* %23, align 8 + %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg18, i32 0, i32 0 + %25 = bitcast [1 x %variant]* %varargslots19 to %variant* + store %variant* %25, %variant** %24, align 8 + %26 = bitcast %"variant[]"* %vararg18 to { i8*, i64 }* + %27 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 0 + %lo20 = load i8*, i8** %27, align 8 + %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %26, i32 0, i32 1 + %hi21 = load i64, i64* %28, align 8 + %29 = call i64 @std_io_printfln(i64* %retparam14, i8* %lo16, i64 %hi17, i8* %lo20, i64 %hi21) + %not_err22 = icmp eq i64 %29, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check22: ; preds = %if.then12 - br label %voiderr23 +after_check23: ; preds = %if.then13 + br label %voiderr24 -voiderr23: ; preds = %after_check22, %if.then12 - br label %if.exit24 +voiderr24: ; preds = %after_check23, %if.then13 + br label %if.exit25 -if.exit24: ; preds = %voiderr23, %end_block10 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i64 9 }, %"char[]"* %taddr26, align 8 - %32 = bitcast %"char[]"* %taddr26 to { i8*, i64 }* - %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 0 - %lo27 = load i8*, i8** %33, align 8 - %34 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %32, i32 0, i32 1 - %hi28 = load i64, i64* %34, align 8 - %35 = load i64, i64* %a.f, align 8 - %not_err31 = icmp eq i64 %35, 0 - br i1 %not_err31, label %after_check32, label %voiderr37 +if.exit25: ; preds = %voiderr24, %end_block11 + store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i64 9 }, %"char[]"* %taddr27, align 8 + %30 = bitcast %"char[]"* %taddr27 to { i8*, i64 }* + %31 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 0 + %lo28 = load i8*, i8** %31, align 8 + %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 1 + %hi29 = load i64, i64* %32, align 8 + %optval32 = load i64, i64* %a.f, align 8 + %not_err33 = icmp eq i64 %optval32, 0 + br i1 %not_err33, label %after_check34, label %voiderr39 -after_check32: ; preds = %if.exit24 - %36 = bitcast i32* %a to i8* - %37 = insertvalue %variant undef, i8* %36, 0 - %38 = insertvalue %variant %37, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %39 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots30, i64 0, i64 0 - store %variant %38, %variant* %39, align 16 - %40 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg29, i32 0, i32 1 - store i64 1, i64* %40, align 8 - %41 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg29, i32 0, i32 0 - %42 = bitcast [1 x %variant]* %varargslots30 to %variant* - store %variant* %42, %variant** %41, align 8 - %43 = bitcast %"variant[]"* %vararg29 to { i8*, i64 }* - %44 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 0 - %lo33 = load i8*, i8** %44, align 8 - %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %43, i32 0, i32 1 - %hi34 = load i64, i64* %45, align 8 - %46 = call i64 @std_io_printfln(i64* %retparam25, i8* %lo27, i64 %hi28, i8* %lo33, i64 %hi34) - %not_err35 = icmp eq i64 %46, 0 - br i1 %not_err35, label %after_check36, label %voiderr37 +after_check34: ; preds = %if.exit25 + %33 = bitcast i32* %a to i8* + %34 = insertvalue %variant undef, i8* %33, 0 + %35 = insertvalue %variant %34, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %36 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots31, i64 0, i64 0 + store %variant %35, %variant* %36, align 16 + %37 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg30, i32 0, i32 1 + store i64 1, i64* %37, align 8 + %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg30, i32 0, i32 0 + %39 = bitcast [1 x %variant]* %varargslots31 to %variant* + store %variant* %39, %variant** %38, align 8 + %40 = bitcast %"variant[]"* %vararg30 to { i8*, i64 }* + %41 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %40, i32 0, i32 0 + %lo35 = load i8*, i8** %41, align 8 + %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %40, i32 0, i32 1 + %hi36 = load i64, i64* %42, align 8 + %43 = call i64 @std_io_printfln(i64* %retparam26, i8* %lo28, i64 %hi29, i8* %lo35, i64 %hi36) + %not_err37 = icmp eq i64 %43, 0 + br i1 %not_err37, label %after_check38, label %voiderr39 -after_check36: ; preds = %after_check32 - br label %voiderr37 +after_check38: ; preds = %after_check34 + br label %voiderr39 -voiderr37: ; preds = %after_check36, %after_check32, %if.exit24 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i32 0, i32 0), i64 9 }, %"char[]"* %taddr39, align 8 - %47 = bitcast %"char[]"* %taddr39 to { i8*, i64 }* - %48 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 0 - %lo40 = load i8*, i8** %48, align 8 - %49 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %47, i32 0, i32 1 - %hi41 = load i64, i64* %49, align 8 - %50 = load i64, i64* %b.f, align 8 - %not_err44 = icmp eq i64 %50, 0 - br i1 %not_err44, label %after_check45, label %voiderr50 +voiderr39: ; preds = %after_check38, %after_check34, %if.exit25 + store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i32 0, i32 0), i64 9 }, %"char[]"* %taddr41, align 8 + %44 = bitcast %"char[]"* %taddr41 to { i8*, i64 }* + %45 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 0 + %lo42 = load i8*, i8** %45, align 8 + %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %44, i32 0, i32 1 + %hi43 = load i64, i64* %46, align 8 + %optval46 = load i64, i64* %b.f, align 8 + %not_err47 = icmp eq i64 %optval46, 0 + br i1 %not_err47, label %after_check48, label %voiderr53 -after_check45: ; preds = %voiderr37 - %51 = bitcast i32* %b to i8* - %52 = insertvalue %variant undef, i8* %51, 0 - %53 = insertvalue %variant %52, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %54 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots43, i64 0, i64 0 - store %variant %53, %variant* %54, align 16 - %55 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg42, i32 0, i32 1 - store i64 1, i64* %55, align 8 - %56 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg42, i32 0, i32 0 - %57 = bitcast [1 x %variant]* %varargslots43 to %variant* - store %variant* %57, %variant** %56, align 8 - %58 = bitcast %"variant[]"* %vararg42 to { i8*, i64 }* - %59 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 0 - %lo46 = load i8*, i8** %59, align 8 - %60 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %58, i32 0, i32 1 - %hi47 = load i64, i64* %60, align 8 - %61 = call i64 @std_io_printfln(i64* %retparam38, i8* %lo40, i64 %hi41, i8* %lo46, i64 %hi47) - %not_err48 = icmp eq i64 %61, 0 - br i1 %not_err48, label %after_check49, label %voiderr50 +after_check48: ; preds = %voiderr39 + %47 = bitcast i32* %b to i8* + %48 = insertvalue %variant undef, i8* %47, 0 + %49 = insertvalue %variant %48, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %50 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots45, i64 0, i64 0 + store %variant %49, %variant* %50, align 16 + %51 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 1 + store i64 1, i64* %51, align 8 + %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg44, i32 0, i32 0 + %53 = bitcast [1 x %variant]* %varargslots45 to %variant* + store %variant* %53, %variant** %52, align 8 + %54 = bitcast %"variant[]"* %vararg44 to { i8*, i64 }* + %55 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 0 + %lo49 = load i8*, i8** %55, align 8 + %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %54, i32 0, i32 1 + %hi50 = load i64, i64* %56, align 8 + %57 = call i64 @std_io_printfln(i64* %retparam40, i8* %lo42, i64 %hi43, i8* %lo49, i64 %hi50) + %not_err51 = icmp eq i64 %57, 0 + br i1 %not_err51, label %after_check52, label %voiderr53 -after_check49: ; preds = %after_check45 - br label %voiderr50 +after_check52: ; preds = %after_check48 + br label %voiderr53 -voiderr50: ; preds = %after_check49, %after_check45, %voiderr37 +voiderr53: ; preds = %after_check52, %after_check48, %voiderr39 ret void } @@ -269,33 +269,33 @@ entry: %taddr = alloca %"char[]", align 8 %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err9 = alloca i64, align 8 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [1 x %variant], align 16 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [1 x %variant], align 16 - %retparam42 = alloca i64, align 8 - %taddr43 = alloca %"char[]", align 8 - %vararg46 = alloca %"variant[]", align 8 - %varargslots47 = alloca [1 x %variant], align 16 + %err10 = alloca i64, align 8 + %retparam19 = alloca i64, align 8 + %taddr20 = alloca %"char[]", align 8 + %vararg23 = alloca %"variant[]", align 8 + %varargslots24 = alloca [1 x %variant], align 16 + %retparam31 = alloca i64, align 8 + %taddr32 = alloca %"char[]", align 8 + %vararg35 = alloca %"variant[]", align 8 + %varargslots36 = alloca [1 x %variant], align 16 + %retparam45 = alloca i64, align 8 + %taddr46 = alloca %"char[]", align 8 + %vararg49 = alloca %"variant[]", align 8 + %varargslots50 = alloca [1 x %variant], align 16 store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %x.f, align 8 store i32 1, i32* %a, align 4 store i64 0, i64* %a.f, align 8 - %0 = load i64, i64* %x.f, align 8 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %x.f, align 8 + %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* %a.f, align 8 + store i64 %optval, i64* %a.f, align 8 br label %optional_assign_jump after_check: ; preds = %entry - %1 = load i32, i32* %x, align 4 - store i32 %1, i32* %a, align 4 + %0 = load i32, i32* %x, align 4 + store i32 %0, i32* %a, align 4 store i64 0, i64* %a.f, align 8 br label %after_assign @@ -305,7 +305,7 @@ optional_assign_jump: ; preds = %assign_optional br label %after_assign1 after_assign: ; preds = %after_check - store i32 %1, i32* %b, align 4 + store i32 %0, i32* %b, align 4 store i64 0, i64* %b.f, align 8 br label %after_assign1 @@ -313,177 +313,177 @@ after_assign1: ; preds = %after_assign, %opti br label %testblock testblock: ; preds = %after_assign1 - %2 = load i64, i64* %a.f, align 8 - %not_err2 = icmp eq i64 %2, 0 - br i1 %not_err2, label %after_check4, label %assign_optional3 + %optval2 = load i64, i64* %a.f, align 8 + %not_err3 = icmp eq i64 %optval2, 0 + br i1 %not_err3, label %after_check5, label %assign_optional4 -assign_optional3: ; preds = %testblock - store i64 %2, i64* %err, align 8 +assign_optional4: ; preds = %testblock + store i64 %optval2, i64* %err, align 8 br label %end_block -after_check4: ; preds = %testblock +after_check5: ; preds = %testblock store i64 0, i64* %err, align 8 br label %end_block -end_block: ; preds = %after_check4, %assign_optional3 - %3 = load i64, i64* %err, align 8 - %neq = icmp ne i64 %3, 0 +end_block: ; preds = %after_check5, %assign_optional4 + %1 = load i64, i64* %err, align 8 + %neq = icmp ne i64 %1, 0 br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i32 0, i32 0), i64 13 }, %"char[]"* %taddr, align 8 - %4 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %5 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 0 - %lo = load i8*, i8** %5, align 8 - %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 1 - %hi = load i64, i64* %6, align 8 - %7 = bitcast i64* %err to i8* - %8 = insertvalue %variant undef, i8* %7, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %10 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %9, %variant* %10, align 16 - %11 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %11, align 8 - %12 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %13 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %13, %variant** %12, align 8 - %14 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 0 - %lo5 = load i8*, i8** %15, align 8 - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 1 - %hi6 = load i64, i64* %16, align 8 - %17 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo5, i64 %hi6) - %not_err7 = icmp eq i64 %17, 0 - br i1 %not_err7, label %after_check8, label %voiderr + %2 = bitcast %"char[]"* %taddr to { i8*, i64 }* + %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0 + %lo = load i8*, i8** %3, align 8 + %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1 + %hi = load i64, i64* %4, align 8 + %5 = bitcast i64* %err to i8* + %6 = insertvalue %variant undef, i8* %5, 0 + %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %7, %variant* %8, align 16 + %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 + store i64 1, i64* %9, align 8 + %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 + %11 = bitcast [1 x %variant]* %varargslots to %variant* + store %variant* %11, %variant** %10, align 8 + %12 = bitcast %"variant[]"* %vararg to { i8*, i64 }* + %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0 + %lo6 = load i8*, i8** %13, align 8 + %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1 + %hi7 = load i64, i64* %14, align 8 + %15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %15, 0 + 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 - %18 = load i64, i64* %b.f, align 8 - %not_err11 = icmp eq i64 %18, 0 - br i1 %not_err11, label %after_check13, label %assign_optional12 +testblock11: ; preds = %if.exit + %optval12 = load i64, i64* %b.f, align 8 + %not_err13 = icmp eq i64 %optval12, 0 + br i1 %not_err13, label %after_check15, label %assign_optional14 -assign_optional12: ; preds = %testblock10 - store i64 %18, i64* %err9, align 8 - br label %end_block14 +assign_optional14: ; preds = %testblock11 + store i64 %optval12, i64* %err10, align 8 + br label %end_block16 -after_check13: ; preds = %testblock10 - store i64 0, i64* %err9, align 8 - br label %end_block14 +after_check15: ; preds = %testblock11 + store i64 0, i64* %err10, align 8 + br label %end_block16 -end_block14: ; preds = %after_check13, %assign_optional12 - %19 = load i64, i64* %err9, align 8 - %neq15 = icmp ne i64 %19, 0 - br i1 %neq15, label %if.then16, label %if.exit28 +end_block16: ; preds = %after_check15, %assign_optional14 + %16 = load i64, i64* %err10, align 8 + %neq17 = icmp ne i64 %16, 0 + br i1 %neq17, label %if.then18, label %if.exit30 -if.then16: ; preds = %end_block14 - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i32 0, i32 0), i64 13 }, %"char[]"* %taddr18, align 8 - %20 = bitcast %"char[]"* %taddr18 to { i8*, i64 }* - %21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 0 - %lo19 = load i8*, i8** %21, align 8 - %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 1 - %hi20 = load i64, i64* %22, align 8 - %23 = bitcast i64* %err9 to i8* - %24 = insertvalue %variant undef, i8* %23, 0 - %25 = insertvalue %variant %24, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %26 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots22, i64 0, i64 0 - store %variant %25, %variant* %26, align 16 - %27 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 1 - store i64 1, i64* %27, align 8 - %28 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 0 - %29 = bitcast [1 x %variant]* %varargslots22 to %variant* - store %variant* %29, %variant** %28, align 8 - %30 = bitcast %"variant[]"* %vararg21 to { i8*, i64 }* - %31 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 0 - %lo23 = load i8*, i8** %31, align 8 - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 1 - %hi24 = load i64, i64* %32, align 8 - %33 = call i64 @std_io_printfln(i64* %retparam17, i8* %lo19, i64 %hi20, i8* %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %33, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +if.then18: ; preds = %end_block16 + store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i32 0, i32 0), i64 13 }, %"char[]"* %taddr20, align 8 + %17 = bitcast %"char[]"* %taddr20 to { i8*, i64 }* + %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 + %lo21 = load i8*, i8** %18, align 8 + %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 + %hi22 = load i64, i64* %19, align 8 + %20 = bitcast i64* %err10 to i8* + %21 = insertvalue %variant undef, i8* %20, 0 + %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %23 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0 + store %variant %22, %variant* %23, align 16 + %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1 + store i64 1, i64* %24, align 8 + %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0 + %26 = bitcast [1 x %variant]* %varargslots24 to %variant* + store %variant* %26, %variant** %25, align 8 + %27 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }* + %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 + %lo25 = load i8*, i8** %28, align 8 + %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 + %hi26 = load i64, i64* %29, align 8 + %30 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26) + %not_err27 = icmp eq i64 %30, 0 + br i1 %not_err27, label %after_check28, label %voiderr29 -after_check26: ; preds = %if.then16 - br label %voiderr27 +after_check28: ; preds = %if.then18 + br label %voiderr29 -voiderr27: ; preds = %after_check26, %if.then16 - br label %if.exit28 +voiderr29: ; preds = %after_check28, %if.then18 + br label %if.exit30 -if.exit28: ; preds = %voiderr27, %end_block14 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0), i64 9 }, %"char[]"* %taddr30, align 8 - %34 = bitcast %"char[]"* %taddr30 to { i8*, i64 }* - %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 0 - %lo31 = load i8*, i8** %35, align 8 - %36 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 1 - %hi32 = load i64, i64* %36, align 8 - %37 = load i64, i64* %a.f, align 8 - %not_err35 = icmp eq i64 %37, 0 - br i1 %not_err35, label %after_check36, label %voiderr41 +if.exit30: ; preds = %voiderr29, %end_block16 + store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i32 0, i32 0), i64 9 }, %"char[]"* %taddr32, align 8 + %31 = bitcast %"char[]"* %taddr32 to { i8*, i64 }* + %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 + %lo33 = load i8*, i8** %32, align 8 + %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 + %hi34 = load i64, i64* %33, align 8 + %optval37 = load i64, i64* %a.f, align 8 + %not_err38 = icmp eq i64 %optval37, 0 + br i1 %not_err38, label %after_check39, label %voiderr44 -after_check36: ; preds = %if.exit28 - %38 = bitcast i32* %a to i8* - %39 = insertvalue %variant undef, i8* %38, 0 - %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %41 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots34, i64 0, i64 0 - store %variant %40, %variant* %41, align 16 - %42 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 1 - store i64 1, i64* %42, align 8 - %43 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 0 - %44 = bitcast [1 x %variant]* %varargslots34 to %variant* - store %variant* %44, %variant** %43, align 8 - %45 = bitcast %"variant[]"* %vararg33 to { i8*, i64 }* +after_check39: ; preds = %if.exit30 + %34 = bitcast i32* %a to i8* + %35 = insertvalue %variant undef, i8* %34, 0 + %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %37 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots36, i64 0, i64 0 + store %variant %36, %variant* %37, align 16 + %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 1 + store i64 1, i64* %38, align 8 + %39 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 0 + %40 = bitcast [1 x %variant]* %varargslots36 to %variant* + store %variant* %40, %variant** %39, align 8 + %41 = bitcast %"variant[]"* %vararg35 to { i8*, i64 }* + %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 + %lo40 = load i8*, i8** %42, align 8 + %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 + %hi41 = load i64, i64* %43, align 8 + %44 = call i64 @std_io_printfln(i64* %retparam31, i8* %lo33, i64 %hi34, i8* %lo40, i64 %hi41) + %not_err42 = icmp eq i64 %44, 0 + br i1 %not_err42, label %after_check43, label %voiderr44 + +after_check43: ; preds = %after_check39 + br label %voiderr44 + +voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 + store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i32 0, i32 0), i64 9 }, %"char[]"* %taddr46, align 8 + %45 = bitcast %"char[]"* %taddr46 to { i8*, i64 }* %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 - %lo37 = load i8*, i8** %46, align 8 + %lo47 = load i8*, i8** %46, align 8 %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 - %hi38 = load i64, i64* %47, align 8 - %48 = call i64 @std_io_printfln(i64* %retparam29, i8* %lo31, i64 %hi32, i8* %lo37, i64 %hi38) - %not_err39 = icmp eq i64 %48, 0 - br i1 %not_err39, label %after_check40, label %voiderr41 + %hi48 = load i64, i64* %47, align 8 + %optval51 = load i64, i64* %b.f, align 8 + %not_err52 = icmp eq i64 %optval51, 0 + br i1 %not_err52, label %after_check53, label %voiderr58 -after_check40: ; preds = %after_check36 - br label %voiderr41 +after_check53: ; preds = %voiderr44 + %48 = bitcast i32* %b to i8* + %49 = insertvalue %variant undef, i8* %48, 0 + %50 = insertvalue %variant %49, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %51 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots50, i64 0, i64 0 + store %variant %50, %variant* %51, align 16 + %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 1 + store i64 1, i64* %52, align 8 + %53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 0 + %54 = bitcast [1 x %variant]* %varargslots50 to %variant* + store %variant* %54, %variant** %53, align 8 + %55 = bitcast %"variant[]"* %vararg49 to { i8*, i64 }* + %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 0 + %lo54 = load i8*, i8** %56, align 8 + %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 1 + %hi55 = load i64, i64* %57, align 8 + %58 = call i64 @std_io_printfln(i64* %retparam45, i8* %lo47, i64 %hi48, i8* %lo54, i64 %hi55) + %not_err56 = icmp eq i64 %58, 0 + br i1 %not_err56, label %after_check57, label %voiderr58 -voiderr41: ; preds = %after_check40, %after_check36, %if.exit28 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.7, i32 0, i32 0), i64 9 }, %"char[]"* %taddr43, align 8 - %49 = bitcast %"char[]"* %taddr43 to { i8*, i64 }* - %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 0 - %lo44 = load i8*, i8** %50, align 8 - %51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 1 - %hi45 = load i64, i64* %51, align 8 - %52 = load i64, i64* %b.f, align 8 - %not_err48 = icmp eq i64 %52, 0 - br i1 %not_err48, label %after_check49, label %voiderr54 +after_check57: ; preds = %after_check53 + br label %voiderr58 -after_check49: ; preds = %voiderr41 - %53 = bitcast i32* %b to i8* - %54 = insertvalue %variant undef, i8* %53, 0 - %55 = insertvalue %variant %54, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %56 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots47, i64 0, i64 0 - store %variant %55, %variant* %56, align 16 - %57 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg46, i32 0, i32 1 - store i64 1, i64* %57, align 8 - %58 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg46, i32 0, i32 0 - %59 = bitcast [1 x %variant]* %varargslots47 to %variant* - store %variant* %59, %variant** %58, align 8 - %60 = bitcast %"variant[]"* %vararg46 to { i8*, i64 }* - %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0 - %lo50 = load i8*, i8** %61, align 8 - %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1 - %hi51 = load i64, i64* %62, align 8 - %63 = call i64 @std_io_printfln(i64* %retparam42, i8* %lo44, i64 %hi45, i8* %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %63, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 - -after_check53: ; preds = %after_check49 - br label %voiderr54 - -voiderr54: ; preds = %after_check53, %after_check49, %voiderr41 +voiderr58: ; preds = %after_check57, %after_check53, %voiderr44 ret void } @@ -501,34 +501,34 @@ entry: %taddr = alloca %"char[]", align 8 %vararg = alloca %"variant[]", align 8 %varargslots = alloca [1 x %variant], align 16 - %err9 = alloca i64, align 8 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [1 x %variant], align 16 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [1 x %variant], align 16 - %retparam42 = alloca i64, align 8 - %taddr43 = alloca %"char[]", align 8 - %vararg46 = alloca %"variant[]", align 8 - %varargslots47 = alloca [1 x %variant], align 16 + %err10 = alloca i64, align 8 + %retparam19 = alloca i64, align 8 + %taddr20 = alloca %"char[]", align 8 + %vararg23 = alloca %"variant[]", align 8 + %varargslots24 = alloca [1 x %variant], align 16 + %retparam31 = alloca i64, align 8 + %taddr32 = alloca %"char[]", align 8 + %vararg35 = alloca %"variant[]", align 8 + %varargslots36 = alloca [1 x %variant], align 16 + %retparam45 = alloca i64, align 8 + %taddr46 = alloca %"char[]", align 8 + %vararg49 = alloca %"variant[]", align 8 + %varargslots50 = alloca [1 x %variant], align 16 store i32 23, i32* %x, align 4 store i64 0, i64* %x.f, align 8 store i32 1, i32* %a, align 4 store i64 0, i64* %a.f, align 8 - %0 = load i64, i64* %x.f, align 8 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %x.f, align 8 + %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* %a.f, align 8 + store i64 %optval, i64* %a.f, align 8 br label %optional_assign_jump after_check: ; preds = %entry - %1 = load i32, i32* %x, align 4 - store i32 %1, i32* %a, align 4 + %0 = load i32, i32* %x, align 4 + store i32 %0, i32* %a, align 4 store i64 0, i64* %a.f, align 8 br label %after_assign @@ -538,7 +538,7 @@ optional_assign_jump: ; preds = %assign_optional br label %after_assign1 after_assign: ; preds = %after_check - store i32 %1, i32* %b, align 4 + store i32 %0, i32* %b, align 4 store i64 0, i64* %b.f, align 8 br label %after_assign1 @@ -546,177 +546,176 @@ after_assign1: ; preds = %after_assign, %opti br label %testblock testblock: ; preds = %after_assign1 - %2 = load i64, i64* %a.f, align 8 - %not_err2 = icmp eq i64 %2, 0 - br i1 %not_err2, label %after_check4, label %assign_optional3 + %optval2 = load i64, i64* %a.f, align 8 + %not_err3 = icmp eq i64 %optval2, 0 + br i1 %not_err3, label %after_check5, label %assign_optional4 -assign_optional3: ; preds = %testblock - store i64 %2, i64* %err, align 8 +assign_optional4: ; preds = %testblock + store i64 %optval2, i64* %err, align 8 br label %end_block -after_check4: ; preds = %testblock +after_check5: ; preds = %testblock store i64 0, i64* %err, align 8 br label %end_block -end_block: ; preds = %after_check4, %assign_optional3 - %3 = load i64, i64* %err, align 8 - %neq = icmp ne i64 %3, 0 +end_block: ; preds = %after_check5, %assign_optional4 + %1 = load i64, i64* %err, align 8 + %neq = icmp ne i64 %1, 0 br i1 %neq, label %if.then, label %if.exit if.then: ; preds = %end_block store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i32 0, i32 0), i64 13 }, %"char[]"* %taddr, align 8 - %4 = bitcast %"char[]"* %taddr to { i8*, i64 }* - %5 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 0 - %lo = load i8*, i8** %5, align 8 - %6 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %4, i32 0, i32 1 - %hi = load i64, i64* %6, align 8 - %7 = bitcast i64* %err to i8* - %8 = insertvalue %variant undef, i8* %7, 0 - %9 = insertvalue %variant %8, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %10 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 - store %variant %9, %variant* %10, align 16 - %11 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 - store i64 1, i64* %11, align 8 - %12 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 - %13 = bitcast [1 x %variant]* %varargslots to %variant* - store %variant* %13, %variant** %12, align 8 - %14 = bitcast %"variant[]"* %vararg to { i8*, i64 }* - %15 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 0 - %lo5 = load i8*, i8** %15, align 8 - %16 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %14, i32 0, i32 1 - %hi6 = load i64, i64* %16, align 8 - %17 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo5, i64 %hi6) - %not_err7 = icmp eq i64 %17, 0 - br i1 %not_err7, label %after_check8, label %voiderr + %2 = bitcast %"char[]"* %taddr to { i8*, i64 }* + %3 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 0 + %lo = load i8*, i8** %3, align 8 + %4 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %2, i32 0, i32 1 + %hi = load i64, i64* %4, align 8 + %5 = bitcast i64* %err to i8* + %6 = insertvalue %variant undef, i8* %5, 0 + %7 = insertvalue %variant %6, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %8 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots, i64 0, i64 0 + store %variant %7, %variant* %8, align 16 + %9 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 1 + store i64 1, i64* %9, align 8 + %10 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg, i32 0, i32 0 + %11 = bitcast [1 x %variant]* %varargslots to %variant* + store %variant* %11, %variant** %10, align 8 + %12 = bitcast %"variant[]"* %vararg to { i8*, i64 }* + %13 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 0 + %lo6 = load i8*, i8** %13, align 8 + %14 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %12, i32 0, i32 1 + %hi7 = load i64, i64* %14, align 8 + %15 = call i64 @std_io_printfln(i64* %retparam, i8* %lo, i64 %hi, i8* %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %15, 0 + 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 - %18 = load i64, i64* %b.f, align 8 - %not_err11 = icmp eq i64 %18, 0 - br i1 %not_err11, label %after_check13, label %assign_optional12 +testblock11: ; preds = %if.exit + %optval12 = load i64, i64* %b.f, align 8 + %not_err13 = icmp eq i64 %optval12, 0 + br i1 %not_err13, label %after_check15, label %assign_optional14 -assign_optional12: ; preds = %testblock10 - store i64 %18, i64* %err9, align 8 - br label %end_block14 +assign_optional14: ; preds = %testblock11 + store i64 %optval12, i64* %err10, align 8 + br label %end_block16 -after_check13: ; preds = %testblock10 - store i64 0, i64* %err9, align 8 - br label %end_block14 +after_check15: ; preds = %testblock11 + store i64 0, i64* %err10, align 8 + br label %end_block16 -end_block14: ; preds = %after_check13, %assign_optional12 - %19 = load i64, i64* %err9, align 8 - %neq15 = icmp ne i64 %19, 0 - br i1 %neq15, label %if.then16, label %if.exit28 +end_block16: ; preds = %after_check15, %assign_optional14 + %16 = load i64, i64* %err10, align 8 + %neq17 = icmp ne i64 %16, 0 + br i1 %neq17, label %if.then18, label %if.exit30 -if.then16: ; preds = %end_block14 - store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.9, i32 0, i32 0), i64 13 }, %"char[]"* %taddr18, align 8 - %20 = bitcast %"char[]"* %taddr18 to { i8*, i64 }* - %21 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 0 - %lo19 = load i8*, i8** %21, align 8 - %22 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %20, i32 0, i32 1 - %hi20 = load i64, i64* %22, align 8 - %23 = bitcast i64* %err9 to i8* - %24 = insertvalue %variant undef, i8* %23, 0 - %25 = insertvalue %variant %24, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 - %26 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots22, i64 0, i64 0 - store %variant %25, %variant* %26, align 16 - %27 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 1 - store i64 1, i64* %27, align 8 - %28 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg21, i32 0, i32 0 - %29 = bitcast [1 x %variant]* %varargslots22 to %variant* - store %variant* %29, %variant** %28, align 8 - %30 = bitcast %"variant[]"* %vararg21 to { i8*, i64 }* - %31 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 0 - %lo23 = load i8*, i8** %31, align 8 - %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %30, i32 0, i32 1 - %hi24 = load i64, i64* %32, align 8 - %33 = call i64 @std_io_printfln(i64* %retparam17, i8* %lo19, i64 %hi20, i8* %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %33, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +if.then18: ; preds = %end_block16 + store %"char[]" { i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.9, i32 0, i32 0), i64 13 }, %"char[]"* %taddr20, align 8 + %17 = bitcast %"char[]"* %taddr20 to { i8*, i64 }* + %18 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 0 + %lo21 = load i8*, i8** %18, align 8 + %19 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %17, i32 0, i32 1 + %hi22 = load i64, i64* %19, align 8 + %20 = bitcast i64* %err10 to i8* + %21 = insertvalue %variant undef, i8* %20, 0 + %22 = insertvalue %variant %21, i64 ptrtoint (%.introspect* @"ct$anyerr" to i64), 1 + %23 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots24, i64 0, i64 0 + store %variant %22, %variant* %23, align 16 + %24 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 1 + store i64 1, i64* %24, align 8 + %25 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg23, i32 0, i32 0 + %26 = bitcast [1 x %variant]* %varargslots24 to %variant* + store %variant* %26, %variant** %25, align 8 + %27 = bitcast %"variant[]"* %vararg23 to { i8*, i64 }* + %28 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 0 + %lo25 = load i8*, i8** %28, align 8 + %29 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %27, i32 0, i32 1 + %hi26 = load i64, i64* %29, align 8 + %30 = call i64 @std_io_printfln(i64* %retparam19, i8* %lo21, i64 %hi22, i8* %lo25, i64 %hi26) + %not_err27 = icmp eq i64 %30, 0 + br i1 %not_err27, label %after_check28, label %voiderr29 -after_check26: ; preds = %if.then16 - br label %voiderr27 +after_check28: ; preds = %if.then18 + br label %voiderr29 -voiderr27: ; preds = %after_check26, %if.then16 - br label %if.exit28 +voiderr29: ; preds = %after_check28, %if.then18 + br label %if.exit30 -if.exit28: ; preds = %voiderr27, %end_block14 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i32 0, i32 0), i64 9 }, %"char[]"* %taddr30, align 8 - %34 = bitcast %"char[]"* %taddr30 to { i8*, i64 }* - %35 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 0 - %lo31 = load i8*, i8** %35, align 8 - %36 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %34, i32 0, i32 1 - %hi32 = load i64, i64* %36, align 8 - %37 = load i64, i64* %a.f, align 8 - %not_err35 = icmp eq i64 %37, 0 - br i1 %not_err35, label %after_check36, label %voiderr41 +if.exit30: ; preds = %voiderr29, %end_block16 + store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i32 0, i32 0), i64 9 }, %"char[]"* %taddr32, align 8 + %31 = bitcast %"char[]"* %taddr32 to { i8*, i64 }* + %32 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 0 + %lo33 = load i8*, i8** %32, align 8 + %33 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %31, i32 0, i32 1 + %hi34 = load i64, i64* %33, align 8 + %optval37 = load i64, i64* %a.f, align 8 + %not_err38 = icmp eq i64 %optval37, 0 + br i1 %not_err38, label %after_check39, label %voiderr44 -after_check36: ; preds = %if.exit28 - %38 = bitcast i32* %a to i8* - %39 = insertvalue %variant undef, i8* %38, 0 - %40 = insertvalue %variant %39, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %41 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots34, i64 0, i64 0 - store %variant %40, %variant* %41, align 16 - %42 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 1 - store i64 1, i64* %42, align 8 - %43 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg33, i32 0, i32 0 - %44 = bitcast [1 x %variant]* %varargslots34 to %variant* - store %variant* %44, %variant** %43, align 8 - %45 = bitcast %"variant[]"* %vararg33 to { i8*, i64 }* +after_check39: ; preds = %if.exit30 + %34 = bitcast i32* %a to i8* + %35 = insertvalue %variant undef, i8* %34, 0 + %36 = insertvalue %variant %35, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %37 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots36, i64 0, i64 0 + store %variant %36, %variant* %37, align 16 + %38 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 1 + store i64 1, i64* %38, align 8 + %39 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg35, i32 0, i32 0 + %40 = bitcast [1 x %variant]* %varargslots36 to %variant* + store %variant* %40, %variant** %39, align 8 + %41 = bitcast %"variant[]"* %vararg35 to { i8*, i64 }* + %42 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 0 + %lo40 = load i8*, i8** %42, align 8 + %43 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %41, i32 0, i32 1 + %hi41 = load i64, i64* %43, align 8 + %44 = call i64 @std_io_printfln(i64* %retparam31, i8* %lo33, i64 %hi34, i8* %lo40, i64 %hi41) + %not_err42 = icmp eq i64 %44, 0 + br i1 %not_err42, label %after_check43, label %voiderr44 + +after_check43: ; preds = %after_check39 + br label %voiderr44 + +voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 + store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i32 0, i32 0), i64 9 }, %"char[]"* %taddr46, align 8 + %45 = bitcast %"char[]"* %taddr46 to { i8*, i64 }* %46 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 0 - %lo37 = load i8*, i8** %46, align 8 + %lo47 = load i8*, i8** %46, align 8 %47 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %45, i32 0, i32 1 - %hi38 = load i64, i64* %47, align 8 - %48 = call i64 @std_io_printfln(i64* %retparam29, i8* %lo31, i64 %hi32, i8* %lo37, i64 %hi38) - %not_err39 = icmp eq i64 %48, 0 - br i1 %not_err39, label %after_check40, label %voiderr41 + %hi48 = load i64, i64* %47, align 8 + %optval51 = load i64, i64* %b.f, align 8 + %not_err52 = icmp eq i64 %optval51, 0 + br i1 %not_err52, label %after_check53, label %voiderr58 -after_check40: ; preds = %after_check36 - br label %voiderr41 +after_check53: ; preds = %voiderr44 + %48 = bitcast i32* %b to i8* + %49 = insertvalue %variant undef, i8* %48, 0 + %50 = insertvalue %variant %49, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 + %51 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots50, i64 0, i64 0 + store %variant %50, %variant* %51, align 16 + %52 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 1 + store i64 1, i64* %52, align 8 + %53 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg49, i32 0, i32 0 + %54 = bitcast [1 x %variant]* %varargslots50 to %variant* + store %variant* %54, %variant** %53, align 8 + %55 = bitcast %"variant[]"* %vararg49 to { i8*, i64 }* + %56 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 0 + %lo54 = load i8*, i8** %56, align 8 + %57 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %55, i32 0, i32 1 + %hi55 = load i64, i64* %57, align 8 + %58 = call i64 @std_io_printfln(i64* %retparam45, i8* %lo47, i64 %hi48, i8* %lo54, i64 %hi55) + %not_err56 = icmp eq i64 %58, 0 + br i1 %not_err56, label %after_check57, label %voiderr58 -voiderr41: ; preds = %after_check40, %after_check36, %if.exit28 - store %"char[]" { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.11, i32 0, i32 0), i64 9 }, %"char[]"* %taddr43, align 8 - %49 = bitcast %"char[]"* %taddr43 to { i8*, i64 }* - %50 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 0 - %lo44 = load i8*, i8** %50, align 8 - %51 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %49, i32 0, i32 1 - %hi45 = load i64, i64* %51, align 8 - %52 = load i64, i64* %b.f, align 8 - %not_err48 = icmp eq i64 %52, 0 - br i1 %not_err48, label %after_check49, label %voiderr54 +after_check57: ; preds = %after_check53 + br label %voiderr58 -after_check49: ; preds = %voiderr41 - %53 = bitcast i32* %b to i8* - %54 = insertvalue %variant undef, i8* %53, 0 - %55 = insertvalue %variant %54, i64 ptrtoint (%.introspect* @"ct$int" to i64), 1 - %56 = getelementptr inbounds [1 x %variant], [1 x %variant]* %varargslots47, i64 0, i64 0 - store %variant %55, %variant* %56, align 16 - %57 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg46, i32 0, i32 1 - store i64 1, i64* %57, align 8 - %58 = getelementptr inbounds %"variant[]", %"variant[]"* %vararg46, i32 0, i32 0 - %59 = bitcast [1 x %variant]* %varargslots47 to %variant* - store %variant* %59, %variant** %58, align 8 - %60 = bitcast %"variant[]"* %vararg46 to { i8*, i64 }* - %61 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 0 - %lo50 = load i8*, i8** %61, align 8 - %62 = getelementptr inbounds { i8*, i64 }, { i8*, i64 }* %60, i32 0, i32 1 - %hi51 = load i64, i64* %62, align 8 - %63 = call i64 @std_io_printfln(i64* %retparam42, i8* %lo44, i64 %hi45, i8* %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %63, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 - -after_check53: ; preds = %after_check49 - br label %voiderr54 - -voiderr54: ; preds = %after_check53, %after_check49, %voiderr41 +voiderr58: ; preds = %after_check57, %after_check53, %voiderr44 ret void -} - +} \ No newline at end of file diff --git a/test/test_suite/errors/failable_inits.c3t b/test/test_suite/errors/failable_inits.c3t index 78cffa07b..4fe593f6c 100644 --- a/test/test_suite/errors/failable_inits.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %x.f, align 8 + %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 - ret i64 %1 + %0 = load i64, i64* %error_var, align 8 + ret i64 %0 noerr_block: ; preds = %after_check - %2 = bitcast %Bar* %y to i8* - %3 = bitcast %Bar* %x to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %2, i8* align 4 %3, i32 4, i1 false) + %1 = bitcast %Bar* %y to i8* + %2 = bitcast %Bar* %x to i8* + 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 - %not_err = icmp eq i64 %1, 0 + %optval = load i64, i64* %x.f, align 8 + %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 - ret i64 %2 + %1 = load i64, i64* %error_var, align 8 + ret i64 %1 noerr_block: ; preds = %after_check - %3 = bitcast %Bar* %y to i8* - %4 = bitcast %Bar* %x to i8* - call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %3, i8* align 4 %4, i32 4, i1 false) + %2 = bitcast %Bar* %y to i8* + %3 = bitcast %Bar* %x to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %2, i8* align 4 %3, i32 4, i1 false) ret i64 0 } diff --git a/test/test_suite/errors/failable_taddr_and_access.c3t b/test/test_suite/errors/failable_taddr_and_access.c3t index de5eb60f8..b50d016a4 100644 --- a/test/test_suite/errors/failable_taddr_and_access.c3t +++ b/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 - %not_err = icmp eq i64 %1, 0 + %optval = load i64, i64* %z.f, align 8 + %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 - store i32 %2, i32* %0, align 4 - %3 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1 - store i32 0, i32* %3, align 4 + %1 = load i32, i32* %z, align 4 + store i32 %1, i32* %0, align 4 + %2 = getelementptr inbounds %Foo, %Foo* %literal, i32 0, i32 1 + 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 - %not_err1 = icmp eq i64 %4, 0 - br i1 %not_err1, label %after_check2, label %voiderr + %optval1 = load i64, i64* %w.f, align 8 + %not_err2 = icmp eq i64 %optval1, 0 + br i1 %not_err2, label %after_check3, label %voiderr -after_check2: ; preds = %after_assign - %5 = load %Foo*, %Foo** %w, align 8 - %6 = getelementptr inbounds %Foo, %Foo* %5, i32 0, i32 0 - %7 = load i32, i32* %6, align 8 - %8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i32 %7) +after_check3: ; preds = %after_assign + %3 = load %Foo*, %Foo** %w, align 8 + %4 = getelementptr inbounds %Foo, %Foo* %3, i32 0, i32 0 + %5 = load i32, i32* %4, align 8 + %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 - %9 = getelementptr inbounds %Foo, %Foo* %literal5, i32 0, i32 0 - %10 = load i64, i64* %z.f, align 8 - %not_err6 = icmp eq i64 %10, 0 - br i1 %not_err6, label %after_check8, label %assign_optional7 +voiderr5: ; preds = %voiderr + %7 = getelementptr inbounds %Foo, %Foo* %literal6, i32 0, i32 0 + %optval7 = load i64, i64* %z.f, align 8 + %not_err8 = icmp eq i64 %optval7, 0 + br i1 %not_err8, label %after_check10, label %assign_optional9 -assign_optional7: ; preds = %voiderr4 - store i64 %10, i64* %w.f, align 8 - br label %after_assign9 +assign_optional9: ; preds = %voiderr5 + store i64 %optval7, i64* %w.f, align 8 + br label %after_assign11 -after_check8: ; preds = %voiderr4 - %11 = load i32, i32* %z, align 4 - store i32 %11, i32* %9, align 4 - %12 = getelementptr inbounds %Foo, %Foo* %literal5, i32 0, i32 1 - store i32 0, i32* %12, align 4 - store %Foo* %literal5, %Foo** %w, align 8 +after_check10: ; preds = %voiderr5 + %8 = load i32, i32* %z, align 4 + store i32 %8, i32* %7, align 4 + %9 = getelementptr inbounds %Foo, %Foo* %literal6, i32 0, i32 1 + store i32 0, i32* %9, align 4 + 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 - br label %voiderr10 +after_assign11: ; preds = %after_check10, %assign_optional9 + br label %voiderr12 -voiderr10: ; preds = %after_assign9 - %13 = load i64, i64* %w.f, align 8 - %not_err11 = icmp eq i64 %13, 0 - br i1 %not_err11, label %after_check12, label %voiderr13 +voiderr12: ; preds = %after_assign11 + %optval13 = load i64, i64* %w.f, align 8 + %not_err14 = icmp eq i64 %optval13, 0 + br i1 %not_err14, label %after_check15, label %voiderr16 -after_check12: ; preds = %voiderr10 - %14 = load %Foo*, %Foo** %w, align 8 - %15 = getelementptr inbounds %Foo, %Foo* %14, i32 0, i32 0 - %16 = load i32, i32* %15, align 8 - %17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i32 0, i32 0), i32 %16) - br label %voiderr13 +after_check15: ; preds = %voiderr12 + %10 = load %Foo*, %Foo** %w, align 8 + %11 = getelementptr inbounds %Foo, %Foo* %10, i32 0, i32 0 + %12 = load i32, i32* %11, align 8 + %13 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i32 0, i32 0), i32 %12) + br label %voiderr16 -voiderr13: ; preds = %after_check12, %voiderr10 +voiderr16: ; preds = %after_check15, %voiderr12 ret void } \ No newline at end of file diff --git a/test/test_suite/errors/or_err_bool.c3t b/test/test_suite/errors/or_err_bool.c3t index 29fccd1ee..26a68c9d7 100644 --- a/test/test_suite/errors/or_err_bool.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %x.f, align 8 + %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 - %2 = trunc i8 %1 to i1 + %0 = load i8, i8* %x, align 1 + %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 } \ No newline at end of file diff --git a/test/test_suite/errors/rethrow.c3t b/test/test_suite/errors/rethrow.c3t index 44069b5aa..d5a950e3d 100644 --- a/test/test_suite/errors/rethrow.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %i.f, align 8 + %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 - ret i64 %1 + %0 = load i64, i64* %error_var, align 8 + ret i64 %0 noerr_block: ; preds = %after_check ret i64 0 diff --git a/test/test_suite/errors/rethrow_mingw.c3t b/test/test_suite/errors/rethrow_mingw.c3t index 56cf8ec9a..b0000e5f5 100644 --- a/test/test_suite/errors/rethrow_mingw.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %i.f, align 8 + %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 - ret i64 %1 + %0 = load i64, i64* %error_var, align 8 + ret i64 %0 noerr_block: ; preds = %after_check ret i64 0 diff --git a/test/test_suite/errors/try_assign.c3t b/test/test_suite/errors/try_assign.c3t index 24c83e4c7..0890d72cf 100644 --- a/test/test_suite/errors/try_assign.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %z.f, align 8 + %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 - store i32 %1, i32* %x, align 4 + %0 = load i32, i32* %z, 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 - %not_err1 = icmp eq i64 %2, 0 - br i1 %not_err1, label %after_check2, label %catch_landing3 + %optval1 = load i64, i64* %w.f, align 8 + %not_err2 = icmp eq i64 %optval1, 0 + br i1 %not_err2, label %after_check3, label %catch_landing4 -after_check2: ; preds = %chain_next - %3 = load i32, i32* %w, align 4 - store i32 %3, i32* %gh, align 4 - br label %phi_try_catch4 +after_check3: ; preds = %chain_next + %1 = load i32, i32* %w, align 4 + store i32 %1, i32* %gh, align 4 + br label %phi_try_catch5 -catch_landing3: ; preds = %chain_next - br label %phi_try_catch4 +catch_landing4: ; preds = %chain_next + br label %phi_try_catch5 -phi_try_catch4: ; preds = %catch_landing3, %after_check2 - %val5 = phi i1 [ true, %after_check2 ], [ false, %catch_landing3 ] - br i1 %val5, label %chain_next6, label %fail_chain +phi_try_catch5: ; preds = %catch_landing4, %after_check3 + %val6 = phi i1 [ true, %after_check3 ], [ false, %catch_landing4 ] + 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 - %chain.phi = phi i1 [ true, %chain_next6 ], [ false, %fail_chain ] +end_chain: ; preds = %fail_chain, %chain_next7 + %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 - %5 = 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) + %2 = load i32, i32* %x, align 4 + %3 = load i32, i32* %gh, align 4 + %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 - %not_err7 = icmp eq i64 %7, 0 - br i1 %not_err7, label %after_check8, label %catch_landing11 + %optval8 = load i64, i64* %z.f, align 8 + %not_err9 = icmp eq i64 %optval8, 0 + br i1 %not_err9, label %after_check10, label %catch_landing14 -after_check8: ; preds = %if.exit - %8 = load i32, i32* %z, align 4 - %9 = load i64, i64* %w.f, align 8 - %not_err9 = icmp eq i64 %9, 0 - br i1 %not_err9, label %after_check10, label %catch_landing11 +after_check10: ; preds = %if.exit + %5 = load i32, i32* %z, align 4 + %optval11 = load i64, i64* %w.f, align 8 + %not_err12 = icmp eq i64 %optval11, 0 + br i1 %not_err12, label %after_check13, label %catch_landing14 -after_check10: ; preds = %after_check8 - %10 = load i32, i32* %w, align 4 - %add = add i32 %8, %10 +after_check13: ; preds = %after_check10 + %6 = load i32, i32* %w, align 4 + %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 - br label %phi_try_catch12 +catch_landing14: ; preds = %after_check10, %if.exit + br label %phi_try_catch15 -phi_try_catch12: ; preds = %catch_landing11, %after_check10 - %val13 = phi i1 [ true, %after_check10 ], [ false, %catch_landing11 ] - br i1 %val13, label %if.then14, label %if.exit15 +phi_try_catch15: ; preds = %catch_landing14, %after_check13 + %val16 = phi i1 [ true, %after_check13 ], [ false, %catch_landing14 ] + br i1 %val16, label %if.then17, label %if.exit18 -if.then14: ; preds = %phi_try_catch12 - %11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0)) - br label %if.exit15 +if.then17: ; preds = %phi_try_catch15 + %7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i32 0, i32 0)) + 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 - %12 = load i64, i64* %z.f, align 8 - %not_err16 = icmp eq i64 %12, 0 - br i1 %not_err16, label %after_check17, label %assign_optional +testblock: ; preds = %if.exit18 + %optval19 = load i64, i64* %z.f, align 8 + %not_err20 = icmp eq i64 %optval19, 0 + 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 - %13 = load i64, i64* %e, align 8 - %neq = icmp ne i64 %13, 0 - br i1 %neq, label %if.then18, label %if.exit19 +end_block: ; preds = %after_check21, %assign_optional + %8 = load i64, i64* %e, align 8 + %neq = icmp ne i64 %8, 0 + br i1 %neq, label %if.then22, label %if.exit23 -if.then18: ; preds = %end_block - %14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0)) - br label %if.exit19 +if.then22: ; preds = %end_block + %9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0)) + br label %if.exit23 -if.exit19: ; preds = %if.then18, %end_block +if.exit23: ; preds = %if.then22, %end_block ret void } diff --git a/test/test_suite/errors/try_catch_if.c3t b/test/test_suite/errors/try_catch_if.c3t index 0ff3e4bb9..030fe7611 100644 --- a/test/test_suite/errors/try_catch_if.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %a.f, align 8 + %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) - %not_err2 = icmp eq i64 %1, 0 + %0 = call i64 @try_catch_if_tester(i32* %retparam) + %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 - %neq = icmp ne i64 %2, 0 + %1 = load i64, i64* %err, align 8 + %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 - %5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.2, i32 0, i32 0), i32 %4) + %3 = load i32, i32* %a, align 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 diff --git a/test/test_suite/errors/try_with_unwrapper.c3t b/test/test_suite/errors/try_with_unwrapper.c3t index b9065ecdd..7fff22c00 100644 --- a/test/test_suite/errors/try_with_unwrapper.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %a.f, align 8 + %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 - store i32 %1, i32* %b, align 4 + %0 = load i32, i32* %a, 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) - %not_err1 = icmp eq i64 %2, 0 + %1 = call i64 @try_with_unwrapper_tester(i32* %retparam) + %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 - store i32 %3, i32* %c, align 4 + %2 = load i32, i32* %retparam, 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 - %5 = call i32 @try_with_unwrapper_hello(i32 %4) - %6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %5) - %7 = 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) + %3 = load i32, i32* %b, align 4 + %4 = call i32 @try_with_unwrapper_hello(i32 %3) + %5 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i32 %4) + %6 = load i32, i32* %c, align 4 + %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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %a.f, align 8 + %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 - store i32 %1, i32* %b, align 4 + %0 = load i32, i32* %a, 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 - %3 = call i32 @try_with_unwrapper_hello(i32 %2) - %intbool = icmp ne i32 %3, 0 + %1 = load i32, i32* %b, align 4 + %2 = call i32 @try_with_unwrapper_hello(i32 %1) + %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 - %add = add i32 %4, 1 - %5 = call i32 @try_with_unwrapper_hello(i32 %add) + %3 = load i32, i32* %b, align 4 + %add = add i32 %3, 1 + %4 = call i32 @try_with_unwrapper_hello(i32 %add) br label %if.exit if.exit: ; preds = %if.then, %end_chain diff --git a/test/test_suite/expressions/chained_ternary.c3t b/test/test_suite/expressions/chained_ternary.c3t index 4b3c865d4..798043661 100644 --- a/test/test_suite/expressions/chained_ternary.c3t +++ b/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 - %not_err = icmp eq i64 %6, 0 + %optval = load i64, i64* %x.f, align 8 + %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 - %not11 = icmp eq i8* %9, null + %8 = load i8*, i8** %a, align 8 + %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 - br label %cond.phi17 + %9 = load i8*, i8** %b, align 8 + br label %cond.phi18 cond.rhs13: ; preds = %after_assign - %11 = load i64, i64* %x.f, align 8 - %not_err14 = icmp eq i64 %11, 0 - br i1 %not_err14, label %after_check16, label %assign_optional15 + %optval14 = load i64, i64* %x.f, align 8 + %not_err15 = icmp eq i64 %optval14, 0 + br i1 %not_err15, label %after_check17, label %assign_optional16 -assign_optional15: ; preds = %cond.rhs13 - store i64 %11, i64* %y.f, align 8 - br label %after_assign19 +assign_optional16: ; preds = %cond.rhs13 + store i64 %optval14, i64* %y.f, align 8 + br label %after_assign20 -after_check16: ; preds = %cond.rhs13 - %12 = load i8*, i8** %x, align 8 - br label %cond.phi17 +after_check17: ; preds = %cond.rhs13 + %10 = load i8*, i8** %x, align 8 + br label %cond.phi18 -cond.phi17: ; preds = %after_check16, %cond.lhs12 - %val18 = phi i8* [ %10, %cond.lhs12 ], [ %12, %after_check16 ] - store i8* %val18, i8** %y, align 8 +cond.phi18: ; preds = %after_check17, %cond.lhs12 + %val19 = phi i8* [ %9, %cond.lhs12 ], [ %10, %after_check17 ] + 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 - %13 = load i8*, i8** %a, align 8 - %not20 = icmp eq i8* %13, null - br i1 %not20, label %cond.lhs21, label %cond.rhs25 +voiderr: ; preds = %after_assign20 + %11 = load i8*, i8** %a, align 8 + %not21 = icmp eq i8* %11, null + br i1 %not21, label %cond.lhs22, label %cond.rhs27 -cond.lhs21: ; preds = %voiderr - %14 = load i64, i64* %x.f, align 8 - %not_err22 = icmp eq i64 %14, 0 - br i1 %not_err22, label %after_check24, label %assign_optional23 +cond.lhs22: ; preds = %voiderr + %optval23 = load i64, i64* %x.f, align 8 + %not_err24 = icmp eq i64 %optval23, 0 + br i1 %not_err24, label %after_check26, label %assign_optional25 -assign_optional23: ; preds = %cond.lhs21 - store i64 %14, i64* %y.f, align 8 - br label %after_assign31 +assign_optional25: ; preds = %cond.lhs22 + store i64 %optval23, i64* %y.f, align 8 + 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 - %16 = load i64, i64* %x.f, align 8 - %not_err26 = icmp eq i64 %16, 0 - br i1 %not_err26, label %after_check28, label %assign_optional27 +cond.rhs42: ; preds = %voiderr35 + store i64 ptrtoint (%.fault* @"test_Test$FOO" to i64), i64* %y.f, align 8 + br label %after_assign44 -assign_optional27: ; preds = %cond.rhs25 - store i64 %16, i64* %y.f, align 8 - br label %after_assign31 +cond.phi43: ; preds = %after_check41 + store i8* %15, i8** %y, align 8 + 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 - %val30 = phi i8* [ %15, %after_check24 ], [ %17, %after_check28 ] - store i8* %val30, i8** %y, align 8 +cond.phi53: ; preds = %after_check52 + store i8* %17, 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 - br label %voiderr32 +after_assign54: ; preds = %cond.phi53, %assign_optional51, %cond.lhs47 + br label %voiderr55 -voiderr32: ; preds = %after_assign31 +voiderr55: ; preds = %after_assign54 %18 = load i8*, i8** %a, align 8 - %not33 = icmp eq i8* %18, null - br i1 %not33, label %cond.lhs34, label %cond.rhs38 + %not56 = icmp eq i8* %18, null + br i1 %not56, label %cond.lhs57, label %cond.rhs58 -cond.lhs34: ; preds = %voiderr32 - %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 +cond.lhs57: ; preds = %voiderr55 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 - 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 +cond.rhs58: ; preds = %voiderr55 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 - br label %voiderr56 +after_assign60: ; preds = %cond.rhs58, %cond.lhs57 + br label %voiderr61 -voiderr56: ; preds = %after_assign55 +voiderr61: ; preds = %after_assign60 ret void diff --git a/test/test_suite/failable_catch.c3t b/test/test_suite/failable_catch.c3t index 314b8c21c..683d45f13 100644 --- a/test/test_suite/failable_catch.c3t +++ b/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 - %not_err = icmp eq i64 %3, 0 + %optval = load i64, i64* %a.f, align 8 + %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 - %add = add i32 %4, 3 + %3 = load i32, i32* %a, align 4 + %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 - %intbool3 = icmp ne i32 %5, 0 + %4 = load i32, i32* %x1, align 4 + %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 - store i32 %6, i32* %blockret2, align 4 + %5 = load i32, i32* %x1, 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 - store i32 %7, i32* %b, align 4 + %6 = load i32, i32* %blockret2, 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 - %intbool10 = icmp ne i32 %8, 0 + %7 = load i32, i32* %x8, align 4 + %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 - store i32 %9, i32* %blockret9, align 4 + %8 = load i32, i32* %x8, 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 - store i32 %10, i32* %c, align 4 + %9 = load i32, i32* %blockret9, 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 - %not_err15 = icmp eq i64 %11, 0 - br i1 %not_err15, label %after_check16, label %voiderr -after_check16: ; preds = %after_assign14 - %12 = 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) + %optval15 = load i64, i64* %a.f, align 8 + %not_err16 = icmp eq i64 %optval15, 0 + br i1 %not_err16, label %after_check17, label %voiderr +after_check17: ; preds = %after_assign14 + %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 %10) br label %voiderr -voiderr: ; preds = %after_check16, %after_assign14 - %13 = load i64, i64* %b.f, align 8 - %not_err17 = icmp eq i64 %13, 0 - br i1 %not_err17, label %after_check18, label %voiderr19 -after_check18: ; preds = %voiderr - %14 = 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) - br label %voiderr19 -voiderr19: ; preds = %after_check18, %voiderr - %15 = load i64, i64* %c.f, align 8 - %not_err20 = icmp eq i64 %15, 0 - br i1 %not_err20, label %after_check21, label %voiderr22 -after_check21: ; preds = %voiderr19 - %16 = 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) - br label %voiderr22 -voiderr22: ; preds = %after_check21, %voiderr19 - %17 = load i64, i64* %c.f, align 8 - %neq = icmp ne i64 %17, 0 - br i1 %neq, label %if.then23, label %if.exit24 -if.then23: ; preds = %voiderr22 +voiderr: ; preds = %after_check17, %after_assign14 + %optval18 = load i64, i64* %b.f, align 8 + %not_err19 = icmp eq i64 %optval18, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 +after_check20: ; preds = %voiderr + %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 %11) + br label %voiderr21 +voiderr21: ; preds = %after_check20, %voiderr + %optval22 = load i64, i64* %c.f, align 8 + %not_err23 = icmp eq i64 %optval22, 0 + br i1 %not_err23, label %after_check24, label %voiderr25 +after_check24: ; preds = %voiderr21 + %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 %12) + br label %voiderr25 +voiderr25: ; preds = %after_check24, %voiderr21 + %13 = load i64, i64* %c.f, align 8 + %neq = icmp ne i64 %13, 0 + br i1 %neq, label %if.then26, label %if.exit27 +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 -if.exit24: ; preds = %if.then23, %voiderr22 + br label %if.exit27 +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 - %not_err25 = icmp eq i64 %18, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 -after_check26: ; preds = %if.exit24 - %19 = 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) - br label %voiderr27 -voiderr27: ; preds = %after_check26, %if.exit24 + %optval28 = load i64, i64* %c.f, align 8 + %not_err29 = icmp eq i64 %optval28, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 +after_check30: ; preds = %if.exit27 + %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 %14) + br label %voiderr31 +voiderr31: ; preds = %after_check30, %if.exit27 ret i32 0 } diff --git a/test/test_suite/from_docs/examples_if_catch.c3t b/test/test_suite/from_docs/examples_if_catch.c3t index 32152aa4e..5a82a6fa7 100644 --- a/test/test_suite/from_docs/examples_if_catch.c3t +++ b/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 - %not_err1 = icmp eq i64 %4, 0 + %optval = load i64, i64* %ratio.f, align 8 + %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 - %neq = icmp ne i64 %5, 0 + %4 = load i64, i64* %err, align 8 + %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 - %eq = icmp eq i64 ptrtoint (%.fault* @"demo_MathError$DIVISION_BY_ZERO" to i64), %6 + %5 = load i64, i64* %switch, align 8 + %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 - %10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i32 0, i32 0), double %9) + %8 = load double, double* %ratio, align 8 + %9 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i32 0, i32 0), double %8) ret void } \ No newline at end of file diff --git a/test/test_suite/functions/assorted_tests.c3t b/test/test_suite/functions/assorted_tests.c3t index c5737579a..93dc4989b 100644 --- a/test/test_suite/functions/assorted_tests.c3t +++ b/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 - %add = add i32 %0, %uiuiext + %zext = zext i8 %2 to i32 + %add = add i32 %0, %zext store i32 %add, i32* %w_cnt, align 4 %3 = load i32, i32* %w_cnt, align 4 ret i32 %3 diff --git a/test/test_suite/functions/simple_test.c3t b/test/test_suite/functions/simple_test.c3t index a026ffb2b..889c1be63 100644 --- a/test/test_suite/functions/simple_test.c3t +++ b/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 - %add = add i32 %0, %uiuiext + %zext = zext i8 %2 to i32 + %add = add i32 %0, %zext store i32 %add, i32* %w_cnt, align 4 %3 = load i32, i32* %w_cnt, align 4 ret i32 %3 diff --git a/test/test_suite/macros/macro_with_body.c3t b/test/test_suite/macros/macro_with_body.c3t index 71f2dfc8e..d15233bc8 100644 --- a/test/test_suite/macros/macro_with_body.c3t +++ b/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 - store %Foo %1, %Foo* %foo, align 4 - %2 = getelementptr inbounds %Foo, %Foo* %foo, i32 0, i32 0 - %3 = load i32, i32* %2, align 4 - store i32 %3, i32* %y, align 4 - %4 = call i32 @withbody_Foo_mutate(%Foo* %foo) - store i32 %4, i32* %x, align 4 - %5 = load i32, i32* %y, align 4 - store i32 %5, i32* %dy, align 4 - %6 = load i32, i32* %x, align 4 - %7 = load i32, i32* %dy, 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) + %1 = bitcast %Foo* %foo to i8* + %2 = bitcast %Foo* %f to i8* + call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 4 %1, i8* align 4 %2, i32 4, i1 false) + %3 = getelementptr inbounds %Foo, %Foo* %foo, i32 0, i32 0 + %4 = load i32, i32* %3, align 4 + store i32 %4, i32* %y, align 4 + %5 = call i32 @withbody_Foo_mutate(%Foo* %foo) + store i32 %5, i32* %x, align 4 + %6 = load i32, i32* %y, align 4 + store i32 %6, i32* %dy, align 4 + %7 = load i32, i32* %x, align 4 + %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* %times, align 4 - %lt = icmp slt i32 %9, %10 + %10 = load i32, i32* %i, align 4 + %11 = load i32, i32* %times, align 4 + %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 - %add = add i32 %11, 1 + %12 = load i32, i32* %i, align 4 + %add = add i32 %12, 1 store i32 %add, i32* %loop, align 4 - %12 = 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 = load i32, i32* %i, align 4 - %add1 = add i32 %14, 1 + %13 = load i32, i32* %loop, align 4 + %14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i32 0, i32 0), i32 %13) + %15 = load i32, i32* %i, align 4 + %add1 = add i32 %15, 1 store i32 %add1, i32* %i, align 4 br label %loop.cond diff --git a/test/test_suite/macros/userland_bitcast.c3t b/test/test_suite/macros/userland_bitcast.c3t index 2b2f9e441..f48a8f3ad 100644 --- a/test/test_suite/macros/userland_bitcast.c3t +++ b/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 - store %Foo %7, %Foo* %expr, align 2 + %7 = bitcast %Foo* %expr to i8* + %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 - %lt = icmp ult i64 %8, 8 + %9 = load i64, i64* %i, align 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 i64, i64* %i, align 8 - %ptroffset = getelementptr inbounds i16, i16* %9, i64 %10 - %11 = load i16*, i16** %b, align 8 - %12 = load i64, i64* %i, align 8 - %ptroffset2 = getelementptr inbounds i16, i16* %11, i64 %12 - %13 = load i16, i16* %ptroffset2, align 2 - store i16 %13, i16* %ptroffset, align 2 - %14 = load i64, i64* %i, align 8 - %add = add i64 %14, 2 + %10 = load i16*, i16** %to, align 8 + %11 = load i64, i64* %i, align 8 + %ptroffset = getelementptr inbounds i16, i16* %10, i64 %11 + %12 = load i16*, i16** %b, align 8 + %13 = load i64, i64* %i, align 8 + %ptroffset2 = getelementptr inbounds i16, i16* %12, i64 %13 + %14 = load i16, i16* %ptroffset2, align 2 + store i16 %14, i16* %ptroffset, align 2 + %15 = load i64, i64* %i, align 8 + %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 - ret i64 %15 + %16 = load i64, i64* %x, align 8 + ret i64 %16 } ; Function Attrs: nounwind diff --git a/test/test_suite/statements/comparison_widening.c3t b/test/test_suite/statements/comparison_widening.c3t index 65b9ce45f..b2006abc5 100644 --- a/test/test_suite/statements/comparison_widening.c3t +++ b/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 - %gt = icmp sgt i32 %0, %uiuiext - %check = icmp sge i32 %uiuiext, 0 + %zext = zext i8 %1 to i32 + %gt = icmp sgt i32 %0, %zext + %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 diff --git a/test/test_suite/statements/foreach_common.c3t b/test/test_suite/statements/foreach_common.c3t index f67c7bf6b..096f1e886 100644 --- a/test/test_suite/statements/foreach_common.c3t +++ b/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> , <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 - store i8 %uiuitrunc, i8* %i30, align 1 + %ztrunc = trunc i64 %30 to i8 + 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 } \ No newline at end of file diff --git a/test/test_suite/statements/various_switching.c3t b/test/test_suite/statements/various_switching.c3t index 43ac51bea..758c6c146 100644 --- a/test/test_suite/statements/various_switching.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, i64* %x.f, align 8 + %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 - %neq = icmp ne i64 %1, 0 + %0 = load i64, i64* %err, align 8 + %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 - %eq = icmp eq i64 ptrtoint (%.fault* @"mymodule_HelloErr$FOO" to i64), %2 + %1 = load i64, i64* %switch, align 8 + %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 - store i64 %3, i64* %switch4, align 8 + %2 = load i64, i64* %z, 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 - %eq6 = icmp eq i64 ptrtoint (%.introspect* @"ct$int" to i64), %4 + %3 = load i64, i64* %switch4, align 8 + %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 - %6 = load i32, i32* %a, align 4 - %add = add i32 %5, %6 + %4 = load i32, i32* %b, align 4 + %5 = load i32, i32* %a, align 4 + %add = add i32 %4, %5 store i32 %add, i32* %zy, align 4 - %7 = load i32, i32* %zy, align 4 - store i32 %7, i32* %switch17, align 4 + %6 = load i32, i32* %zy, 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 - %9 = load i32, i32* %a, align 4 - %eq19 = icmp eq i32 %9, %8 + %7 = load i32, i32* %switch17, align 4 + %8 = load i32, i32* %a, align 4 + %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 - %eq22 = icmp eq i32 %10, %8 + %9 = load i32, i32* %b, align 4 + %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 - %12 = trunc i8 %11 to i1 - %13 = load i32, i32* %a, align 4 - %lt = icmp slt i32 %13, 0 - %eq29 = icmp eq i1 %lt, %12 + %10 = load i8, i8* %switch27, align 1 + %11 = trunc i8 %10 to i1 + %12 = load i32, i32* %a, align 4 + %lt = icmp slt i32 %12, 0 + %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 - %eq32 = icmp eq i32 %14, 1 - %eq33 = icmp eq i1 %eq32, %12 + %13 = load i32, i32* %a, align 4 + %eq32 = icmp eq i32 %13, 1 + %eq33 = icmp eq i1 %eq32, %11 br i1 %eq33, label %switch.case34, label %next_if35 switch.case34: ; preds = %next_if31 diff --git a/test/test_suite2/arrays/array_literal.c3t b/test/test_suite2/arrays/array_literal.c3t index 02dc0d244..d29dd766e 100644 --- a/test/test_suite2/arrays/array_literal.c3t +++ b/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 - %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %uiuiext + %zext = zext i32 %0 to i64 + %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %zext %2 = load double, ptr %1, align 8 ret double %2 } diff --git a/test/test_suite2/bitstruct/array_with_boolean.c3t b/test/test_suite2/bitstruct/array_with_boolean.c3t index 31542d529..9f5c4224c 100644 --- a/test/test_suite2/bitstruct/array_with_boolean.c3t +++ b/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 - %3 = shl i32 %2, 29 - %4 = ashr i32 %3, 29 - %5 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %6 = load i8, ptr %5, align 1 - %7 = zext i8 %6 to i32 - %8 = lshr i32 %7, 3 - %9 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %zext = zext i8 %1 to i32 + %shl = shl i32 %zext, 29 + %ashr = ashr i32 %shl, 29 + %2 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %3 = load i8, ptr %2, align 1 + %zext1 = zext i8 %3 to i32 + %lshrl = lshr i32 %zext1, 3 + %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 - %12 = shl i32 %11, 5 - %13 = or i32 %12, %8 - %14 = shl i32 %13, 26 - %15 = ashr i32 %14, 26 - %16 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %17 = load i8, ptr %16, align 1 - %18 = zext i8 %17 to i32 - %19 = lshr i32 %18, 1 - %20 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %21 = load i8, ptr %20, align 1 - %22 = zext i8 %21 to i32 - %23 = shl i32 %22, 7 - %24 = or i32 %23, %19 - %25 = shl i32 %24, 22 - %26 = ashr i32 %25, 22 - %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) + %zext8 = zext i8 %10 to i32 + %shl9 = shl i32 %zext8, 7 + %11 = or i32 %shl9, %lshrl7 + %shl10 = shl i32 %11, 22 + %ashr11 = ashr i32 %shl10, 22 + %12 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %13 = load i8, ptr %12, align 1 + %lshrl12 = lshr i8 %13, 3 + %14 = trunc i8 %lshrl12 to i1 + %boolsi = zext i1 %14 to i32 + %15 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %16 = load i8, ptr %15, align 1 + %lshrl13 = lshr i8 %16, 4 + %17 = trunc i8 %lshrl13 to i1 + %boolsi14 = zext i1 %17 to i32 + call void (ptr, ...) @printf(ptr @.str, i32 %ashr, i32 %ashr5, i32 %ashr11, i32 %boolsi, i32 %boolsi14) ret void } \ No newline at end of file diff --git a/test/test_suite2/bitstruct/bitfield_access.c3t b/test/test_suite2/bitstruct/bitfield_access.c3t index 1a58a9d1e..b22e6e031 100644 --- a/test/test_suite2/bitstruct/bitfield_access.c3t +++ b/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 - %3 = shl i32 %2, 29 - %4 = ashr i32 %3, 29 - call void (ptr, ...) @printf(ptr @.str, i32 %4) - %5 = getelementptr inbounds [3 x i8], ptr %e2, i64 0, i64 0 - %6 = load i8, ptr %5, align 1 - %7 = zext i8 %6 to i32 - %8 = shl i32 %7, 29 - %9 = ashr i32 %8, 29 - call void (ptr, ...) @printf(ptr @.str.1, i32 %9) - %10 = getelementptr inbounds [3 x i8], ptr %e3, i64 0, i64 0 - %11 = load i8, ptr %10, align 1 - %12 = zext i8 %11 to i32 - %13 = shl i32 %12, 29 - %14 = ashr i32 %13, 29 - call void (ptr, ...) @printf(ptr @.str.2, i32 %14) + %zext = zext i8 %1 to i32 + %shl = shl i32 %zext, 29 + %ashr = ashr i32 %shl, 29 + call void (ptr, ...) @printf(ptr @.str, i32 %ashr) + %2 = getelementptr inbounds [3 x i8], ptr %e2, i64 0, i64 0 + %3 = load i8, ptr %2, align 1 + %zext1 = zext i8 %3 to i32 + %shl2 = shl i32 %zext1, 29 + %ashr3 = ashr i32 %shl2, 29 + call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr3) + %4 = getelementptr inbounds [3 x i8], ptr %e3, i64 0, i64 0 + %5 = load i8, ptr %4, align 1 + %zext4 = zext i8 %5 to i32 + %shl5 = shl i32 %zext4, 29 + %ashr6 = ashr i32 %shl5, 29 + 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 - %16 = load i8, ptr %15, align 1 - %17 = zext i8 %16 to i32 - %18 = and i32 7, %17 - call void (ptr, ...) @printf(ptr @.str.3, i32 %18) - %19 = getelementptr inbounds [3 x i8], ptr %z2, i64 0, i64 0 - %20 = load i8, ptr %19, align 1 - %21 = zext i8 %20 to i32 - %22 = and i32 7, %21 - call void (ptr, ...) @printf(ptr @.str.4, i32 %22) - %23 = getelementptr inbounds [3 x i8], ptr %z3, i64 0, i64 0 - %24 = load i8, ptr %23, align 1 - %25 = zext i8 %24 to i32 - %26 = and i32 7, %25 - call void (ptr, ...) @printf(ptr @.str.5, i32 %26) + %6 = getelementptr inbounds [3 x i8], ptr %z1, i64 0, i64 0 + %7 = load i8, ptr %6, align 1 + %zext7 = zext i8 %7 to i32 + %8 = and i32 7, %zext7 + call void (ptr, ...) @printf(ptr @.str.3, i32 %8) + %9 = getelementptr inbounds [3 x i8], ptr %z2, i64 0, i64 0 + %10 = load i8, ptr %9, align 1 + %zext8 = zext i8 %10 to i32 + %11 = and i32 7, %zext8 + call void (ptr, ...) @printf(ptr @.str.4, i32 %11) + %12 = getelementptr inbounds [3 x i8], ptr %z3, i64 0, i64 0 + %13 = load i8, ptr %12, align 1 + %zext9 = zext i8 %13 to i32 + %14 = and i32 7, %zext9 + 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 - %28 = load i8, ptr %27, align 1 - %29 = zext i8 %28 to i32 - %30 = lshr i32 %29, 5 - %31 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 1 - %32 = load i8, ptr %31, align 1 - %33 = zext i8 %32 to i32 - %34 = shl i32 %33, 3 - %35 = or i32 %34, %30 - %36 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 2 - %37 = load i8, ptr %36, align 1 - %38 = zext i8 %37 to i32 - %39 = shl i32 %38, 11 - %40 = or i32 %39, %35 - %41 = and i32 262143, %40 - call void (ptr, ...) @printf(ptr @.str.6, i32 %41) + %15 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 0 + %16 = load i8, ptr %15, align 1 + %zext10 = zext i8 %16 to i32 + %lshrl = lshr i32 %zext10, 5 + %17 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 1 + %18 = load i8, ptr %17, align 1 + %zext11 = zext i8 %18 to i32 + %shl12 = shl i32 %zext11, 3 + %19 = or i32 %shl12, %lshrl + %20 = getelementptr inbounds [5 x i8], ptr %xx, i64 0, i64 2 + %21 = load i8, ptr %20, align 1 + %zext13 = zext i8 %21 to i32 + %shl14 = shl i32 %zext13, 11 + %22 = or i32 %shl14, %19 + %23 = and i32 262143, %22 + call void (ptr, ...) @printf(ptr @.str.6, i32 %23) ret void } \ No newline at end of file diff --git a/test/test_suite2/bitstruct/bitstruct_access_signed.c3t b/test/test_suite2/bitstruct/bitstruct_access_signed.c3t index 265ada0d1..3475821f5 100644 --- a/test/test_suite2/bitstruct/bitstruct_access_signed.c3t +++ b/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 - %3 = lshr i32 %2, 5 - %4 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %5 = load i8, ptr %4, align 1 - %6 = zext i8 %5 to i32 - %7 = shl i32 %6, 3 - %8 = or i32 %7, %3 - %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 - %12 = shl i32 %11, 11 - %13 = or i32 %12, %8 - %14 = shl i32 %13, 14 - %15 = ashr i32 %14, 14 - call void (ptr, ...) @printf(ptr @.str, i32 %15) + %zext = zext i8 %1 to i32 + %lshrl = lshr i32 %zext, 5 + %2 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %3 = load i8, ptr %2, align 1 + %zext1 = zext i8 %3 to i32 + %shl = shl i32 %zext1, 3 + %4 = or i32 %shl, %lshrl + %5 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %6 = load i8, ptr %5, align 1 + %zext2 = zext i8 %6 to i32 + %shl3 = shl i32 %zext2, 11 + %7 = or i32 %shl3, %4 + %shl4 = shl i32 %7, 14 + %ashr = ashr i32 %shl4, 14 + 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 - %17 = load i8, ptr %16, align 1 - %18 = zext i8 %17 to i32 - %19 = lshr i32 %18, 5 - %20 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %21 = load i8, ptr %20, align 1 - %22 = zext i8 %21 to i32 - %23 = shl i32 %22, 3 - %24 = or i32 %23, %19 - %25 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %26 = load i8, ptr %25, align 1 - %27 = zext i8 %26 to i32 - %28 = shl i32 %27, 11 - %29 = or i32 %28, %24 - %30 = shl i32 %29, 14 - %31 = ashr i32 %30, 14 - call void (ptr, ...) @printf(ptr @.str.1, i32 %31) + %8 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %9 = load i8, ptr %8, align 1 + %zext5 = zext i8 %9 to i32 + %lshrl6 = lshr i32 %zext5, 5 + %10 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %11 = load i8, ptr %10, align 1 + %zext7 = zext i8 %11 to i32 + %shl8 = shl i32 %zext7, 3 + %12 = or i32 %shl8, %lshrl6 + %13 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %14 = load i8, ptr %13, align 1 + %zext9 = zext i8 %14 to i32 + %shl10 = shl i32 %zext9, 11 + %15 = or i32 %shl10, %12 + %shl11 = shl i32 %15, 14 + %ashr12 = ashr i32 %shl11, 14 + 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 - %33 = load i8, ptr %32, align 1 - %34 = zext i8 %33 to i32 - %35 = lshr i32 %34, 5 - %36 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 1 - %37 = load i8, ptr %36, align 1 - %38 = zext i8 %37 to i32 - %39 = shl i32 %38, 3 - %40 = or i32 %39, %35 - %41 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 2 - %42 = load i8, ptr %41, align 1 - %43 = zext i8 %42 to i32 - %44 = shl i32 %43, 11 - %45 = or i32 %44, %40 - %46 = and i32 262143, %45 - call void (ptr, ...) @printf(ptr @.str.2, i32 %46) + %16 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 0 + %17 = load i8, ptr %16, align 1 + %zext13 = zext i8 %17 to i32 + %lshrl14 = lshr i32 %zext13, 5 + %18 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 1 + %19 = load i8, ptr %18, align 1 + %zext15 = zext i8 %19 to i32 + %shl16 = shl i32 %zext15, 3 + %20 = or i32 %shl16, %lshrl14 + %21 = getelementptr inbounds [3 x i8], ptr %xxu, i64 0, i64 2 + %22 = load i8, ptr %21, align 1 + %zext17 = zext i8 %22 to i32 + %shl18 = shl i32 %zext17, 11 + %23 = or i32 %shl18, %20 + %24 = and i32 262143, %23 + call void (ptr, ...) @printf(ptr @.str.2, i32 %24) ret void } diff --git a/test/test_suite2/bitstruct/bitstruct_arrays.c3t b/test/test_suite2/bitstruct/bitstruct_arrays.c3t index 4a5290c61..15e5d33bc 100644 --- a/test/test_suite2/bitstruct/bitstruct_arrays.c3t +++ b/test/test_suite2/bitstruct/bitstruct_arrays.c3t @@ -140,204 +140,204 @@ entry: %2 = or i64 %1, 3 store i64 %2, ptr %xx, align 8 %3 = load i64, ptr %xx, align 8 - %4 = shl i64 %3, 61 - %5 = ashr i64 %4, 61 - %6 = trunc i64 %5 to i32 + %shl = shl i64 %3, 61 + %ashr = ashr i64 %shl, 61 + %4 = trunc i64 %ashr to i32 + %5 = load i64, ptr %xx, align 8 + %shl1 = shl i64 %5, 55 + %ashr2 = ashr i64 %shl1, 58 + %6 = trunc i64 %ashr2 to i32 + call void (ptr, ...) @printf(ptr @.str, i32 %4, i32 %6) %7 = load i64, ptr %xx, align 8 - %8 = shl i64 %7, 55 - %9 = ashr i64 %8, 58 - %10 = trunc i64 %9 to i32 - call void (ptr, ...) @printf(ptr @.str, i32 %6, i32 %10) - %11 = load i64, ptr %xx, align 8 - %12 = shl i64 %11, 61 - %13 = ashr i64 %12, 61 - %14 = trunc i64 %13 to i32 - %sub = sub i32 %14, 1 + %shl3 = shl i64 %7, 61 + %ashr4 = ashr i64 %shl3, 61 + %8 = trunc i64 %ashr4 to i32 + %sub = sub i32 %8, 1 + %9 = load i64, ptr %xx, align 8 + %zext = zext i32 %sub to i64 + %10 = and i64 %zext, 7 + %11 = and i64 %9, -8 + %12 = or i64 %11, %10 + store i64 %12, ptr %xx, align 8 + %13 = load i64, ptr %xx, align 8 + %shl5 = shl i64 %13, 61 + %ashr6 = ashr i64 %shl5, 61 + %14 = trunc i64 %ashr6 to i32 %15 = load i64, ptr %xx, align 8 - %16 = zext i32 %sub to i64 - %17 = and i64 %16, 7 - %18 = and i64 %15, -8 - %19 = or i64 %18, %17 - store i64 %19, ptr %xx, align 8 - %20 = load i64, ptr %xx, align 8 - %21 = shl i64 %20, 61 - %22 = ashr i64 %21, 61 - %23 = trunc i64 %22 to i32 - %24 = load i64, ptr %xx, align 8 - %25 = shl i64 %24, 55 - %26 = ashr i64 %25, 58 - %27 = trunc i64 %26 to i32 - call void (ptr, ...) @printf(ptr @.str.1, i32 %23, i32 %27) - %28 = load i64, ptr %xx, align 8 - %29 = shl i64 %28, 55 - %30 = ashr i64 %29, 58 - %31 = trunc i64 %30 to i32 - %mul = mul i32 %31, 2 - %32 = load i64, ptr %xx, align 8 - %33 = zext i32 %mul to i64 - %34 = shl i64 %33, 3 - %35 = and i64 %34, 504 - %36 = and i64 %32, -505 - %37 = or i64 %36, %35 - store i64 %37, ptr %xx, align 8 - %38 = load i64, ptr %xx, align 8 - %39 = shl i64 %38, 61 - %40 = ashr i64 %39, 61 - %41 = trunc i64 %40 to i32 - %42 = load i64, ptr %xx, align 8 - %43 = shl i64 %42, 55 - %44 = ashr i64 %43, 58 - %45 = trunc i64 %44 to i32 - call void (ptr, ...) @printf(ptr @.str.2, i32 %41, i32 %45) - %46 = load i64, ptr %xx, align 8 - %47 = shl i64 %46, 55 - %48 = ashr i64 %47, 58 - %49 = trunc i64 %48 to i32 - %xor = xor i32 %49, 4 + %shl7 = shl i64 %15, 55 + %ashr8 = ashr i64 %shl7, 58 + %16 = trunc i64 %ashr8 to i32 + call void (ptr, ...) @printf(ptr @.str.1, i32 %14, i32 %16) + %17 = load i64, ptr %xx, align 8 + %shl9 = shl i64 %17, 55 + %ashr10 = ashr i64 %shl9, 58 + %18 = trunc i64 %ashr10 to i32 + %mul = mul i32 %18, 2 + %19 = load i64, ptr %xx, align 8 + %zext11 = zext i32 %mul to i64 + %shl12 = shl i64 %zext11, 3 + %20 = and i64 %shl12, 504 + %21 = and i64 %19, -505 + %22 = or i64 %21, %20 + store i64 %22, ptr %xx, align 8 + %23 = load i64, ptr %xx, align 8 + %shl13 = shl i64 %23, 61 + %ashr14 = ashr i64 %shl13, 61 + %24 = trunc i64 %ashr14 to i32 + %25 = load i64, ptr %xx, align 8 + %shl15 = shl i64 %25, 55 + %ashr16 = ashr i64 %shl15, 58 + %26 = trunc i64 %ashr16 to i32 + call void (ptr, ...) @printf(ptr @.str.2, i32 %24, i32 %26) + %27 = load i64, ptr %xx, align 8 + %shl17 = shl i64 %27, 55 + %ashr18 = ashr i64 %shl17, 58 + %28 = trunc i64 %ashr18 to i32 + %xor = xor i32 %28, 4 + %29 = load i64, ptr %xx, align 8 + %zext19 = zext i32 %xor to i64 + %shl20 = shl i64 %zext19, 3 + %30 = and i64 %shl20, 504 + %31 = and i64 %29, -505 + %32 = or i64 %31, %30 + store i64 %32, ptr %xx, align 8 + %33 = load i64, ptr %xx, align 8 + %shl21 = shl i64 %33, 61 + %ashr22 = ashr i64 %shl21, 61 + %34 = trunc i64 %ashr22 to i32 + %35 = load i64, ptr %xx, align 8 + %shl23 = shl i64 %35, 55 + %ashr24 = ashr i64 %shl23, 58 + %36 = trunc i64 %ashr24 to i32 + call void (ptr, ...) @printf(ptr @.str.3, i32 %34, i32 %36) + %37 = load i64, ptr %xx, align 8 + %shl25 = shl i64 %37, 55 + %ashr26 = ashr i64 %shl25, 58 + %38 = trunc i64 %ashr26 to i32 + %or = or i32 %38, 4 + %39 = load i64, ptr %xx, align 8 + %zext27 = zext i32 %or to i64 + %shl28 = shl i64 %zext27, 3 + %40 = and i64 %shl28, 504 + %41 = and i64 %39, -505 + %42 = or i64 %41, %40 + store i64 %42, ptr %xx, align 8 + %43 = load i64, ptr %xx, align 8 + %shl29 = shl i64 %43, 61 + %ashr30 = ashr i64 %shl29, 61 + %44 = trunc i64 %ashr30 to i32 + %45 = load i64, ptr %xx, align 8 + %shl31 = shl i64 %45, 55 + %ashr32 = ashr i64 %shl31, 58 + %46 = trunc i64 %ashr32 to i32 + call void (ptr, ...) @printf(ptr @.str.4, i32 %44, i32 %46) + %47 = load i64, ptr %xx, align 8 + %shl33 = shl i64 %47, 55 + %ashr34 = ashr i64 %shl33, 58 + %48 = trunc i64 %ashr34 to i32 + %shl35 = shl i32 %48, 1 + %49 = freeze i32 %shl35 %50 = load i64, ptr %xx, align 8 - %51 = zext i32 %xor to i64 - %52 = shl i64 %51, 3 - %53 = and i64 %52, 504 - %54 = and i64 %50, -505 - %55 = or i64 %54, %53 - store i64 %55, ptr %xx, align 8 + %zext36 = zext i32 %49 to i64 + %shl37 = shl i64 %zext36, 3 + %51 = and i64 %shl37, 504 + %52 = and i64 %50, -505 + %53 = or i64 %52, %51 + store i64 %53, ptr %xx, align 8 + %54 = load i64, ptr %xx, align 8 + %shl38 = shl i64 %54, 61 + %ashr39 = ashr i64 %shl38, 61 + %55 = trunc i64 %ashr39 to i32 %56 = load i64, ptr %xx, align 8 - %57 = shl i64 %56, 61 - %58 = ashr i64 %57, 61 - %59 = trunc i64 %58 to i32 - %60 = load i64, ptr %xx, align 8 - %61 = shl i64 %60, 55 - %62 = ashr i64 %61, 58 - %63 = trunc i64 %62 to i32 - call void (ptr, ...) @printf(ptr @.str.3, i32 %59, i32 %63) - %64 = load i64, ptr %xx, align 8 - %65 = shl i64 %64, 55 - %66 = ashr i64 %65, 58 - %67 = trunc i64 %66 to i32 - %or = or i32 %67, 4 - %68 = load i64, ptr %xx, align 8 - %69 = zext i32 %or to i64 - %70 = shl i64 %69, 3 - %71 = and i64 %70, 504 - %72 = and i64 %68, -505 - %73 = or i64 %72, %71 - store i64 %73, ptr %xx, align 8 - %74 = load i64, ptr %xx, align 8 - %75 = shl i64 %74, 61 - %76 = ashr i64 %75, 61 - %77 = trunc i64 %76 to i32 - %78 = load i64, ptr %xx, align 8 - %79 = shl i64 %78, 55 - %80 = ashr i64 %79, 58 - %81 = trunc i64 %80 to i32 - call void (ptr, ...) @printf(ptr @.str.4, i32 %77, i32 %81) - %82 = load i64, ptr %xx, align 8 - %83 = shl i64 %82, 55 - %84 = ashr i64 %83, 58 - %85 = trunc i64 %84 to i32 - %shl = shl i32 %85, 1 - %86 = freeze i32 %shl + %shl40 = shl i64 %56, 55 + %ashr41 = ashr i64 %shl40, 58 + %57 = trunc i64 %ashr41 to i32 + call void (ptr, ...) @printf(ptr @.str.5, i32 %55, i32 %57) + %58 = load i64, ptr %xx, align 8 + %shl42 = shl i64 %58, 55 + %ashr43 = ashr i64 %shl42, 58 + %59 = trunc i64 %ashr43 to i32 + %ashr44 = ashr i32 %59, 1 + %60 = freeze i32 %ashr44 + %61 = load i64, ptr %xx, align 8 + %zext45 = zext i32 %60 to i64 + %shl46 = shl i64 %zext45, 3 + %62 = and i64 %shl46, 504 + %63 = and i64 %61, -505 + %64 = or i64 %63, %62 + store i64 %64, ptr %xx, align 8 + %65 = load i64, ptr %xx, align 8 + %shl47 = shl i64 %65, 61 + %ashr48 = ashr i64 %shl47, 61 + %66 = trunc i64 %ashr48 to i32 + %67 = load i64, ptr %xx, align 8 + %shl49 = shl i64 %67, 55 + %ashr50 = ashr i64 %shl49, 58 + %68 = trunc i64 %ashr50 to i32 + call void (ptr, ...) @printf(ptr @.str.6, i32 %66, i32 %68) + %69 = load i64, ptr %xx, align 8 + %shl51 = shl i64 %69, 55 + %ashr52 = ashr i64 %shl51, 58 + %70 = trunc i64 %ashr52 to i32 + %sdiv = sdiv i32 %70, 2 + %71 = load i64, ptr %xx, align 8 + %zext53 = zext i32 %sdiv to i64 + %shl54 = shl i64 %zext53, 3 + %72 = and i64 %shl54, 504 + %73 = and i64 %71, -505 + %74 = or i64 %73, %72 + store i64 %74, ptr %xx, align 8 + %75 = load i64, ptr %xx, align 8 + %shl55 = shl i64 %75, 61 + %ashr56 = ashr i64 %shl55, 61 + %76 = trunc i64 %ashr56 to i32 + %77 = load i64, ptr %xx, align 8 + %shl57 = shl i64 %77, 55 + %ashr58 = ashr i64 %shl57, 58 + %78 = trunc i64 %ashr58 to i32 + call void (ptr, ...) @printf(ptr @.str.7, i32 %76, i32 %78) + %79 = load i64, ptr %xx, align 8 + %shl59 = shl i64 %79, 55 + %ashr60 = ashr i64 %shl59, 58 + %80 = trunc i64 %ashr60 to i32 + %smod = srem i32 %80, 2 + %81 = load i64, ptr %xx, align 8 + %zext61 = zext i32 %smod to i64 + %shl62 = shl i64 %zext61, 3 + %82 = and i64 %shl62, 504 + %83 = and i64 %81, -505 + %84 = or i64 %83, %82 + store i64 %84, ptr %xx, align 8 + %85 = load i64, ptr %xx, align 8 + %shl63 = shl i64 %85, 61 + %ashr64 = ashr i64 %shl63, 61 + %86 = trunc i64 %ashr64 to i32 %87 = load i64, ptr %xx, align 8 - %88 = zext i32 %86 to i64 - %89 = shl i64 %88, 3 - %90 = and i64 %89, 504 - %91 = and i64 %87, -505 - %92 = or i64 %91, %90 - store i64 %92, ptr %xx, align 8 - %93 = load i64, ptr %xx, align 8 - %94 = shl i64 %93, 61 - %95 = ashr i64 %94, 61 - %96 = trunc i64 %95 to i32 - %97 = load i64, ptr %xx, align 8 - %98 = shl i64 %97, 55 - %99 = ashr i64 %98, 58 - %100 = trunc i64 %99 to i32 - call void (ptr, ...) @printf(ptr @.str.5, i32 %96, i32 %100) - %101 = load i64, ptr %xx, align 8 - %102 = shl i64 %101, 55 - %103 = ashr i64 %102, 58 - %104 = trunc i64 %103 to i32 - %ashr = ashr i32 %104, 1 - %105 = freeze i32 %ashr - %106 = load i64, ptr %xx, align 8 - %107 = zext i32 %105 to i64 - %108 = shl i64 %107, 3 - %109 = and i64 %108, 504 - %110 = and i64 %106, -505 - %111 = or i64 %110, %109 - store i64 %111, ptr %xx, align 8 - %112 = load i64, ptr %xx, align 8 - %113 = shl i64 %112, 61 - %114 = ashr i64 %113, 61 - %115 = trunc i64 %114 to i32 - %116 = load i64, ptr %xx, align 8 - %117 = shl i64 %116, 55 - %118 = ashr i64 %117, 58 - %119 = trunc i64 %118 to i32 - call void (ptr, ...) @printf(ptr @.str.6, i32 %115, i32 %119) - %120 = load i64, ptr %xx, align 8 - %121 = shl i64 %120, 55 - %122 = ashr i64 %121, 58 - %123 = trunc i64 %122 to i32 - %sdiv = sdiv i32 %123, 2 - %124 = load i64, ptr %xx, align 8 - %125 = zext i32 %sdiv to i64 - %126 = shl i64 %125, 3 - %127 = and i64 %126, 504 - %128 = and i64 %124, -505 - %129 = or i64 %128, %127 - store i64 %129, ptr %xx, align 8 - %130 = load i64, ptr %xx, align 8 - %131 = shl i64 %130, 61 - %132 = ashr i64 %131, 61 - %133 = trunc i64 %132 to i32 - %134 = load i64, ptr %xx, align 8 - %135 = shl i64 %134, 55 - %136 = ashr i64 %135, 58 - %137 = trunc i64 %136 to i32 - call void (ptr, ...) @printf(ptr @.str.7, i32 %133, i32 %137) - %138 = load i64, ptr %xx, align 8 - %139 = shl i64 %138, 55 - %140 = ashr i64 %139, 58 - %141 = trunc i64 %140 to i32 - %smod = srem i32 %141, 2 - %142 = load i64, ptr %xx, align 8 - %143 = zext i32 %smod to i64 - %144 = shl i64 %143, 3 - %145 = and i64 %144, 504 - %146 = and i64 %142, -505 - %147 = or i64 %146, %145 - store i64 %147, ptr %xx, align 8 - %148 = load i64, ptr %xx, align 8 - %149 = shl i64 %148, 61 - %150 = ashr i64 %149, 61 - %151 = trunc i64 %150 to i32 - %152 = load i64, ptr %xx, align 8 - %153 = shl i64 %152, 55 - %154 = ashr i64 %153, 58 - %155 = trunc i64 %154 to i32 - call void (ptr, ...) @printf(ptr @.str.8, i32 %151, i32 %155) - %156 = load i64, ptr %xx, align 8 - %157 = and i64 %156, -1048577 - %158 = or i64 %157, 1048576 - store i64 %158, ptr %xx, align 8 - %159 = load i64, ptr %xx, align 8 - %160 = lshr i64 %159, 20 - %161 = and i64 1, %160 - %162 = trunc i64 %161 to i8 - %163 = trunc i8 %162 to i1 - %boolsi = zext i1 %163 to i32 + %shl65 = shl i64 %87, 55 + %ashr66 = ashr i64 %shl65, 58 + %88 = trunc i64 %ashr66 to i32 + call void (ptr, ...) @printf(ptr @.str.8, i32 %86, i32 %88) + %89 = load i64, ptr %xx, align 8 + %90 = and i64 %89, -1048577 + %91 = or i64 %90, 1048576 + store i64 %91, ptr %xx, align 8 + %92 = load i64, ptr %xx, align 8 + %lshrl = lshr i64 %92, 20 + %93 = and i64 1, %lshrl + %ztrunc = trunc i64 %93 to i8 + %94 = trunc i8 %ztrunc to i1 + %boolsi = zext i1 %94 to i32 call void (ptr, ...) @printf(ptr @.str.9, i32 %boolsi) - %164 = load i64, ptr %xx, align 8 - %165 = and i64 %164, -1048577 - store i64 %165, ptr %xx, align 8 - %166 = load i64, ptr %xx, align 8 - %167 = lshr i64 %166, 20 - %168 = and i64 1, %167 - %169 = trunc i64 %168 to i8 - %170 = trunc i8 %169 to i1 - %boolsi1 = zext i1 %170 to i32 - call void (ptr, ...) @printf(ptr @.str.10, i32 %boolsi1) + %95 = load i64, ptr %xx, align 8 + %96 = and i64 %95, -1048577 + store i64 %96, ptr %xx, align 8 + %97 = load i64, ptr %xx, align 8 + %lshrl67 = lshr i64 %97, 20 + %98 = and i64 1, %lshrl67 + %ztrunc68 = trunc i64 %98 to i8 + %99 = trunc i8 %ztrunc68 to i1 + %boolsi69 = zext i1 %99 to i32 + call void (ptr, ...) @printf(ptr @.str.10, i32 %boolsi69) ret void } @@ -353,388 +353,388 @@ entry: store i8 %3, ptr %0, align 1 %4 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 %5 = load i8, ptr %4, align 1 - %6 = zext i8 %5 to i32 - %7 = shl i32 %6, 29 - %8 = ashr i32 %7, 29 - %9 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %10 = load i8, ptr %9, align 1 - %11 = zext i8 %10 to i32 - %12 = lshr i32 %11, 3 - %13 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %14 = load i8, ptr %13, align 1 - %15 = zext i8 %14 to i32 - %16 = shl i32 %15, 5 - %17 = or i32 %16, %12 - %18 = shl i32 %17, 26 - %19 = ashr i32 %18, 26 - call void (ptr, ...) @printf(ptr @.str.11, i32 %8, i32 %19) + %zext = zext i8 %5 to i32 + %shl = shl i32 %zext, 29 + %ashr = ashr i32 %shl, 29 + %6 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %7 = load i8, ptr %6, align 1 + %zext1 = zext i8 %7 to i32 + %lshrl = lshr i32 %zext1, 3 + %8 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %9 = load i8, ptr %8, align 1 + %zext2 = zext i8 %9 to i32 + %shl3 = shl i32 %zext2, 5 + %10 = or i32 %shl3, %lshrl + %shl4 = shl i32 %10, 26 + %ashr5 = ashr i32 %shl4, 26 + call void (ptr, ...) @printf(ptr @.str.11, i32 %ashr, i32 %ashr5) + %11 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %12 = load i8, ptr %11, align 1 + %zext6 = zext i8 %12 to i32 + %shl7 = shl i32 %zext6, 29 + %ashr8 = ashr i32 %shl7, 29 + %sub = sub i32 %ashr8, 1 + %13 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %ztrunc = trunc i32 %sub to i8 + %14 = and i8 %ztrunc, 7 + %15 = load i8, ptr %13, align 1 + %16 = and i8 %15, -8 + %17 = or i8 %16, %14 + store i8 %17, ptr %13, align 1 + %18 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %19 = load i8, ptr %18, align 1 + %zext9 = zext i8 %19 to i32 + %shl10 = shl i32 %zext9, 29 + %ashr11 = ashr i32 %shl10, 29 %20 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 %21 = load i8, ptr %20, align 1 - %22 = zext i8 %21 to i32 - %23 = shl i32 %22, 29 - %24 = ashr i32 %23, 29 - %sub = sub i32 %24, 1 + %zext12 = zext i8 %21 to i32 + %lshrl13 = lshr i32 %zext12, 3 + %22 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %23 = load i8, ptr %22, align 1 + %zext14 = zext i8 %23 to i32 + %shl15 = shl i32 %zext14, 5 + %24 = or i32 %shl15, %lshrl13 + %shl16 = shl i32 %24, 26 + %ashr17 = ashr i32 %shl16, 26 + call void (ptr, ...) @printf(ptr @.str.12, i32 %ashr11, i32 %ashr17) %25 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %26 = trunc i32 %sub to i8 - %27 = and i8 %26, 7 - %28 = load i8, ptr %25, align 1 - %29 = and i8 %28, -8 - %30 = or i8 %29, %27 - store i8 %30, ptr %25, align 1 - %31 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %32 = load i8, ptr %31, align 1 - %33 = zext i8 %32 to i32 - %34 = shl i32 %33, 29 - %35 = ashr i32 %34, 29 - %36 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %37 = load i8, ptr %36, align 1 - %38 = zext i8 %37 to i32 - %39 = lshr i32 %38, 3 - %40 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %41 = load i8, ptr %40, align 1 - %42 = zext i8 %41 to i32 - %43 = shl i32 %42, 5 - %44 = or i32 %43, %39 - %45 = shl i32 %44, 26 - %46 = ashr i32 %45, 26 - call void (ptr, ...) @printf(ptr @.str.12, i32 %35, i32 %46) - %47 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %48 = load i8, ptr %47, align 1 - %49 = zext i8 %48 to i32 - %50 = lshr i32 %49, 3 - %51 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %26 = load i8, ptr %25, align 1 + %zext18 = zext i8 %26 to i32 + %lshrl19 = lshr i32 %zext18, 3 + %27 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %28 = load i8, ptr %27, align 1 + %zext20 = zext i8 %28 to i32 + %shl21 = shl i32 %zext20, 5 + %29 = or i32 %shl21, %lshrl19 + %shl22 = shl i32 %29, 26 + %ashr23 = ashr i32 %shl22, 26 + %mul = mul i32 %ashr23, 2 + %30 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl24 = shl i32 %mul, 3 + %ztrunc25 = trunc i32 %shl24 to i8 + %31 = load i8, ptr %30, align 1 + %32 = and i8 %31, 7 + %33 = or i8 %32, %ztrunc25 + store i8 %33, ptr %30, align 1 + %lshrl26 = lshr i32 %mul, 5 + %34 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc27 = trunc i32 %lshrl26 to i8 + %35 = and i8 %ztrunc27, 1 + %36 = load i8, ptr %34, align 1 + %37 = and i8 %36, -2 + %38 = or i8 %37, %35 + store i8 %38, ptr %34, align 1 + %39 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %40 = load i8, ptr %39, align 1 + %zext28 = zext i8 %40 to i32 + %shl29 = shl i32 %zext28, 29 + %ashr30 = ashr i32 %shl29, 29 + %41 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %42 = load i8, ptr %41, align 1 + %zext31 = zext i8 %42 to i32 + %lshrl32 = lshr i32 %zext31, 3 + %43 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %44 = load i8, ptr %43, align 1 + %zext33 = zext i8 %44 to i32 + %shl34 = shl i32 %zext33, 5 + %45 = or i32 %shl34, %lshrl32 + %shl35 = shl i32 %45, 26 + %ashr36 = ashr i32 %shl35, 26 + call void (ptr, ...) @printf(ptr @.str.13, i32 %ashr30, i32 %ashr36) + %46 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %47 = load i8, ptr %46, align 1 + %zext37 = zext i8 %47 to i32 + %lshrl38 = lshr i32 %zext37, 3 + %48 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %49 = load i8, ptr %48, align 1 + %zext39 = zext i8 %49 to i32 + %shl40 = shl i32 %zext39, 5 + %50 = or i32 %shl40, %lshrl38 + %shl41 = shl i32 %50, 26 + %ashr42 = ashr i32 %shl41, 26 + %xor = xor i32 %ashr42, 4 + %51 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl43 = shl i32 %xor, 3 + %ztrunc44 = trunc i32 %shl43 to i8 %52 = load i8, ptr %51, align 1 - %53 = zext i8 %52 to i32 - %54 = shl i32 %53, 5 - %55 = or i32 %54, %50 - %56 = shl i32 %55, 26 - %57 = ashr i32 %56, 26 - %mul = mul i32 %57, 2 - %58 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %59 = shl i32 %mul, 3 - %60 = trunc i32 %59 to i8 - %61 = load i8, ptr %58, align 1 - %62 = and i8 %61, 7 - %63 = or i8 %62, %60 - store i8 %63, ptr %58, align 1 - %64 = lshr i32 %mul, 5 - %65 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %66 = trunc i32 %64 to i8 - %67 = and i8 %66, 1 - %68 = load i8, ptr %65, align 1 - %69 = and i8 %68, -2 - %70 = or i8 %69, %67 - store i8 %70, ptr %65, align 1 - %71 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %72 = load i8, ptr %71, align 1 - %73 = zext i8 %72 to i32 - %74 = shl i32 %73, 29 - %75 = ashr i32 %74, 29 - %76 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %77 = load i8, ptr %76, align 1 - %78 = zext i8 %77 to i32 - %79 = lshr i32 %78, 3 - %80 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %81 = load i8, ptr %80, align 1 - %82 = zext i8 %81 to i32 - %83 = shl i32 %82, 5 - %84 = or i32 %83, %79 - %85 = shl i32 %84, 26 - %86 = ashr i32 %85, 26 - call void (ptr, ...) @printf(ptr @.str.13, i32 %75, i32 %86) - %87 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %88 = load i8, ptr %87, align 1 - %89 = zext i8 %88 to i32 - %90 = lshr i32 %89, 3 - %91 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %92 = load i8, ptr %91, align 1 - %93 = zext i8 %92 to i32 - %94 = shl i32 %93, 5 - %95 = or i32 %94, %90 - %96 = shl i32 %95, 26 - %97 = ashr i32 %96, 26 - %xor = xor i32 %97, 4 - %98 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %99 = shl i32 %xor, 3 - %100 = trunc i32 %99 to i8 - %101 = load i8, ptr %98, align 1 - %102 = and i8 %101, 7 - %103 = or i8 %102, %100 - store i8 %103, ptr %98, align 1 - %104 = lshr i32 %xor, 5 - %105 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %106 = trunc i32 %104 to i8 - %107 = and i8 %106, 1 - %108 = load i8, ptr %105, align 1 - %109 = and i8 %108, -2 - %110 = or i8 %109, %107 - store i8 %110, ptr %105, align 1 - %111 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %112 = load i8, ptr %111, align 1 - %113 = zext i8 %112 to i32 - %114 = shl i32 %113, 29 - %115 = ashr i32 %114, 29 + %53 = and i8 %52, 7 + %54 = or i8 %53, %ztrunc44 + store i8 %54, ptr %51, align 1 + %lshrl45 = lshr i32 %xor, 5 + %55 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc46 = trunc i32 %lshrl45 to i8 + %56 = and i8 %ztrunc46, 1 + %57 = load i8, ptr %55, align 1 + %58 = and i8 %57, -2 + %59 = or i8 %58, %56 + store i8 %59, ptr %55, align 1 + %60 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %61 = load i8, ptr %60, align 1 + %zext47 = zext i8 %61 to i32 + %shl48 = shl i32 %zext47, 29 + %ashr49 = ashr i32 %shl48, 29 + %62 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %63 = load i8, ptr %62, align 1 + %zext50 = zext i8 %63 to i32 + %lshrl51 = lshr i32 %zext50, 3 + %64 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %65 = load i8, ptr %64, align 1 + %zext52 = zext i8 %65 to i32 + %shl53 = shl i32 %zext52, 5 + %66 = or i32 %shl53, %lshrl51 + %shl54 = shl i32 %66, 26 + %ashr55 = ashr i32 %shl54, 26 + call void (ptr, ...) @printf(ptr @.str.14, i32 %ashr49, i32 %ashr55) + %67 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %68 = load i8, ptr %67, align 1 + %zext56 = zext i8 %68 to i32 + %lshrl57 = lshr i32 %zext56, 3 + %69 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %70 = load i8, ptr %69, align 1 + %zext58 = zext i8 %70 to i32 + %shl59 = shl i32 %zext58, 5 + %71 = or i32 %shl59, %lshrl57 + %shl60 = shl i32 %71, 26 + %ashr61 = ashr i32 %shl60, 26 + %or = or i32 %ashr61, 4 + %72 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl62 = shl i32 %or, 3 + %ztrunc63 = trunc i32 %shl62 to i8 + %73 = load i8, ptr %72, align 1 + %74 = and i8 %73, 7 + %75 = or i8 %74, %ztrunc63 + store i8 %75, ptr %72, align 1 + %lshrl64 = lshr i32 %or, 5 + %76 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc65 = trunc i32 %lshrl64 to i8 + %77 = and i8 %ztrunc65, 1 + %78 = load i8, ptr %76, align 1 + %79 = and i8 %78, -2 + %80 = or i8 %79, %77 + store i8 %80, ptr %76, align 1 + %81 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %82 = load i8, ptr %81, align 1 + %zext66 = zext i8 %82 to i32 + %shl67 = shl i32 %zext66, 29 + %ashr68 = ashr i32 %shl67, 29 + %83 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %84 = load i8, ptr %83, align 1 + %zext69 = zext i8 %84 to i32 + %lshrl70 = lshr i32 %zext69, 3 + %85 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %86 = load i8, ptr %85, align 1 + %zext71 = zext i8 %86 to i32 + %shl72 = shl i32 %zext71, 5 + %87 = or i32 %shl72, %lshrl70 + %shl73 = shl i32 %87, 26 + %ashr74 = ashr i32 %shl73, 26 + call void (ptr, ...) @printf(ptr @.str.15, i32 %ashr68, i32 %ashr74) + %88 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %89 = load i8, ptr %88, align 1 + %zext75 = zext i8 %89 to i32 + %lshrl76 = lshr i32 %zext75, 3 + %90 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %91 = load i8, ptr %90, align 1 + %zext77 = zext i8 %91 to i32 + %shl78 = shl i32 %zext77, 5 + %92 = or i32 %shl78, %lshrl76 + %shl79 = shl i32 %92, 26 + %ashr80 = ashr i32 %shl79, 26 + %shl81 = shl i32 %ashr80, 1 + %93 = freeze i32 %shl81 + %94 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl82 = shl i32 %93, 3 + %ztrunc83 = trunc i32 %shl82 to i8 + %95 = load i8, ptr %94, align 1 + %96 = and i8 %95, 7 + %97 = or i8 %96, %ztrunc83 + store i8 %97, ptr %94, align 1 + %lshrl84 = lshr i32 %93, 5 + %98 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc85 = trunc i32 %lshrl84 to i8 + %99 = and i8 %ztrunc85, 1 + %100 = load i8, ptr %98, align 1 + %101 = and i8 %100, -2 + %102 = or i8 %101, %99 + store i8 %102, ptr %98, align 1 + %103 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %104 = load i8, ptr %103, align 1 + %zext86 = zext i8 %104 to i32 + %shl87 = shl i32 %zext86, 29 + %ashr88 = ashr i32 %shl87, 29 + %105 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %106 = load i8, ptr %105, align 1 + %zext89 = zext i8 %106 to i32 + %lshrl90 = lshr i32 %zext89, 3 + %107 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %108 = load i8, ptr %107, align 1 + %zext91 = zext i8 %108 to i32 + %shl92 = shl i32 %zext91, 5 + %109 = or i32 %shl92, %lshrl90 + %shl93 = shl i32 %109, 26 + %ashr94 = ashr i32 %shl93, 26 + call void (ptr, ...) @printf(ptr @.str.16, i32 %ashr88, i32 %ashr94) + %110 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %111 = load i8, ptr %110, align 1 + %zext95 = zext i8 %111 to i32 + %lshrl96 = lshr i32 %zext95, 3 + %112 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %113 = load i8, ptr %112, align 1 + %zext97 = zext i8 %113 to i32 + %shl98 = shl i32 %zext97, 5 + %114 = or i32 %shl98, %lshrl96 + %shl99 = shl i32 %114, 26 + %ashr100 = ashr i32 %shl99, 26 + %ashr101 = ashr i32 %ashr100, 1 + %115 = freeze i32 %ashr101 %116 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl102 = shl i32 %115, 3 + %ztrunc103 = trunc i32 %shl102 to i8 %117 = load i8, ptr %116, align 1 - %118 = zext i8 %117 to i32 - %119 = lshr i32 %118, 3 + %118 = and i8 %117, 7 + %119 = or i8 %118, %ztrunc103 + store i8 %119, ptr %116, align 1 + %lshrl104 = lshr i32 %115, 5 %120 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %121 = load i8, ptr %120, align 1 - %122 = zext i8 %121 to i32 - %123 = shl i32 %122, 5 - %124 = or i32 %123, %119 - %125 = shl i32 %124, 26 - %126 = ashr i32 %125, 26 - call void (ptr, ...) @printf(ptr @.str.14, i32 %115, i32 %126) + %ztrunc105 = trunc i32 %lshrl104 to i8 + %121 = and i8 %ztrunc105, 1 + %122 = load i8, ptr %120, align 1 + %123 = and i8 %122, -2 + %124 = or i8 %123, %121 + store i8 %124, ptr %120, align 1 + %125 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %126 = load i8, ptr %125, align 1 + %zext106 = zext i8 %126 to i32 + %shl107 = shl i32 %zext106, 29 + %ashr108 = ashr i32 %shl107, 29 %127 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 %128 = load i8, ptr %127, align 1 - %129 = zext i8 %128 to i32 - %130 = lshr i32 %129, 3 - %131 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %132 = load i8, ptr %131, align 1 - %133 = zext i8 %132 to i32 - %134 = shl i32 %133, 5 - %135 = or i32 %134, %130 - %136 = shl i32 %135, 26 - %137 = ashr i32 %136, 26 - %or = or i32 %137, 4 - %138 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %139 = shl i32 %or, 3 - %140 = trunc i32 %139 to i8 - %141 = load i8, ptr %138, align 1 - %142 = and i8 %141, 7 - %143 = or i8 %142, %140 - store i8 %143, ptr %138, align 1 - %144 = lshr i32 %or, 5 - %145 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %146 = trunc i32 %144 to i8 - %147 = and i8 %146, 1 - %148 = load i8, ptr %145, align 1 - %149 = and i8 %148, -2 - %150 = or i8 %149, %147 - store i8 %150, ptr %145, align 1 - %151 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %152 = load i8, ptr %151, align 1 - %153 = zext i8 %152 to i32 - %154 = shl i32 %153, 29 - %155 = ashr i32 %154, 29 - %156 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %157 = load i8, ptr %156, align 1 - %158 = zext i8 %157 to i32 - %159 = lshr i32 %158, 3 - %160 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %161 = load i8, ptr %160, align 1 - %162 = zext i8 %161 to i32 - %163 = shl i32 %162, 5 - %164 = or i32 %163, %159 - %165 = shl i32 %164, 26 - %166 = ashr i32 %165, 26 - call void (ptr, ...) @printf(ptr @.str.15, i32 %155, i32 %166) + %zext109 = zext i8 %128 to i32 + %lshrl110 = lshr i32 %zext109, 3 + %129 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %130 = load i8, ptr %129, align 1 + %zext111 = zext i8 %130 to i32 + %shl112 = shl i32 %zext111, 5 + %131 = or i32 %shl112, %lshrl110 + %shl113 = shl i32 %131, 26 + %ashr114 = ashr i32 %shl113, 26 + call void (ptr, ...) @printf(ptr @.str.17, i32 %ashr108, i32 %ashr114) + %132 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %133 = load i8, ptr %132, align 1 + %zext115 = zext i8 %133 to i32 + %lshrl116 = lshr i32 %zext115, 3 + %134 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %135 = load i8, ptr %134, align 1 + %zext117 = zext i8 %135 to i32 + %shl118 = shl i32 %zext117, 5 + %136 = or i32 %shl118, %lshrl116 + %shl119 = shl i32 %136, 26 + %ashr120 = ashr i32 %shl119, 26 + %sdiv = sdiv i32 %ashr120, 2 + %137 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl121 = shl i32 %sdiv, 3 + %ztrunc122 = trunc i32 %shl121 to i8 + %138 = load i8, ptr %137, align 1 + %139 = and i8 %138, 7 + %140 = or i8 %139, %ztrunc122 + store i8 %140, ptr %137, align 1 + %lshrl123 = lshr i32 %sdiv, 5 + %141 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc124 = trunc i32 %lshrl123 to i8 + %142 = and i8 %ztrunc124, 1 + %143 = load i8, ptr %141, align 1 + %144 = and i8 %143, -2 + %145 = or i8 %144, %142 + store i8 %145, ptr %141, align 1 + %146 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %147 = load i8, ptr %146, align 1 + %zext125 = zext i8 %147 to i32 + %shl126 = shl i32 %zext125, 29 + %ashr127 = ashr i32 %shl126, 29 + %148 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %149 = load i8, ptr %148, align 1 + %zext128 = zext i8 %149 to i32 + %lshrl129 = lshr i32 %zext128, 3 + %150 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %151 = load i8, ptr %150, align 1 + %zext130 = zext i8 %151 to i32 + %shl131 = shl i32 %zext130, 5 + %152 = or i32 %shl131, %lshrl129 + %shl132 = shl i32 %152, 26 + %ashr133 = ashr i32 %shl132, 26 + call void (ptr, ...) @printf(ptr @.str.18, i32 %ashr127, i32 %ashr133) + %153 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %154 = load i8, ptr %153, align 1 + %zext134 = zext i8 %154 to i32 + %lshrl135 = lshr i32 %zext134, 3 + %155 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %156 = load i8, ptr %155, align 1 + %zext136 = zext i8 %156 to i32 + %shl137 = shl i32 %zext136, 5 + %157 = or i32 %shl137, %lshrl135 + %shl138 = shl i32 %157, 26 + %ashr139 = ashr i32 %shl138, 26 + %smod = srem i32 %ashr139, 2 + %158 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl140 = shl i32 %smod, 3 + %ztrunc141 = trunc i32 %shl140 to i8 + %159 = load i8, ptr %158, align 1 + %160 = and i8 %159, 7 + %161 = or i8 %160, %ztrunc141 + store i8 %161, ptr %158, align 1 + %lshrl142 = lshr i32 %smod, 5 + %162 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc143 = trunc i32 %lshrl142 to i8 + %163 = and i8 %ztrunc143, 1 + %164 = load i8, ptr %162, align 1 + %165 = and i8 %164, -2 + %166 = or i8 %165, %163 + store i8 %166, ptr %162, align 1 %167 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 %168 = load i8, ptr %167, align 1 - %169 = zext i8 %168 to i32 - %170 = lshr i32 %169, 3 + %zext144 = zext i8 %168 to i32 + %shl145 = shl i32 %zext144, 29 + %ashr146 = ashr i32 %shl145, 29 + %169 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %170 = load i8, ptr %169, align 1 + %zext147 = zext i8 %170 to i32 + %lshrl148 = lshr i32 %zext147, 3 %171 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 %172 = load i8, ptr %171, align 1 - %173 = zext i8 %172 to i32 - %174 = shl i32 %173, 5 - %175 = or i32 %174, %170 - %176 = shl i32 %175, 26 - %177 = ashr i32 %176, 26 - %shl = shl i32 %177, 1 - %178 = freeze i32 %shl - %179 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %180 = shl i32 %178, 3 - %181 = trunc i32 %180 to i8 - %182 = load i8, ptr %179, align 1 - %183 = and i8 %182, 7 - %184 = or i8 %183, %181 - store i8 %184, ptr %179, align 1 - %185 = lshr i32 %178, 5 - %186 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %187 = trunc i32 %185 to i8 - %188 = and i8 %187, 1 - %189 = load i8, ptr %186, align 1 - %190 = and i8 %189, -2 - %191 = or i8 %190, %188 - store i8 %191, ptr %186, align 1 - %192 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %193 = load i8, ptr %192, align 1 - %194 = zext i8 %193 to i32 - %195 = shl i32 %194, 29 - %196 = ashr i32 %195, 29 - %197 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %198 = load i8, ptr %197, align 1 - %199 = zext i8 %198 to i32 - %200 = lshr i32 %199, 3 - %201 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %202 = load i8, ptr %201, align 1 - %203 = zext i8 %202 to i32 - %204 = shl i32 %203, 5 - %205 = or i32 %204, %200 - %206 = shl i32 %205, 26 - %207 = ashr i32 %206, 26 - call void (ptr, ...) @printf(ptr @.str.16, i32 %196, i32 %207) - %208 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %209 = load i8, ptr %208, align 1 - %210 = zext i8 %209 to i32 - %211 = lshr i32 %210, 3 - %212 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %213 = load i8, ptr %212, align 1 - %214 = zext i8 %213 to i32 - %215 = shl i32 %214, 5 - %216 = or i32 %215, %211 - %217 = shl i32 %216, 26 - %218 = ashr i32 %217, 26 - %ashr = ashr i32 %218, 1 - %219 = freeze i32 %ashr - %220 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %221 = shl i32 %219, 3 - %222 = trunc i32 %221 to i8 - %223 = load i8, ptr %220, align 1 - %224 = and i8 %223, 7 - %225 = or i8 %224, %222 - store i8 %225, ptr %220, align 1 - %226 = lshr i32 %219, 5 - %227 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %228 = trunc i32 %226 to i8 - %229 = and i8 %228, 1 - %230 = load i8, ptr %227, align 1 - %231 = and i8 %230, -2 - %232 = or i8 %231, %229 - store i8 %232, ptr %227, align 1 - %233 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %234 = load i8, ptr %233, align 1 - %235 = zext i8 %234 to i32 - %236 = shl i32 %235, 29 - %237 = ashr i32 %236, 29 - %238 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %239 = load i8, ptr %238, align 1 - %240 = zext i8 %239 to i32 - %241 = lshr i32 %240, 3 - %242 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %243 = load i8, ptr %242, align 1 - %244 = zext i8 %243 to i32 - %245 = shl i32 %244, 5 - %246 = or i32 %245, %241 - %247 = shl i32 %246, 26 - %248 = ashr i32 %247, 26 - call void (ptr, ...) @printf(ptr @.str.17, i32 %237, i32 %248) - %249 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %250 = load i8, ptr %249, align 1 - %251 = zext i8 %250 to i32 - %252 = lshr i32 %251, 3 - %253 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %254 = load i8, ptr %253, align 1 - %255 = zext i8 %254 to i32 - %256 = shl i32 %255, 5 - %257 = or i32 %256, %252 - %258 = shl i32 %257, 26 - %259 = ashr i32 %258, 26 - %sdiv = sdiv i32 %259, 2 - %260 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %261 = shl i32 %sdiv, 3 - %262 = trunc i32 %261 to i8 - %263 = load i8, ptr %260, align 1 - %264 = and i8 %263, 7 - %265 = or i8 %264, %262 - store i8 %265, ptr %260, align 1 - %266 = lshr i32 %sdiv, 5 - %267 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %268 = trunc i32 %266 to i8 - %269 = and i8 %268, 1 - %270 = load i8, ptr %267, align 1 - %271 = and i8 %270, -2 - %272 = or i8 %271, %269 - store i8 %272, ptr %267, align 1 - %273 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %274 = load i8, ptr %273, align 1 - %275 = zext i8 %274 to i32 - %276 = shl i32 %275, 29 - %277 = ashr i32 %276, 29 - %278 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %279 = load i8, ptr %278, align 1 - %280 = zext i8 %279 to i32 - %281 = lshr i32 %280, 3 - %282 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %283 = load i8, ptr %282, align 1 - %284 = zext i8 %283 to i32 - %285 = shl i32 %284, 5 - %286 = or i32 %285, %281 - %287 = shl i32 %286, 26 - %288 = ashr i32 %287, 26 - call void (ptr, ...) @printf(ptr @.str.18, i32 %277, i32 %288) - %289 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %290 = load i8, ptr %289, align 1 - %291 = zext i8 %290 to i32 - %292 = lshr i32 %291, 3 - %293 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %294 = load i8, ptr %293, align 1 - %295 = zext i8 %294 to i32 - %296 = shl i32 %295, 5 - %297 = or i32 %296, %292 - %298 = shl i32 %297, 26 - %299 = ashr i32 %298, 26 - %smod = srem i32 %299, 2 - %300 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %301 = shl i32 %smod, 3 - %302 = trunc i32 %301 to i8 - %303 = load i8, ptr %300, align 1 - %304 = and i8 %303, 7 - %305 = or i8 %304, %302 - store i8 %305, ptr %300, align 1 - %306 = lshr i32 %smod, 5 - %307 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %308 = trunc i32 %306 to i8 - %309 = and i8 %308, 1 - %310 = load i8, ptr %307, align 1 - %311 = and i8 %310, -2 - %312 = or i8 %311, %309 - store i8 %312, ptr %307, align 1 - %313 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %314 = load i8, ptr %313, align 1 - %315 = zext i8 %314 to i32 - %316 = shl i32 %315, 29 - %317 = ashr i32 %316, 29 - %318 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %319 = load i8, ptr %318, align 1 - %320 = zext i8 %319 to i32 - %321 = lshr i32 %320, 3 - %322 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %323 = load i8, ptr %322, align 1 - %324 = zext i8 %323 to i32 - %325 = shl i32 %324, 5 - %326 = or i32 %325, %321 - %327 = shl i32 %326, 26 - %328 = ashr i32 %327, 26 - call void (ptr, ...) @printf(ptr @.str.19, i32 %317, i32 %328) - %329 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %330 = load i8, ptr %329, align 1 - %331 = lshr i8 %330, 4 - %332 = trunc i8 %331 to i1 - %boolsi = zext i1 %332 to i32 + %zext149 = zext i8 %172 to i32 + %shl150 = shl i32 %zext149, 5 + %173 = or i32 %shl150, %lshrl148 + %shl151 = shl i32 %173, 26 + %ashr152 = ashr i32 %shl151, 26 + call void (ptr, ...) @printf(ptr @.str.19, i32 %ashr146, i32 %ashr152) + %174 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %175 = load i8, ptr %174, align 1 + %lshrl153 = lshr i8 %175, 4 + %176 = trunc i8 %lshrl153 to i1 + %boolsi = zext i1 %176 to i32 call void (ptr, ...) @printf(ptr @.str.20, i32 %boolsi) - %333 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %334 = load i8, ptr %333, align 1 - %335 = and i8 %334, -17 - %336 = or i8 %335, 16 - store i8 %336, ptr %333, align 1 - %337 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %338 = load i8, ptr %337, align 1 - %339 = lshr i8 %338, 4 - %340 = trunc i8 %339 to i1 - %boolsi1 = zext i1 %340 to i32 - call void (ptr, ...) @printf(ptr @.str.21, i32 %boolsi1) - %341 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %342 = load i8, ptr %341, align 1 - %343 = and i8 %342, -17 - store i8 %343, ptr %341, align 1 - %344 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %345 = load i8, ptr %344, align 1 - %346 = lshr i8 %345, 4 - %347 = trunc i8 %346 to i1 - %boolsi2 = zext i1 %347 to i32 - call void (ptr, ...) @printf(ptr @.str.22, i32 %boolsi2) + %177 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %178 = load i8, ptr %177, align 1 + %179 = and i8 %178, -17 + %180 = or i8 %179, 16 + store i8 %180, ptr %177, align 1 + %181 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %182 = load i8, ptr %181, align 1 + %lshrl154 = lshr i8 %182, 4 + %183 = trunc i8 %lshrl154 to i1 + %boolsi155 = zext i1 %183 to i32 + call void (ptr, ...) @printf(ptr @.str.21, i32 %boolsi155) + %184 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %185 = load i8, ptr %184, align 1 + %186 = and i8 %185, -17 + store i8 %186, ptr %184, align 1 + %187 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %188 = load i8, ptr %187, align 1 + %lshrl156 = lshr i8 %188, 4 + %189 = trunc i8 %lshrl156 to i1 + %boolsi157 = zext i1 %189 to i32 + call void (ptr, ...) @printf(ptr @.str.22, i32 %boolsi157) ret void } @@ -750,399 +750,399 @@ entry: store i8 %3, ptr %0, align 1 %4 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 %5 = load i8, ptr %4, align 1 - %6 = zext i8 %5 to i32 - %7 = lshr i32 %6, 1 - %8 = shl i32 %7, 29 - %9 = ashr i32 %8, 29 - %10 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %11 = load i8, ptr %10, align 1 - %12 = zext i8 %11 to i32 - %13 = lshr i32 %12, 4 - %14 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %15 = load i8, ptr %14, align 1 - %16 = zext i8 %15 to i32 - %17 = shl i32 %16, 4 - %18 = or i32 %17, %13 - %19 = shl i32 %18, 26 - %20 = ashr i32 %19, 26 - call void (ptr, ...) @printf(ptr @.str.23, i32 %9, i32 %20) - %21 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %22 = load i8, ptr %21, align 1 - %23 = zext i8 %22 to i32 - %24 = lshr i32 %23, 1 - %25 = shl i32 %24, 29 - %26 = ashr i32 %25, 29 - %sub = sub i32 %26, 1 - %27 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %28 = shl i32 %sub, 1 - %29 = trunc i32 %28 to i8 - %30 = and i8 %29, 15 - %31 = load i8, ptr %27, align 1 - %32 = and i8 %31, -15 - %33 = or i8 %32, %30 - store i8 %33, ptr %27, align 1 - %34 = lshr i32 %sub, 7 - %35 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %36 = load i8, ptr %35, align 1 - %37 = zext i8 %36 to i32 - %38 = lshr i32 %37, 1 - %39 = shl i32 %38, 29 - %40 = ashr i32 %39, 29 + %zext = zext i8 %5 to i32 + %lshrl = lshr i32 %zext, 1 + %shl = shl i32 %lshrl, 29 + %ashr = ashr i32 %shl, 29 + %6 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %7 = load i8, ptr %6, align 1 + %zext1 = zext i8 %7 to i32 + %lshrl2 = lshr i32 %zext1, 4 + %8 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %9 = load i8, ptr %8, align 1 + %zext3 = zext i8 %9 to i32 + %shl4 = shl i32 %zext3, 4 + %10 = or i32 %shl4, %lshrl2 + %shl5 = shl i32 %10, 26 + %ashr6 = ashr i32 %shl5, 26 + call void (ptr, ...) @printf(ptr @.str.23, i32 %ashr, i32 %ashr6) + %11 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %12 = load i8, ptr %11, align 1 + %zext7 = zext i8 %12 to i32 + %lshrl8 = lshr i32 %zext7, 1 + %shl9 = shl i32 %lshrl8, 29 + %ashr10 = ashr i32 %shl9, 29 + %sub = sub i32 %ashr10, 1 + %13 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl11 = shl i32 %sub, 1 + %ztrunc = trunc i32 %shl11 to i8 + %14 = and i8 %ztrunc, 15 + %15 = load i8, ptr %13, align 1 + %16 = and i8 %15, -15 + %17 = or i8 %16, %14 + store i8 %17, ptr %13, align 1 + %lshrl12 = lshr i32 %sub, 7 + %18 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %19 = load i8, ptr %18, align 1 + %zext13 = zext i8 %19 to i32 + %lshrl14 = lshr i32 %zext13, 1 + %shl15 = shl i32 %lshrl14, 29 + %ashr16 = ashr i32 %shl15, 29 + %20 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %21 = load i8, ptr %20, align 1 + %zext17 = zext i8 %21 to i32 + %lshrl18 = lshr i32 %zext17, 4 + %22 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %23 = load i8, ptr %22, align 1 + %zext19 = zext i8 %23 to i32 + %shl20 = shl i32 %zext19, 4 + %24 = or i32 %shl20, %lshrl18 + %shl21 = shl i32 %24, 26 + %ashr22 = ashr i32 %shl21, 26 + call void (ptr, ...) @printf(ptr @.str.24, i32 %ashr16, i32 %ashr22) + %25 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %26 = load i8, ptr %25, align 1 + %zext23 = zext i8 %26 to i32 + %lshrl24 = lshr i32 %zext23, 4 + %27 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %28 = load i8, ptr %27, align 1 + %zext25 = zext i8 %28 to i32 + %shl26 = shl i32 %zext25, 4 + %29 = or i32 %shl26, %lshrl24 + %shl27 = shl i32 %29, 26 + %ashr28 = ashr i32 %shl27, 26 + %mul = mul i32 %ashr28, 2 + %30 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl29 = shl i32 %mul, 4 + %ztrunc30 = trunc i32 %shl29 to i8 + %31 = load i8, ptr %30, align 1 + %32 = and i8 %31, 15 + %33 = or i8 %32, %ztrunc30 + store i8 %33, ptr %30, align 1 + %lshrl31 = lshr i32 %mul, 4 + %34 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc32 = trunc i32 %lshrl31 to i8 + %35 = and i8 %ztrunc32, 3 + %36 = load i8, ptr %34, align 1 + %37 = and i8 %36, -4 + %38 = or i8 %37, %35 + store i8 %38, ptr %34, align 1 + %39 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %40 = load i8, ptr %39, align 1 + %zext33 = zext i8 %40 to i32 + %lshrl34 = lshr i32 %zext33, 1 + %shl35 = shl i32 %lshrl34, 29 + %ashr36 = ashr i32 %shl35, 29 %41 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 %42 = load i8, ptr %41, align 1 - %43 = zext i8 %42 to i32 - %44 = lshr i32 %43, 4 - %45 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %46 = load i8, ptr %45, align 1 - %47 = zext i8 %46 to i32 - %48 = shl i32 %47, 4 - %49 = or i32 %48, %44 - %50 = shl i32 %49, 26 - %51 = ashr i32 %50, 26 - call void (ptr, ...) @printf(ptr @.str.24, i32 %40, i32 %51) - %52 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %53 = load i8, ptr %52, align 1 - %54 = zext i8 %53 to i32 - %55 = lshr i32 %54, 4 - %56 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %57 = load i8, ptr %56, align 1 - %58 = zext i8 %57 to i32 - %59 = shl i32 %58, 4 - %60 = or i32 %59, %55 - %61 = shl i32 %60, 26 - %62 = ashr i32 %61, 26 - %mul = mul i32 %62, 2 - %63 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %64 = shl i32 %mul, 4 - %65 = trunc i32 %64 to i8 - %66 = load i8, ptr %63, align 1 - %67 = and i8 %66, 15 - %68 = or i8 %67, %65 - store i8 %68, ptr %63, align 1 - %69 = lshr i32 %mul, 4 - %70 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %71 = trunc i32 %69 to i8 - %72 = and i8 %71, 3 - %73 = load i8, ptr %70, align 1 - %74 = and i8 %73, -4 - %75 = or i8 %74, %72 - store i8 %75, ptr %70, align 1 - %76 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %77 = load i8, ptr %76, align 1 - %78 = zext i8 %77 to i32 - %79 = lshr i32 %78, 1 - %80 = shl i32 %79, 29 - %81 = ashr i32 %80, 29 - %82 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %83 = load i8, ptr %82, align 1 - %84 = zext i8 %83 to i32 - %85 = lshr i32 %84, 4 - %86 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %87 = load i8, ptr %86, align 1 - %88 = zext i8 %87 to i32 - %89 = shl i32 %88, 4 - %90 = or i32 %89, %85 - %91 = shl i32 %90, 26 - %92 = ashr i32 %91, 26 - call void (ptr, ...) @printf(ptr @.str.25, i32 %81, i32 %92) - %93 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %94 = load i8, ptr %93, align 1 - %95 = zext i8 %94 to i32 - %96 = lshr i32 %95, 4 - %97 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %98 = load i8, ptr %97, align 1 - %99 = zext i8 %98 to i32 - %100 = shl i32 %99, 4 - %101 = or i32 %100, %96 - %102 = shl i32 %101, 26 - %103 = ashr i32 %102, 26 - %xor = xor i32 %103, 4 - %104 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %105 = shl i32 %xor, 4 - %106 = trunc i32 %105 to i8 - %107 = load i8, ptr %104, align 1 - %108 = and i8 %107, 15 - %109 = or i8 %108, %106 - store i8 %109, ptr %104, align 1 - %110 = lshr i32 %xor, 4 - %111 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %112 = trunc i32 %110 to i8 - %113 = and i8 %112, 3 - %114 = load i8, ptr %111, align 1 - %115 = and i8 %114, -4 - %116 = or i8 %115, %113 - store i8 %116, ptr %111, align 1 - %117 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %118 = load i8, ptr %117, align 1 - %119 = zext i8 %118 to i32 - %120 = lshr i32 %119, 1 - %121 = shl i32 %120, 29 - %122 = ashr i32 %121, 29 - %123 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %124 = load i8, ptr %123, align 1 - %125 = zext i8 %124 to i32 - %126 = lshr i32 %125, 4 - %127 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %zext37 = zext i8 %42 to i32 + %lshrl38 = lshr i32 %zext37, 4 + %43 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %44 = load i8, ptr %43, align 1 + %zext39 = zext i8 %44 to i32 + %shl40 = shl i32 %zext39, 4 + %45 = or i32 %shl40, %lshrl38 + %shl41 = shl i32 %45, 26 + %ashr42 = ashr i32 %shl41, 26 + call void (ptr, ...) @printf(ptr @.str.25, i32 %ashr36, i32 %ashr42) + %46 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %47 = load i8, ptr %46, align 1 + %zext43 = zext i8 %47 to i32 + %lshrl44 = lshr i32 %zext43, 4 + %48 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %49 = load i8, ptr %48, align 1 + %zext45 = zext i8 %49 to i32 + %shl46 = shl i32 %zext45, 4 + %50 = or i32 %shl46, %lshrl44 + %shl47 = shl i32 %50, 26 + %ashr48 = ashr i32 %shl47, 26 + %xor = xor i32 %ashr48, 4 + %51 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl49 = shl i32 %xor, 4 + %ztrunc50 = trunc i32 %shl49 to i8 + %52 = load i8, ptr %51, align 1 + %53 = and i8 %52, 15 + %54 = or i8 %53, %ztrunc50 + store i8 %54, ptr %51, align 1 + %lshrl51 = lshr i32 %xor, 4 + %55 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc52 = trunc i32 %lshrl51 to i8 + %56 = and i8 %ztrunc52, 3 + %57 = load i8, ptr %55, align 1 + %58 = and i8 %57, -4 + %59 = or i8 %58, %56 + store i8 %59, ptr %55, align 1 + %60 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %61 = load i8, ptr %60, align 1 + %zext53 = zext i8 %61 to i32 + %lshrl54 = lshr i32 %zext53, 1 + %shl55 = shl i32 %lshrl54, 29 + %ashr56 = ashr i32 %shl55, 29 + %62 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %63 = load i8, ptr %62, align 1 + %zext57 = zext i8 %63 to i32 + %lshrl58 = lshr i32 %zext57, 4 + %64 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %65 = load i8, ptr %64, align 1 + %zext59 = zext i8 %65 to i32 + %shl60 = shl i32 %zext59, 4 + %66 = or i32 %shl60, %lshrl58 + %shl61 = shl i32 %66, 26 + %ashr62 = ashr i32 %shl61, 26 + call void (ptr, ...) @printf(ptr @.str.26, i32 %ashr56, i32 %ashr62) + %67 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %68 = load i8, ptr %67, align 1 + %zext63 = zext i8 %68 to i32 + %lshrl64 = lshr i32 %zext63, 4 + %69 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %70 = load i8, ptr %69, align 1 + %zext65 = zext i8 %70 to i32 + %shl66 = shl i32 %zext65, 4 + %71 = or i32 %shl66, %lshrl64 + %shl67 = shl i32 %71, 26 + %ashr68 = ashr i32 %shl67, 26 + %or = or i32 %ashr68, 4 + %72 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl69 = shl i32 %or, 4 + %ztrunc70 = trunc i32 %shl69 to i8 + %73 = load i8, ptr %72, align 1 + %74 = and i8 %73, 15 + %75 = or i8 %74, %ztrunc70 + store i8 %75, ptr %72, align 1 + %lshrl71 = lshr i32 %or, 4 + %76 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc72 = trunc i32 %lshrl71 to i8 + %77 = and i8 %ztrunc72, 3 + %78 = load i8, ptr %76, align 1 + %79 = and i8 %78, -4 + %80 = or i8 %79, %77 + store i8 %80, ptr %76, align 1 + %81 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %82 = load i8, ptr %81, align 1 + %zext73 = zext i8 %82 to i32 + %lshrl74 = lshr i32 %zext73, 1 + %shl75 = shl i32 %lshrl74, 29 + %ashr76 = ashr i32 %shl75, 29 + %83 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %84 = load i8, ptr %83, align 1 + %zext77 = zext i8 %84 to i32 + %lshrl78 = lshr i32 %zext77, 4 + %85 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %86 = load i8, ptr %85, align 1 + %zext79 = zext i8 %86 to i32 + %shl80 = shl i32 %zext79, 4 + %87 = or i32 %shl80, %lshrl78 + %shl81 = shl i32 %87, 26 + %ashr82 = ashr i32 %shl81, 26 + call void (ptr, ...) @printf(ptr @.str.27, i32 %ashr76, i32 %ashr82) + %88 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %89 = load i8, ptr %88, align 1 + %zext83 = zext i8 %89 to i32 + %lshrl84 = lshr i32 %zext83, 4 + %90 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %91 = load i8, ptr %90, align 1 + %zext85 = zext i8 %91 to i32 + %shl86 = shl i32 %zext85, 4 + %92 = or i32 %shl86, %lshrl84 + %shl87 = shl i32 %92, 26 + %ashr88 = ashr i32 %shl87, 26 + %shl89 = shl i32 %ashr88, 1 + %93 = freeze i32 %shl89 + %94 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl90 = shl i32 %93, 4 + %ztrunc91 = trunc i32 %shl90 to i8 + %95 = load i8, ptr %94, align 1 + %96 = and i8 %95, 15 + %97 = or i8 %96, %ztrunc91 + store i8 %97, ptr %94, align 1 + %lshrl92 = lshr i32 %93, 4 + %98 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc93 = trunc i32 %lshrl92 to i8 + %99 = and i8 %ztrunc93, 3 + %100 = load i8, ptr %98, align 1 + %101 = and i8 %100, -4 + %102 = or i8 %101, %99 + store i8 %102, ptr %98, align 1 + %103 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %104 = load i8, ptr %103, align 1 + %zext94 = zext i8 %104 to i32 + %lshrl95 = lshr i32 %zext94, 1 + %shl96 = shl i32 %lshrl95, 29 + %ashr97 = ashr i32 %shl96, 29 + %105 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %106 = load i8, ptr %105, align 1 + %zext98 = zext i8 %106 to i32 + %lshrl99 = lshr i32 %zext98, 4 + %107 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %108 = load i8, ptr %107, align 1 + %zext100 = zext i8 %108 to i32 + %shl101 = shl i32 %zext100, 4 + %109 = or i32 %shl101, %lshrl99 + %shl102 = shl i32 %109, 26 + %ashr103 = ashr i32 %shl102, 26 + call void (ptr, ...) @printf(ptr @.str.28, i32 %ashr97, i32 %ashr103) + %110 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %111 = load i8, ptr %110, align 1 + %zext104 = zext i8 %111 to i32 + %lshrl105 = lshr i32 %zext104, 4 + %112 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %113 = load i8, ptr %112, align 1 + %zext106 = zext i8 %113 to i32 + %shl107 = shl i32 %zext106, 4 + %114 = or i32 %shl107, %lshrl105 + %shl108 = shl i32 %114, 26 + %ashr109 = ashr i32 %shl108, 26 + %ashr110 = ashr i32 %ashr109, 1 + %115 = freeze i32 %ashr110 + %116 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl111 = shl i32 %115, 4 + %ztrunc112 = trunc i32 %shl111 to i8 + %117 = load i8, ptr %116, align 1 + %118 = and i8 %117, 15 + %119 = or i8 %118, %ztrunc112 + store i8 %119, ptr %116, align 1 + %lshrl113 = lshr i32 %115, 4 + %120 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc114 = trunc i32 %lshrl113 to i8 + %121 = and i8 %ztrunc114, 3 + %122 = load i8, ptr %120, align 1 + %123 = and i8 %122, -4 + %124 = or i8 %123, %121 + store i8 %124, ptr %120, align 1 + %125 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %126 = load i8, ptr %125, align 1 + %zext115 = zext i8 %126 to i32 + %lshrl116 = lshr i32 %zext115, 1 + %shl117 = shl i32 %lshrl116, 29 + %ashr118 = ashr i32 %shl117, 29 + %127 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 %128 = load i8, ptr %127, align 1 - %129 = zext i8 %128 to i32 - %130 = shl i32 %129, 4 - %131 = or i32 %130, %126 - %132 = shl i32 %131, 26 - %133 = ashr i32 %132, 26 - call void (ptr, ...) @printf(ptr @.str.26, i32 %122, i32 %133) - %134 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %zext119 = zext i8 %128 to i32 + %lshrl120 = lshr i32 %zext119, 4 + %129 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %130 = load i8, ptr %129, align 1 + %zext121 = zext i8 %130 to i32 + %shl122 = shl i32 %zext121, 4 + %131 = or i32 %shl122, %lshrl120 + %shl123 = shl i32 %131, 26 + %ashr124 = ashr i32 %shl123, 26 + call void (ptr, ...) @printf(ptr @.str.29, i32 %ashr118, i32 %ashr124) + %132 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %133 = load i8, ptr %132, align 1 + %zext125 = zext i8 %133 to i32 + %lshrl126 = lshr i32 %zext125, 4 + %134 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 %135 = load i8, ptr %134, align 1 - %136 = zext i8 %135 to i32 - %137 = lshr i32 %136, 4 - %138 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %139 = load i8, ptr %138, align 1 - %140 = zext i8 %139 to i32 - %141 = shl i32 %140, 4 - %142 = or i32 %141, %137 - %143 = shl i32 %142, 26 - %144 = ashr i32 %143, 26 - %or = or i32 %144, 4 - %145 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %146 = shl i32 %or, 4 - %147 = trunc i32 %146 to i8 - %148 = load i8, ptr %145, align 1 - %149 = and i8 %148, 15 - %150 = or i8 %149, %147 - store i8 %150, ptr %145, align 1 - %151 = lshr i32 %or, 4 - %152 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %153 = trunc i32 %151 to i8 - %154 = and i8 %153, 3 - %155 = load i8, ptr %152, align 1 - %156 = and i8 %155, -4 - %157 = or i8 %156, %154 - store i8 %157, ptr %152, align 1 + %zext127 = zext i8 %135 to i32 + %shl128 = shl i32 %zext127, 4 + %136 = or i32 %shl128, %lshrl126 + %shl129 = shl i32 %136, 26 + %ashr130 = ashr i32 %shl129, 26 + %sdiv = sdiv i32 %ashr130, 2 + %137 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl131 = shl i32 %sdiv, 4 + %ztrunc132 = trunc i32 %shl131 to i8 + %138 = load i8, ptr %137, align 1 + %139 = and i8 %138, 15 + %140 = or i8 %139, %ztrunc132 + store i8 %140, ptr %137, align 1 + %lshrl133 = lshr i32 %sdiv, 4 + %141 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc134 = trunc i32 %lshrl133 to i8 + %142 = and i8 %ztrunc134, 3 + %143 = load i8, ptr %141, align 1 + %144 = and i8 %143, -4 + %145 = or i8 %144, %142 + store i8 %145, ptr %141, align 1 + %146 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %147 = load i8, ptr %146, align 1 + %zext135 = zext i8 %147 to i32 + %lshrl136 = lshr i32 %zext135, 1 + %shl137 = shl i32 %lshrl136, 29 + %ashr138 = ashr i32 %shl137, 29 + %148 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %149 = load i8, ptr %148, align 1 + %zext139 = zext i8 %149 to i32 + %lshrl140 = lshr i32 %zext139, 4 + %150 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %151 = load i8, ptr %150, align 1 + %zext141 = zext i8 %151 to i32 + %shl142 = shl i32 %zext141, 4 + %152 = or i32 %shl142, %lshrl140 + %shl143 = shl i32 %152, 26 + %ashr144 = ashr i32 %shl143, 26 + call void (ptr, ...) @printf(ptr @.str.30, i32 %ashr138, i32 %ashr144) + %153 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %154 = load i8, ptr %153, align 1 + %zext145 = zext i8 %154 to i32 + %lshrl146 = lshr i32 %zext145, 4 + %155 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %156 = load i8, ptr %155, align 1 + %zext147 = zext i8 %156 to i32 + %shl148 = shl i32 %zext147, 4 + %157 = or i32 %shl148, %lshrl146 + %shl149 = shl i32 %157, 26 + %ashr150 = ashr i32 %shl149, 26 + %smod = srem i32 %ashr150, 2 %158 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %shl151 = shl i32 %smod, 4 + %ztrunc152 = trunc i32 %shl151 to i8 %159 = load i8, ptr %158, align 1 - %160 = zext i8 %159 to i32 - %161 = lshr i32 %160, 1 - %162 = shl i32 %161, 29 - %163 = ashr i32 %162, 29 - %164 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %165 = load i8, ptr %164, align 1 - %166 = zext i8 %165 to i32 - %167 = lshr i32 %166, 4 - %168 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %169 = load i8, ptr %168, align 1 - %170 = zext i8 %169 to i32 - %171 = shl i32 %170, 4 - %172 = or i32 %171, %167 - %173 = shl i32 %172, 26 - %174 = ashr i32 %173, 26 - call void (ptr, ...) @printf(ptr @.str.27, i32 %163, i32 %174) - %175 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %176 = load i8, ptr %175, align 1 - %177 = zext i8 %176 to i32 - %178 = lshr i32 %177, 4 - %179 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %180 = load i8, ptr %179, align 1 - %181 = zext i8 %180 to i32 - %182 = shl i32 %181, 4 - %183 = or i32 %182, %178 - %184 = shl i32 %183, 26 - %185 = ashr i32 %184, 26 - %shl = shl i32 %185, 1 - %186 = freeze i32 %shl - %187 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %188 = shl i32 %186, 4 - %189 = trunc i32 %188 to i8 - %190 = load i8, ptr %187, align 1 - %191 = and i8 %190, 15 - %192 = or i8 %191, %189 - store i8 %192, ptr %187, align 1 - %193 = lshr i32 %186, 4 - %194 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %195 = trunc i32 %193 to i8 - %196 = and i8 %195, 3 - %197 = load i8, ptr %194, align 1 - %198 = and i8 %197, -4 - %199 = or i8 %198, %196 - store i8 %199, ptr %194, align 1 - %200 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %201 = load i8, ptr %200, align 1 - %202 = zext i8 %201 to i32 - %203 = lshr i32 %202, 1 - %204 = shl i32 %203, 29 - %205 = ashr i32 %204, 29 - %206 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %207 = load i8, ptr %206, align 1 - %208 = zext i8 %207 to i32 - %209 = lshr i32 %208, 4 - %210 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %211 = load i8, ptr %210, align 1 - %212 = zext i8 %211 to i32 - %213 = shl i32 %212, 4 - %214 = or i32 %213, %209 - %215 = shl i32 %214, 26 - %216 = ashr i32 %215, 26 - call void (ptr, ...) @printf(ptr @.str.28, i32 %205, i32 %216) - %217 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %218 = load i8, ptr %217, align 1 - %219 = zext i8 %218 to i32 - %220 = lshr i32 %219, 4 - %221 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %222 = load i8, ptr %221, align 1 - %223 = zext i8 %222 to i32 - %224 = shl i32 %223, 4 - %225 = or i32 %224, %220 - %226 = shl i32 %225, 26 - %227 = ashr i32 %226, 26 - %ashr = ashr i32 %227, 1 - %228 = freeze i32 %ashr - %229 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %230 = shl i32 %228, 4 - %231 = trunc i32 %230 to i8 - %232 = load i8, ptr %229, align 1 - %233 = and i8 %232, 15 - %234 = or i8 %233, %231 - store i8 %234, ptr %229, align 1 - %235 = lshr i32 %228, 4 - %236 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %237 = trunc i32 %235 to i8 - %238 = and i8 %237, 3 - %239 = load i8, ptr %236, align 1 - %240 = and i8 %239, -4 - %241 = or i8 %240, %238 - store i8 %241, ptr %236, align 1 - %242 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %243 = load i8, ptr %242, align 1 - %244 = zext i8 %243 to i32 - %245 = lshr i32 %244, 1 - %246 = shl i32 %245, 29 - %247 = ashr i32 %246, 29 - %248 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %249 = load i8, ptr %248, align 1 - %250 = zext i8 %249 to i32 - %251 = lshr i32 %250, 4 - %252 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %253 = load i8, ptr %252, align 1 - %254 = zext i8 %253 to i32 - %255 = shl i32 %254, 4 - %256 = or i32 %255, %251 - %257 = shl i32 %256, 26 - %258 = ashr i32 %257, 26 - call void (ptr, ...) @printf(ptr @.str.29, i32 %247, i32 %258) - %259 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %260 = load i8, ptr %259, align 1 - %261 = zext i8 %260 to i32 - %262 = lshr i32 %261, 4 - %263 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %264 = load i8, ptr %263, align 1 - %265 = zext i8 %264 to i32 - %266 = shl i32 %265, 4 - %267 = or i32 %266, %262 - %268 = shl i32 %267, 26 - %269 = ashr i32 %268, 26 - %sdiv = sdiv i32 %269, 2 - %270 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %271 = shl i32 %sdiv, 4 - %272 = trunc i32 %271 to i8 - %273 = load i8, ptr %270, align 1 - %274 = and i8 %273, 15 - %275 = or i8 %274, %272 - store i8 %275, ptr %270, align 1 - %276 = lshr i32 %sdiv, 4 - %277 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %278 = trunc i32 %276 to i8 - %279 = and i8 %278, 3 - %280 = load i8, ptr %277, align 1 - %281 = and i8 %280, -4 - %282 = or i8 %281, %279 - store i8 %282, ptr %277, align 1 - %283 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %284 = load i8, ptr %283, align 1 - %285 = zext i8 %284 to i32 - %286 = lshr i32 %285, 1 - %287 = shl i32 %286, 29 - %288 = ashr i32 %287, 29 - %289 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %290 = load i8, ptr %289, align 1 - %291 = zext i8 %290 to i32 - %292 = lshr i32 %291, 4 - %293 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %294 = load i8, ptr %293, align 1 - %295 = zext i8 %294 to i32 - %296 = shl i32 %295, 4 - %297 = or i32 %296, %292 - %298 = shl i32 %297, 26 - %299 = ashr i32 %298, 26 - call void (ptr, ...) @printf(ptr @.str.30, i32 %288, i32 %299) - %300 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %301 = load i8, ptr %300, align 1 - %302 = zext i8 %301 to i32 - %303 = lshr i32 %302, 4 - %304 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %305 = load i8, ptr %304, align 1 - %306 = zext i8 %305 to i32 - %307 = shl i32 %306, 4 - %308 = or i32 %307, %303 - %309 = shl i32 %308, 26 - %310 = ashr i32 %309, 26 - %smod = srem i32 %310, 2 - %311 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %312 = shl i32 %smod, 4 - %313 = trunc i32 %312 to i8 - %314 = load i8, ptr %311, align 1 - %315 = and i8 %314, 15 - %316 = or i8 %315, %313 - store i8 %316, ptr %311, align 1 - %317 = lshr i32 %smod, 4 - %318 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %319 = trunc i32 %317 to i8 - %320 = and i8 %319, 3 - %321 = load i8, ptr %318, align 1 - %322 = and i8 %321, -4 - %323 = or i8 %322, %320 - store i8 %323, ptr %318, align 1 - %324 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %325 = load i8, ptr %324, align 1 - %326 = zext i8 %325 to i32 - %327 = lshr i32 %326, 1 - %328 = shl i32 %327, 29 - %329 = ashr i32 %328, 29 - %330 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 - %331 = load i8, ptr %330, align 1 - %332 = zext i8 %331 to i32 - %333 = lshr i32 %332, 4 - %334 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 - %335 = load i8, ptr %334, align 1 - %336 = zext i8 %335 to i32 - %337 = shl i32 %336, 4 - %338 = or i32 %337, %333 - %339 = shl i32 %338, 26 - %340 = ashr i32 %339, 26 - call void (ptr, ...) @printf(ptr @.str.31, i32 %329, i32 %340) - %341 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %342 = load i8, ptr %341, align 1 - %343 = lshr i8 %342, 5 - %344 = trunc i8 %343 to i1 - %boolsi = zext i1 %344 to i32 + %160 = and i8 %159, 15 + %161 = or i8 %160, %ztrunc152 + store i8 %161, ptr %158, align 1 + %lshrl153 = lshr i32 %smod, 4 + %162 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %ztrunc154 = trunc i32 %lshrl153 to i8 + %163 = and i8 %ztrunc154, 3 + %164 = load i8, ptr %162, align 1 + %165 = and i8 %164, -4 + %166 = or i8 %165, %163 + store i8 %166, ptr %162, align 1 + %167 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %168 = load i8, ptr %167, align 1 + %zext155 = zext i8 %168 to i32 + %lshrl156 = lshr i32 %zext155, 1 + %shl157 = shl i32 %lshrl156, 29 + %ashr158 = ashr i32 %shl157, 29 + %169 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 0 + %170 = load i8, ptr %169, align 1 + %zext159 = zext i8 %170 to i32 + %lshrl160 = lshr i32 %zext159, 4 + %171 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 1 + %172 = load i8, ptr %171, align 1 + %zext161 = zext i8 %172 to i32 + %shl162 = shl i32 %zext161, 4 + %173 = or i32 %shl162, %lshrl160 + %shl163 = shl i32 %173, 26 + %ashr164 = ashr i32 %shl163, 26 + call void (ptr, ...) @printf(ptr @.str.31, i32 %ashr158, i32 %ashr164) + %174 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %175 = load i8, ptr %174, align 1 + %lshrl165 = lshr i8 %175, 5 + %176 = trunc i8 %lshrl165 to i1 + %boolsi = zext i1 %176 to i32 call void (ptr, ...) @printf(ptr @.str.32, i32 %boolsi) - %345 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %346 = load i8, ptr %345, align 1 - %347 = and i8 %346, -33 - %348 = or i8 %347, 32 - store i8 %348, ptr %345, align 1 - %349 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %350 = load i8, ptr %349, align 1 - %351 = lshr i8 %350, 5 - %352 = trunc i8 %351 to i1 - %boolsi1 = zext i1 %352 to i32 - call void (ptr, ...) @printf(ptr @.str.33, i32 %boolsi1) - %353 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %354 = load i8, ptr %353, align 1 - %355 = and i8 %354, -33 - store i8 %355, ptr %353, align 1 - %356 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 - %357 = load i8, ptr %356, align 1 - %358 = lshr i8 %357, 5 - %359 = trunc i8 %358 to i1 - %boolsi2 = zext i1 %359 to i32 - call void (ptr, ...) @printf(ptr @.str.34, i32 %boolsi2) + %177 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %178 = load i8, ptr %177, align 1 + %179 = and i8 %178, -33 + %180 = or i8 %179, 32 + store i8 %180, ptr %177, align 1 + %181 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %182 = load i8, ptr %181, align 1 + %lshrl166 = lshr i8 %182, 5 + %183 = trunc i8 %lshrl166 to i1 + %boolsi167 = zext i1 %183 to i32 + call void (ptr, ...) @printf(ptr @.str.33, i32 %boolsi167) + %184 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %185 = load i8, ptr %184, align 1 + %186 = and i8 %185, -33 + store i8 %186, ptr %184, align 1 + %187 = getelementptr inbounds [3 x i8], ptr %xx, i64 0, i64 2 + %188 = load i8, ptr %187, align 1 + %lshrl168 = lshr i8 %188, 5 + %189 = trunc i8 %lshrl168 to i1 + %boolsi169 = zext i1 %189 to i32 + call void (ptr, ...) @printf(ptr @.str.34, i32 %boolsi169) ret void } diff --git a/test/test_suite2/bitstruct/bitstruct_arrays_be.c3t b/test/test_suite2/bitstruct/bitstruct_arrays_be.c3t index 6cddddf44..4c686ad02 100644 --- a/test/test_suite2/bitstruct/bitstruct_arrays_be.c3t +++ b/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 - %3 = lshr i32 %2, 4 - %4 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1 - %5 = load i8, ptr %4, align 1 - %6 = zext i8 %5 to i32 - %7 = shl i32 %6, 4 - %8 = or i32 %7, %3 - %9 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2 - %10 = load i8, ptr %9, align 1 - %11 = zext i8 %10 to i32 - %12 = shl i32 %11, 12 - %13 = or i32 %12, %8 - %14 = shl i32 %13, 16 - %15 = call i32 @llvm.bswap.i32(i32 %14) - %16 = and i32 65535, %15 - call void (ptr, ...) @printf(ptr @.str, i32 %16) + %zext = zext i8 %1 to i32 + %lshrl = lshr i32 %zext, 4 + %2 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1 + %3 = load i8, ptr %2, align 1 + %zext1 = zext i8 %3 to i32 + %shl = shl i32 %zext1, 4 + %4 = or i32 %shl, %lshrl + %5 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2 + %6 = load i8, ptr %5, align 1 + %zext2 = zext i8 %6 to i32 + %shl3 = shl i32 %zext2, 12 + %7 = or i32 %shl3, %4 + %shl4 = shl i32 %7, 16 + %8 = call i32 @llvm.bswap.i32(i32 %shl4) + %9 = and i32 65535, %8 + 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 - store ptr %17, ptr %z, align 8 - %18 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0 - %19 = load i8, ptr %18, align 1 - %20 = zext i8 %19 to i32 - %21 = lshr i32 %20, 4 - %22 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1 - %23 = load i8, ptr %22, align 1 - %24 = zext i8 %23 to i32 - %25 = shl i32 %24, 4 - %26 = or i32 %25, %21 - %27 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2 - %28 = load i8, ptr %27, align 1 - %29 = zext i8 %28 to i32 - %30 = shl i32 %29, 12 - %31 = or i32 %30, %26 - %32 = and i32 65535, %31 - call void (ptr, ...) @printf(ptr @.str.1, i32 %32) - %33 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0 - %34 = load i8, ptr %33, align 1 - %35 = and i8 %34, 15 - %36 = or i8 %35, -16 - store i8 %36, ptr %33, align 1 - %37 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1 - store i8 -18, ptr %37, align 1 - %38 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2 + %10 = load ptr, ptr %abc, align 8 + store ptr %10, ptr %z, align 8 + %11 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0 + %12 = load i8, ptr %11, align 1 + %zext5 = zext i8 %12 to i32 + %lshrl6 = lshr i32 %zext5, 4 + %13 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1 + %14 = load i8, ptr %13, align 1 + %zext7 = zext i8 %14 to i32 + %shl8 = shl i32 %zext7, 4 + %15 = or i32 %shl8, %lshrl6 + %16 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2 + %17 = load i8, ptr %16, align 1 + %zext9 = zext i8 %17 to i32 + %shl10 = shl i32 %zext9, 12 + %18 = or i32 %shl10, %15 + %19 = and i32 65535, %18 + call void (ptr, ...) @printf(ptr @.str.1, i32 %19) + %20 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0 + %21 = load i8, ptr %20, align 1 + %22 = and i8 %21, 15 + %23 = or i8 %22, -16 + store i8 %23, ptr %20, align 1 + %24 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1 + store i8 -18, ptr %24, align 1 + %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 - %41 = or i8 %40, 11 + %40 = and i8 %39, 15 + %41 = or i8 %40, -32 store i8 %41, ptr %38, align 1 - %42 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 0 - %43 = load i8, ptr %42, align 1 - %44 = zext i8 %43 to i32 - %45 = lshr i32 %44, 4 - %46 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 1 - %47 = load i8, ptr %46, align 1 - %48 = zext i8 %47 to i32 - %49 = shl i32 %48, 4 - %50 = or i32 %49, %45 - %51 = getelementptr inbounds [4 x i8], ptr %xy, i64 0, i64 2 - %52 = load i8, ptr %51, align 1 - %53 = zext i8 %52 to i32 - %54 = shl i32 %53, 12 - %55 = or i32 %54, %50 + %42 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1 + store i8 -5, ptr %42, align 1 + %43 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 2 + %44 = load i8, ptr %43, align 1 + %45 = and i8 %44, -16 + %46 = or i8 %45, 14 + store i8 %46, ptr %43, align 1 + %47 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 0 + %48 = load i8, ptr %47, align 1 + %zext17 = zext i8 %48 to i32 + %lshrl18 = lshr i32 %zext17, 4 + %49 = getelementptr inbounds [4 x i8], ptr %xx, i64 0, i64 1 + %50 = load i8, ptr %49, align 1 + %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) - %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) + call void (ptr, ...) @printf(ptr @.str.3, i32 %56) ret void } \ No newline at end of file diff --git a/test/test_suite2/bitstruct/bitstruct_intcontainer.c3t b/test/test_suite2/bitstruct/bitstruct_intcontainer.c3t index a90313bb1..bb2a46ddd 100644 --- a/test/test_suite2/bitstruct/bitstruct_intcontainer.c3t +++ b/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 - %2 = ashr i32 %1, 14 - call void (ptr, ...) @printf(ptr @.str, i32 %2) + %shl = shl i32 %0, 9 + %ashr = ashr i32 %shl, 14 + call void (ptr, ...) @printf(ptr @.str, i32 %ashr) store i32 1073741375, ptr %xx, align 4 - %3 = load i32, ptr %xx, align 4 - %4 = shl i32 %3, 9 - %5 = ashr i32 %4, 14 - call void (ptr, ...) @printf(ptr @.str.1, i32 %5) + %1 = load i32, ptr %xx, align 4 + %shl1 = shl i32 %1, 9 + %ashr2 = ashr i32 %shl1, 14 + call void (ptr, ...) @printf(ptr @.str.1, i32 %ashr2) store i32 -3485921, ptr %xxu, align 4 - %6 = load i32, ptr %xxu, align 4 - %7 = lshr i32 %6, 5 - %8 = and i32 262143, %7 - call void (ptr, ...) @printf(ptr @.str.2, i32 %8) + %2 = load i32, ptr %xxu, align 4 + %lshrl = lshr i32 %2, 5 + %3 = and i32 262143, %lshrl + call void (ptr, ...) @printf(ptr @.str.2, i32 %3) store i64 1525363991714123551, ptr %xxy, align 8 - %9 = load i64, ptr %xxy, align 8 - %10 = lshr i64 %9, 5 - %11 = and i64 262143, %10 - %12 = trunc i64 %11 to i32 - %13 = load i64, ptr %xxy, align 8 - %14 = lshr i64 %13, 23 - %15 = and i64 262143, %14 - %16 = trunc i64 %15 to i32 - %17 = load i64, ptr %xxy, align 8 - %18 = lshr i64 %17, 41 - %19 = and i64 2097151, %18 - %20 = trunc i64 %19 to i32 - call void (ptr, ...) @printf(ptr @.str.3, i32 %12, i32 %16, i32 %20) + %4 = load i64, ptr %xxy, align 8 + %lshrl3 = lshr i64 %4, 5 + %5 = and i64 262143, %lshrl3 + %ztrunc = trunc i64 %5 to i32 + %6 = load i64, ptr %xxy, align 8 + %lshrl4 = lshr i64 %6, 23 + %7 = and i64 262143, %lshrl4 + %ztrunc5 = trunc i64 %7 to i32 + %8 = load i64, ptr %xxy, align 8 + %lshrl6 = lshr i64 %8, 41 + %9 = and i64 2097151, %lshrl6 + %ztrunc7 = trunc i64 %9 to i32 + 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 - %22 = call i64 @llvm.bswap.i64(i64 %21) - %23 = lshr i64 %22, 5 - %24 = and i64 262143, %23 - %25 = trunc i64 %24 to i32 - %26 = load i64, ptr %xxybe, align 8 - %27 = call i64 @llvm.bswap.i64(i64 %26) - %28 = lshr i64 %27, 23 - %29 = and i64 262143, %28 - %30 = trunc i64 %29 to i32 - %31 = load i64, ptr %xxybe, align 8 - %32 = call i64 @llvm.bswap.i64(i64 %31) - %33 = lshr i64 %32, 41 - %34 = and i64 2097151, %33 - %35 = trunc i64 %34 to i32 - call void (ptr, ...) @printf(ptr @.str.4, i32 %25, i32 %30, i32 %35) + %10 = load i64, ptr %xxybe, align 8 + %11 = call i64 @llvm.bswap.i64(i64 %10) + %lshrl8 = lshr i64 %11, 5 + %12 = and i64 262143, %lshrl8 + %ztrunc9 = trunc i64 %12 to i32 + %13 = load i64, ptr %xxybe, align 8 + %14 = call i64 @llvm.bswap.i64(i64 %13) + %lshrl10 = lshr i64 %14, 23 + %15 = and i64 262143, %lshrl10 + %ztrunc11 = trunc i64 %15 to i32 + %16 = load i64, ptr %xxybe, align 8 + %17 = call i64 @llvm.bswap.i64(i64 %16) + %lshrl12 = lshr i64 %17, 41 + %18 = and i64 2097151, %lshrl12 + %ztrunc13 = trunc i64 %18 to i32 + call void (ptr, ...) @printf(ptr @.str.4, i32 %ztrunc9, i32 %ztrunc11, i32 %ztrunc13) ret void } \ No newline at end of file diff --git a/test/test_suite2/bitstruct/bitstruct_to_int.c3t b/test/test_suite2/bitstruct/bitstruct_to_int.c3t index 002cee304..70724f7b2 100644 --- a/test/test_suite2/bitstruct/bitstruct_to_int.c3t +++ b/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 - %5 = ashr i32 %4, 29 - %6 = load ptr, ptr %c, align 8 - store ptr %6, ptr %x2, align 8 - %7 = load ptr, ptr %c, align 8 - store ptr %7, ptr %y2, align 8 + %shl = shl i32 %3, 28 + %ashr = ashr i32 %shl, 29 + %4 = load ptr, ptr %c, align 8 + store ptr %4, ptr %x2, align 8 + %5 = load ptr, ptr %c, 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 - %5 = lshr i32 %4, 1 - %6 = shl i32 %5, 29 - %7 = ashr i32 %6, 29 - call void (ptr, ...) @printf(ptr @.str, i32 %7) - %8 = load ptr, ptr %c, align 8 - store ptr %8, ptr %x2, align 8 - %9 = load ptr, ptr %c, align 8 - store ptr %9, ptr %y2, align 8 + %zext = zext i8 %3 to i32 + %lshrl = lshr i32 %zext, 1 + %shl = shl i32 %lshrl, 29 + %ashr = ashr i32 %shl, 29 + call void (ptr, ...) @printf(ptr @.str, i32 %ashr) + %4 = load ptr, ptr %c, align 8 + store ptr %4, ptr %x2, align 8 + %5 = load ptr, ptr %c, align 8 + store ptr %5, ptr %y2, align 8 ret void } diff --git a/test/test_suite2/bitstruct/embedded_bitstruct.c3t b/test/test_suite2/bitstruct/embedded_bitstruct.c3t index 7251f004b..7d1d49e6b 100644 --- a/test/test_suite2/bitstruct/embedded_bitstruct.c3t +++ b/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 - %7 = ashr i32 %6, 23 - call void (ptr, ...) @printf(ptr @.str, i32 %3, i32 %7) + %shl = shl i32 %5, 21 + %ashr = ashr i32 %shl, 23 + 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 - %9 = getelementptr inbounds %anon.1, ptr %8, i32 0, i32 0 - %10 = getelementptr inbounds %anon.2, ptr %9, i32 0, i32 0 - %11 = load i32, ptr %10, align 4 - %12 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 - %13 = getelementptr inbounds %anon.1, ptr %12, i32 0, i32 1 - %14 = getelementptr inbounds %anon.3, ptr %13, i32 0, i32 0 - %15 = load i32, ptr %14, align 4 - %16 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 - %17 = getelementptr inbounds %anon.1, ptr %16, i32 0, i32 2 + %6 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 + %7 = getelementptr inbounds %anon.1, ptr %6, i32 0, i32 0 + %8 = getelementptr inbounds %anon.2, ptr %7, i32 0, i32 0 + %9 = load i32, ptr %8, align 4 + %10 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 + %11 = getelementptr inbounds %anon.1, ptr %10, i32 0, i32 1 + %12 = getelementptr inbounds %anon.3, ptr %11, i32 0, i32 0 + %13 = load i32, ptr %12, align 4 + %14 = getelementptr inbounds %Foo, ptr %f, i32 0, i32 0 + %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 - %20 = load i32, ptr %19, align 4 - call void (ptr, ...) @printf(ptr @.str.11, i32 %11, i32 %15, i32 %18, i32 %20) + call void (ptr, ...) @printf(ptr @.str.11, i32 %9, i32 %13, i32 %16, i32 %18) ret void } diff --git a/test/test_suite2/cast/top_down_casts.c3t b/test/test_suite2/cast/top_down_casts.c3t index 924aec937..e9054b2bf 100644 --- a/test/test_suite2/cast/top_down_casts.c3t +++ b/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 - %shl = shl i64 %sisiext10, %12 - %13 = freeze i64 %shl - store i64 %13, ptr %z, align 8 - %14 = load i32, ptr %x, align 4 - %sisiext11 = sext i32 %14 to i64 - %15 = load i32, ptr %y, align 4 - %16 = zext i32 %15 to i64 - %ashr = ashr i64 %sisiext11, %16 - %17 = freeze i64 %ashr - store i64 %17, ptr %z, align 8 - %18 = load i32, ptr %x, align 4 - %sisiext12 = sext i32 %18 to i64 - %bnot = xor i64 %sisiext12, -1 + %zext = zext i32 %11 to i64 + %shl = shl i64 %sisiext10, %zext + %12 = freeze i64 %shl + store i64 %12, ptr %z, align 8 + %13 = load i32, ptr %x, align 4 + %sisiext11 = sext i32 %13 to i64 + %14 = load i32, ptr %y, align 4 + %zext12 = zext i32 %14 to i64 + %ashr = ashr i64 %sisiext11, %zext12 + %15 = freeze i64 %ashr + store i64 %15, ptr %z, align 8 + %16 = load i32, ptr %x, align 4 + %sisiext13 = sext i32 %16 to i64 + %bnot = xor i64 %sisiext13, -1 store i64 %bnot, ptr %z, align 8 - %19 = load i32, ptr %x, align 4 - %sisiext13 = sext i32 %19 to i64 - %20 = load i32, ptr %x, align 4 - %sisiext14 = sext i32 %20 to i64 - %neg = sub i64 0, %sisiext14 + %17 = load i32, ptr %x, align 4 + %sisiext14 = sext i32 %17 to i64 + %18 = load i32, ptr %x, align 4 + %sisiext15 = sext i32 %18 to i64 + %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 - %not_err = icmp eq i64 %21, 0 + %optval = load i64, ptr %w.f, align 8 + %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 - %sisiext15 = sext i32 %22 to i64 + %19 = load i32, ptr %w, align 4 + %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 } \ No newline at end of file diff --git a/test/test_suite2/clang/2002-04.c3t b/test/test_suite2/clang/2002-04.c3t index d58cf8508..39b3d7445 100644 --- a/test/test_suite2/clang/2002-04.c3t +++ b/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 - %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %uiuiext + %zext = zext i32 %0 to i64 + %1 = getelementptr inbounds [30 x double], ptr %student_t, i64 0, i64 %zext %2 = load double, ptr %1, align 8 ret double %2 } diff --git a/test/test_suite2/enumerations/enum_cast.c3t b/test/test_suite2/enumerations/enum_cast.c3t index deb1ae866..15ad4b8ee 100644 --- a/test/test_suite2/enumerations/enum_cast.c3t +++ b/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 - %not_err = icmp eq i64 %3, 0 + %optval = load i64, ptr %xf.f, align 8 + %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 - %uifp1 = uitofp i8 %4 to float + %3 = load i8, ptr %xf, align 1 + %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 diff --git a/test/test_suite2/errors/error_regression_2.c3t b/test/test_suite2/errors/error_regression_2.c3t index 35a526a12..991d0e315 100644 --- a/test/test_suite2/errors/error_regression_2.c3t +++ b/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 - store %Head %26, ptr %value, align 8 - %27 = call ptr @std_core_mem_malloc(i64 8) #2 - store ptr %27, ptr %temp, align 8 - %28 = load ptr, ptr %temp, align 8 - %not = icmp eq ptr %28, null + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value, ptr align 8 %literal18, i32 8, i1 false) + %26 = call ptr @std_core_mem_malloc(i64 8) #2 + store ptr %26, ptr %temp, align 8 + %27 = load ptr, ptr %temp, align 8 + %not = icmp eq ptr %27, 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 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %29, ptr align 8 %value, i32 8, i1 false) + %28 = load ptr, ptr %temp, align 8 + 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 - ret i64 %30 + %29 = load i64, ptr %error_var, align 8 + ret i64 %29 noerr_block: ; preds = %if.exit20 - %31 = load ptr, ptr %temp, align 8 - store ptr %31, ptr %24, align 8 + %30 = load ptr, ptr %temp, 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 - %lo22 = load ptr, ptr %32, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 - %hi23 = load i64, ptr %33, align 8 + %31 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 0 + %lo22 = load ptr, ptr %31, align 8 + %32 = getelementptr inbounds { ptr, i64 }, ptr %url, i32 0, i32 1 + %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 - %lo25 = load ptr, ptr %34, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 1 - %hi26 = load i64, ptr %35, align 8 - %36 = call i8 @test_contains(ptr %lo22, i64 %hi23, ptr %lo25, i64 %hi26) - %37 = trunc i8 %36 to i1 - br i1 %37, label %if.then27, label %if.exit47 + %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 0 + %lo25 = load ptr, ptr %33, align 8 + %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr24, i32 0, i32 1 + %hi26 = load i64, ptr %34, align 8 + %35 = call i8 @test_contains(ptr %lo22, i64 %hi23, ptr %lo25, i64 %hi26) + %36 = trunc i8 %35 to i1 + 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 - store ptr %40, ptr %temp35, align 8 - %41 = load ptr, ptr %temp35, align 8 - %not36 = icmp eq ptr %41, null + %39 = call ptr @std_core_mem_malloc(i64 16) #2 + store ptr %39, ptr %temp35, align 8 + %40 = load ptr, ptr %temp35, align 8 + %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 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %42, ptr align 8 %value34, i32 16, i1 false) + %41 = load ptr, ptr %temp35, align 8 + 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 - ret i64 %43 + %42 = load i64, ptr %error_var33, align 8 + ret i64 %42 noerr_block40: ; preds = %if.exit38 - %44 = load ptr, ptr %temp35, align 8 - store ptr %44, ptr %39, align 8 - %45 = load %Head, ptr %literal32, align 8 - store %Head %45, ptr %value31, align 8 - %46 = call ptr @std_core_mem_malloc(i64 8) #2 - store ptr %46, ptr %temp41, align 8 - %47 = load ptr, ptr %temp41, align 8 - %not42 = icmp eq ptr %47, null + %43 = load ptr, ptr %temp35, align 8 + store ptr %43, ptr %38, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value31, ptr align 8 %literal32, i32 8, i1 false) + %44 = call ptr @std_core_mem_malloc(i64 8) #2 + store ptr %44, ptr %temp41, align 8 + %45 = load ptr, ptr %temp41, align 8 + %not42 = icmp eq ptr %45, 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 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %48, ptr align 8 %value31, i32 8, i1 false) + %46 = load ptr, ptr %temp41, align 8 + 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 - ret i64 %49 + %47 = load i64, ptr %error_var30, align 8 + ret i64 %47 noerr_block46: ; preds = %if.exit44 - %50 = load ptr, ptr %temp41, align 8 - store ptr %50, ptr %38, align 8 + %48 = load ptr, ptr %temp41, 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 - %52 = load i64, ptr %51, align 8 - %uisitrunc = trunc i64 %52 to i32 - %53 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %54 = load ptr, ptr %53, align 8 - %55 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.7, i32 %uisitrunc, ptr %54) - store i32 %55, ptr %len, align 4 - %56 = load i32, ptr %len, align 4 - %siuiext = sext i32 %56 to i64 + %49 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %50 = load i64, ptr %49, align 8 + %uisitrunc = trunc i64 %50 to i32 + %51 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %52 = load ptr, ptr %51, align 8 + %53 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr null, i64 0, ptr @.str.7, i32 %uisitrunc, ptr %52) + store i32 %53, ptr %len, align 4 + %54 = load i32, ptr %len, align 4 + %siuiext = sext i32 %54 to i64 %add = add i64 %siuiext, 1 - %57 = call ptr @std_core_mem_malloc(i64 %add) #2 - store ptr %57, ptr %str, align 8 - %58 = load ptr, ptr %str, align 8 - %not48 = icmp eq ptr %58, null + %55 = call ptr @std_core_mem_malloc(i64 %add) #2 + store ptr %55, ptr %str, align 8 + %56 = load ptr, ptr %str, align 8 + %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 - %60 = load i32, ptr %len, align 4 - %siuiext51 = sext i32 %60 to i64 + %57 = load ptr, ptr %str, align 8 + %58 = load i32, ptr %len, align 4 + %siuiext51 = sext i32 %58 to i64 %add52 = add i64 %siuiext51, 1 - %61 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 - %62 = load i64, ptr %61, align 8 - %uisitrunc53 = trunc i64 %62 to i32 - %63 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 - %64 = load ptr, ptr %63, align 8 - %65 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %59, i64 %add52, ptr @.str.8, i32 %uisitrunc53, ptr %64) - %66 = getelementptr inbounds %Doc, ptr %literal55, i32 0, i32 0 + %59 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 1 + %60 = load i64, ptr %59, align 8 + %uisitrunc53 = trunc i64 %60 to i32 + %61 = getelementptr inbounds %"char[]", ptr %url, i32 0, i32 0 + %62 = load ptr, ptr %61, align 8 + %63 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr %57, i64 %add52, ptr @.str.8, i32 %uisitrunc53, ptr %62) + %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 - %68 = load ptr, ptr %str, align 8 - %69 = load i32, ptr %len, align 4 - %sub = sub i32 %69, 1 + %65 = getelementptr inbounds %Head, ptr %literal58, i32 0, i32 0 + %66 = load ptr, ptr %str, align 8 + %67 = load i32, ptr %len, align 4 + %sub = sub i32 %67, 1 %sisiext = sext i32 %sub to i64 - %70 = add i64 %sisiext, 1 - %size = sub i64 %70, 0 - %ptroffset = getelementptr inbounds i8, ptr %68, i64 0 - %71 = insertvalue %"char[]" undef, ptr %ptroffset, 0 - %72 = insertvalue %"char[]" %71, i64 %size, 1 - store %"char[]" %72, ptr %value60, align 8 - %73 = call ptr @std_core_mem_malloc(i64 16) #2 - store ptr %73, ptr %temp61, align 8 - %74 = load ptr, ptr %temp61, align 8 - %not62 = icmp eq ptr %74, null + %68 = add i64 %sisiext, 1 + %size = sub i64 %68, 0 + %ptroffset = getelementptr inbounds i8, ptr %66, i64 0 + %69 = insertvalue %"char[]" undef, ptr %ptroffset, 0 + %70 = insertvalue %"char[]" %69, i64 %size, 1 + store %"char[]" %70, ptr %value60, align 8 + %71 = call ptr @std_core_mem_malloc(i64 16) #2 + store ptr %71, ptr %temp61, align 8 + %72 = load ptr, ptr %temp61, align 8 + %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 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %75, ptr align 8 %value60, i32 16, i1 false) + %73 = load ptr, ptr %temp61, align 8 + 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 - ret i64 %76 + %74 = load i64, ptr %error_var59, align 8 + ret i64 %74 noerr_block66: ; preds = %if.exit64 - %77 = load ptr, ptr %temp61, align 8 - store ptr %77, ptr %67, align 8 - %78 = load %Head, ptr %literal58, align 8 - store %Head %78, ptr %value57, align 8 - %79 = call ptr @std_core_mem_malloc(i64 8) #2 - store ptr %79, ptr %temp67, align 8 - %80 = load ptr, ptr %temp67, align 8 - %not68 = icmp eq ptr %80, null + %75 = load ptr, ptr %temp61, align 8 + store ptr %75, ptr %65, align 8 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %value57, ptr align 8 %literal58, i32 8, i1 false) + %76 = call ptr @std_core_mem_malloc(i64 8) #2 + store ptr %76, ptr %temp67, align 8 + %77 = load ptr, ptr %temp67, align 8 + %not68 = icmp eq ptr %77, 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 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %81, ptr align 8 %value57, i32 8, i1 false) + %78 = load ptr, ptr %temp67, align 8 + 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 - ret i64 %82 + %79 = load i64, ptr %error_var56, align 8 + ret i64 %79 noerr_block72: ; preds = %if.exit70 - %83 = load ptr, ptr %temp67, align 8 - store ptr %83, ptr %66, align 8 + %80 = load ptr, ptr %temp67, 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 - %not_err5 = icmp eq i64 %39, 0 + %optval = load i64, ptr %has_title.f, align 8 + %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 - %41 = call ptr @test_bool_to_string(i8 %40) + %39 = load i8, ptr %has_title, align 1 + %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 - %43 = call ptr @test_nameFromError(i64 %42) + %41 = load i64, ptr %has_title.f, align 8 + %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 ] - %44 = load i64, ptr %has_title.f, align 8 - %not_err8 = icmp eq i64 %44, 0 - br i1 %not_err8, label %after_check9, label %else_block10 + %val7 = phi ptr [ %40, %after_check6 ], [ %42, %else_block ] + %optval8 = load i64, ptr %has_title.f, align 8 + %not_err9 = icmp eq i64 %optval8, 0 + br i1 %not_err9, label %after_check10, label %else_block11 -after_check9: ; preds = %phi_block - %45 = load i8, ptr %has_title, align 1 - %46 = trunc i8 %45 to i1 - br label %phi_block11 +after_check10: ; preds = %phi_block + %43 = load i8, ptr %has_title, align 1 + %44 = trunc i8 %43 to i1 + br label %phi_block12 -else_block10: ; preds = %phi_block - br label %phi_block11 +else_block11: ; preds = %phi_block + br label %phi_block12 -phi_block11: ; preds = %else_block10, %after_check9 - %val12 = phi i1 [ %46, %after_check9 ], [ false, %else_block10 ] - %ternary = select i1 %val12, ptr @.str.26, ptr @.str.27 - %47 = call i32 (ptr, ...) @printf(ptr @.str.25, ptr %val7, ptr %ternary) - %48 = load i64, ptr %anon, align 8 - %add = add i64 %48, 1 +phi_block12: ; preds = %else_block11, %after_check10 + %val13 = phi i1 [ %44, %after_check10 ], [ false, %else_block11 ] + %ternary = select i1 %val13, ptr @.str.26, ptr @.str.27 + %45 = call i32 (ptr, ...) @printf(ptr @.str.25, ptr %val7, ptr %ternary) + %46 = load i64, ptr %anon, align 8 + %add = add i64 %46, 1 store i64 %add, ptr %anon, align 8 br label %loop.cond diff --git a/test/test_suite2/errors/failable_chained_init.c3t b/test/test_suite2/errors/failable_chained_init.c3t index 597e5cee9..b45123f51 100644 --- a/test/test_suite2/errors/failable_chained_init.c3t +++ b/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 - %taddr14 = alloca %"char[]", align 8 - %vararg17 = alloca %"variant[]", align 8 - %varargslots18 = alloca [1 x %variant], align 16 - %retparam25 = alloca i64, align 8 - %taddr26 = alloca %"char[]", align 8 - %vararg29 = alloca %"variant[]", align 8 - %varargslots30 = alloca [1 x %variant], align 16 - %retparam38 = alloca i64, align 8 - %taddr39 = alloca %"char[]", align 8 - %vararg42 = alloca %"variant[]", align 8 - %varargslots43 = alloca [1 x %variant], align 16 + %retparam14 = alloca i64, align 8 + %taddr15 = alloca %"char[]", align 8 + %vararg18 = alloca %"variant[]", align 8 + %varargslots19 = alloca [1 x %variant], align 16 + %retparam26 = alloca i64, align 8 + %taddr27 = alloca %"char[]", align 8 + %vararg30 = alloca %"variant[]", align 8 + %varargslots31 = alloca [1 x %variant], align 16 + %retparam40 = alloca i64, align 8 + %taddr41 = alloca %"char[]", align 8 + %vararg44 = alloca %"variant[]", align 8 + %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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %a.f, align 8 + %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 - %neq = icmp ne i64 %1, 0 + %0 = load i64, ptr %err, align 8 + %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 - %lo = load ptr, ptr %2, align 8 - %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %3, align 8 - %4 = insertvalue %variant undef, ptr %err, 0 - %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %5, ptr %6, align 16 - %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %7, align 8 - %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %8, align 8 - %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo1 = load ptr, ptr %9, align 8 - %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi2 = load i64, ptr %10, align 8 - %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) - %not_err3 = icmp eq i64 %11, 0 + %1 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 + %lo = load ptr, ptr %1, align 8 + %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 + %hi = load i64, ptr %2, align 8 + %3 = insertvalue %variant undef, ptr %err, 0 + %4 = insertvalue %variant %3, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %5 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %4, ptr %5, align 16 + %6 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 + store i64 1, ptr %6, align 8 + %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 + store ptr %varargslots, ptr %7, align 8 + %8 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 + %lo1 = load ptr, ptr %8, align 8 + %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 + %hi2 = load i64, ptr %9, align 8 + %10 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo1, i64 %hi2) + %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 - %not_err7 = icmp eq i64 %12, 0 - br i1 %not_err7, label %after_check9, label %assign_optional8 + %optval7 = load i64, ptr %b.f, align 8 + %not_err8 = icmp eq i64 %optval7, 0 + br i1 %not_err8, label %after_check10, label %assign_optional9 -assign_optional8: ; preds = %testblock6 - store i64 %12, ptr %err5, align 8 - br label %end_block10 +assign_optional9: ; preds = %testblock6 + store i64 %optval7, ptr %err5, align 8 + 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 - %13 = load i64, ptr %err5, align 8 - %neq11 = icmp ne i64 %13, 0 - br i1 %neq11, label %if.then12, label %if.exit24 +end_block11: ; preds = %after_check10, %assign_optional9 + %11 = load i64, ptr %err5, align 8 + %neq12 = icmp ne i64 %11, 0 + br i1 %neq12, label %if.then13, label %if.exit25 -if.then12: ; preds = %end_block10 - store %"char[]" { ptr @.str.1, i64 13 }, ptr %taddr14, align 8 - %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr14, i32 0, i32 0 - %lo15 = load ptr, ptr %14, align 8 - %15 = getelementptr inbounds { ptr, i64 }, ptr %taddr14, i32 0, i32 1 - %hi16 = load i64, ptr %15, align 8 - %16 = insertvalue %variant undef, ptr %err5, 0 - %17 = insertvalue %variant %16, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %18 = getelementptr inbounds [1 x %variant], ptr %varargslots18, i64 0, i64 0 - store %variant %17, ptr %18, align 16 - %19 = getelementptr inbounds %"variant[]", ptr %vararg17, i32 0, i32 1 - store i64 1, ptr %19, align 8 - %20 = getelementptr inbounds %"variant[]", ptr %vararg17, i32 0, i32 0 - store ptr %varargslots18, ptr %20, align 8 - %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg17, i32 0, i32 0 - %lo19 = load ptr, ptr %21, align 8 - %22 = getelementptr inbounds { ptr, i64 }, ptr %vararg17, i32 0, i32 1 - %hi20 = load i64, ptr %22, align 8 - %23 = call i64 @std_io_printfln(ptr %retparam13, ptr %lo15, i64 %hi16, ptr %lo19, i64 %hi20) - %not_err21 = icmp eq i64 %23, 0 - br i1 %not_err21, label %after_check22, label %voiderr23 +if.then13: ; preds = %end_block11 + store %"char[]" { ptr @.str.1, i64 13 }, ptr %taddr15, align 8 + %12 = getelementptr inbounds { ptr, i64 }, ptr %taddr15, i32 0, i32 0 + %lo16 = load ptr, ptr %12, align 8 + %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr15, i32 0, i32 1 + %hi17 = load i64, ptr %13, align 8 + %14 = insertvalue %variant undef, ptr %err5, 0 + %15 = insertvalue %variant %14, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %16 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0 + store %variant %15, ptr %16, align 16 + %17 = getelementptr inbounds %"variant[]", ptr %vararg18, i32 0, i32 1 + store i64 1, ptr %17, align 8 + %18 = getelementptr inbounds %"variant[]", ptr %vararg18, i32 0, i32 0 + store ptr %varargslots19, ptr %18, align 8 + %19 = getelementptr inbounds { ptr, i64 }, ptr %vararg18, i32 0, i32 0 + %lo20 = load ptr, ptr %19, align 8 + %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg18, i32 0, i32 1 + %hi21 = load i64, ptr %20, align 8 + %21 = call i64 @std_io_printfln(ptr %retparam14, ptr %lo16, i64 %hi17, ptr %lo20, i64 %hi21) + %not_err22 = icmp eq i64 %21, 0 + br i1 %not_err22, label %after_check23, label %voiderr24 -after_check22: ; preds = %if.then12 - br label %voiderr23 +after_check23: ; preds = %if.then13 + br label %voiderr24 -voiderr23: ; preds = %after_check22, %if.then12 - br label %if.exit24 +voiderr24: ; preds = %after_check23, %if.then13 + br label %if.exit25 -if.exit24: ; preds = %voiderr23, %end_block10 - store %"char[]" { ptr @.str.2, i64 9 }, ptr %taddr26, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr26, i32 0, i32 0 - %lo27 = load ptr, ptr %24, align 8 - %25 = getelementptr inbounds { ptr, i64 }, ptr %taddr26, i32 0, i32 1 - %hi28 = load i64, ptr %25, align 8 - %26 = load i64, ptr %a.f, align 8 - %not_err31 = icmp eq i64 %26, 0 - br i1 %not_err31, label %after_check32, label %voiderr37 +if.exit25: ; preds = %voiderr24, %end_block11 + store %"char[]" { ptr @.str.2, i64 9 }, ptr %taddr27, align 8 + %22 = getelementptr inbounds { ptr, i64 }, ptr %taddr27, i32 0, i32 0 + %lo28 = load ptr, ptr %22, align 8 + %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr27, i32 0, i32 1 + %hi29 = load i64, ptr %23, align 8 + %optval32 = load i64, ptr %a.f, align 8 + %not_err33 = icmp eq i64 %optval32, 0 + br i1 %not_err33, label %after_check34, label %voiderr39 -after_check32: ; preds = %if.exit24 - %27 = insertvalue %variant undef, ptr %a, 0 - %28 = insertvalue %variant %27, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %29 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0 - store %variant %28, ptr %29, align 16 - %30 = getelementptr inbounds %"variant[]", ptr %vararg29, i32 0, i32 1 - store i64 1, ptr %30, align 8 - %31 = getelementptr inbounds %"variant[]", ptr %vararg29, i32 0, i32 0 - store ptr %varargslots30, ptr %31, align 8 - %32 = getelementptr inbounds { ptr, i64 }, ptr %vararg29, i32 0, i32 0 - %lo33 = load ptr, ptr %32, align 8 - %33 = getelementptr inbounds { ptr, i64 }, ptr %vararg29, i32 0, i32 1 - %hi34 = load i64, ptr %33, align 8 - %34 = call i64 @std_io_printfln(ptr %retparam25, ptr %lo27, i64 %hi28, ptr %lo33, i64 %hi34) - %not_err35 = icmp eq i64 %34, 0 - br i1 %not_err35, label %after_check36, label %voiderr37 +after_check34: ; preds = %if.exit25 + %24 = insertvalue %variant undef, ptr %a, 0 + %25 = insertvalue %variant %24, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %26 = getelementptr inbounds [1 x %variant], ptr %varargslots31, i64 0, i64 0 + store %variant %25, ptr %26, align 16 + %27 = getelementptr inbounds %"variant[]", ptr %vararg30, i32 0, i32 1 + store i64 1, ptr %27, align 8 + %28 = getelementptr inbounds %"variant[]", ptr %vararg30, i32 0, i32 0 + store ptr %varargslots31, ptr %28, align 8 + %29 = getelementptr inbounds { ptr, i64 }, ptr %vararg30, i32 0, i32 0 + %lo35 = load ptr, ptr %29, align 8 + %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg30, i32 0, i32 1 + %hi36 = load i64, ptr %30, align 8 + %31 = call i64 @std_io_printfln(ptr %retparam26, ptr %lo28, i64 %hi29, ptr %lo35, i64 %hi36) + %not_err37 = icmp eq i64 %31, 0 + br i1 %not_err37, label %after_check38, label %voiderr39 -after_check36: ; preds = %after_check32 - br label %voiderr37 +after_check38: ; preds = %after_check34 + br label %voiderr39 -voiderr37: ; preds = %after_check36, %after_check32, %if.exit24 - store %"char[]" { ptr @.str.3, i64 9 }, ptr %taddr39, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %taddr39, i32 0, i32 0 - %lo40 = load ptr, ptr %35, align 8 - %36 = getelementptr inbounds { ptr, i64 }, ptr %taddr39, i32 0, i32 1 - %hi41 = load i64, ptr %36, align 8 - %37 = load i64, ptr %b.f, align 8 - %not_err44 = icmp eq i64 %37, 0 - br i1 %not_err44, label %after_check45, label %voiderr50 +voiderr39: ; preds = %after_check38, %after_check34, %if.exit25 + store %"char[]" { ptr @.str.3, i64 9 }, ptr %taddr41, align 8 + %32 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 0 + %lo42 = load ptr, ptr %32, align 8 + %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr41, i32 0, i32 1 + %hi43 = load i64, ptr %33, align 8 + %optval46 = load i64, ptr %b.f, align 8 + %not_err47 = icmp eq i64 %optval46, 0 + br i1 %not_err47, label %after_check48, label %voiderr53 -after_check45: ; preds = %voiderr37 - %38 = insertvalue %variant undef, ptr %b, 0 - %39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %40 = getelementptr inbounds [1 x %variant], ptr %varargslots43, i64 0, i64 0 - store %variant %39, ptr %40, align 16 - %41 = getelementptr inbounds %"variant[]", ptr %vararg42, i32 0, i32 1 - store i64 1, ptr %41, align 8 - %42 = getelementptr inbounds %"variant[]", ptr %vararg42, i32 0, i32 0 - store ptr %varargslots43, ptr %42, align 8 - %43 = getelementptr inbounds { ptr, i64 }, ptr %vararg42, i32 0, i32 0 - %lo46 = load ptr, ptr %43, align 8 - %44 = getelementptr inbounds { ptr, i64 }, ptr %vararg42, i32 0, i32 1 - %hi47 = load i64, ptr %44, align 8 - %45 = call i64 @std_io_printfln(ptr %retparam38, ptr %lo40, i64 %hi41, ptr %lo46, i64 %hi47) - %not_err48 = icmp eq i64 %45, 0 - br i1 %not_err48, label %after_check49, label %voiderr50 +after_check48: ; preds = %voiderr39 + %34 = insertvalue %variant undef, ptr %b, 0 + %35 = insertvalue %variant %34, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %36 = getelementptr inbounds [1 x %variant], ptr %varargslots45, i64 0, i64 0 + store %variant %35, ptr %36, align 16 + %37 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 1 + store i64 1, ptr %37, align 8 + %38 = getelementptr inbounds %"variant[]", ptr %vararg44, i32 0, i32 0 + store ptr %varargslots45, ptr %38, align 8 + %39 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 0 + %lo49 = load ptr, ptr %39, align 8 + %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg44, i32 0, i32 1 + %hi50 = load i64, ptr %40, align 8 + %41 = call i64 @std_io_printfln(ptr %retparam40, ptr %lo42, i64 %hi43, ptr %lo49, i64 %hi50) + %not_err51 = icmp eq i64 %41, 0 + br i1 %not_err51, label %after_check52, label %voiderr53 -after_check49: ; preds = %after_check45 - br label %voiderr50 +after_check52: ; preds = %after_check48 + 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 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [1 x %variant], align 16 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [1 x %variant], align 16 - %retparam42 = alloca i64, align 8 - %taddr43 = alloca %"char[]", align 8 - %vararg46 = alloca %"variant[]", align 8 - %varargslots47 = alloca [1 x %variant], align 16 + %err10 = alloca i64, align 8 + %retparam19 = alloca i64, align 8 + %taddr20 = alloca %"char[]", align 8 + %vararg23 = alloca %"variant[]", align 8 + %varargslots24 = alloca [1 x %variant], align 16 + %retparam31 = alloca i64, align 8 + %taddr32 = alloca %"char[]", align 8 + %vararg35 = alloca %"variant[]", align 8 + %varargslots36 = alloca [1 x %variant], align 16 + %retparam45 = alloca i64, align 8 + %taddr46 = alloca %"char[]", align 8 + %vararg49 = alloca %"variant[]", align 8 + %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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %x.f, align 8 + %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 - store i32 %1, ptr %a, align 4 + %0 = load i32, ptr %x, 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 - %not_err2 = icmp eq i64 %2, 0 - br i1 %not_err2, label %after_check4, label %assign_optional3 + %optval2 = load i64, ptr %a.f, align 8 + %not_err3 = icmp eq i64 %optval2, 0 + br i1 %not_err3, label %after_check5, label %assign_optional4 -assign_optional3: ; preds = %testblock - store i64 %2, ptr %err, align 8 +assign_optional4: ; preds = %testblock + 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 - %3 = load i64, ptr %err, align 8 - %neq = icmp ne i64 %3, 0 +end_block: ; preds = %after_check5, %assign_optional4 + %1 = load i64, ptr %err, align 8 + %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 - %lo = load ptr, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %5, align 8 - %6 = insertvalue %variant undef, ptr %err, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %7, ptr %8, align 16 - %9 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %9, align 8 - %10 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %10, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo5 = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi6 = load i64, ptr %12, align 8 - %13 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo5, i64 %hi6) - %not_err7 = icmp eq i64 %13, 0 - br i1 %not_err7, label %after_check8, label %voiderr + %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 + %lo = load ptr, ptr %2, align 8 + %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 + %hi = load i64, ptr %3, align 8 + %4 = insertvalue %variant undef, ptr %err, 0 + %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %5, ptr %6, align 16 + %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 + store i64 1, ptr %7, align 8 + %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 + store ptr %varargslots, ptr %8, align 8 + %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 + %lo6 = load ptr, ptr %9, align 8 + %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 + %hi7 = load i64, ptr %10, align 8 + %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %11, 0 + 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 - %14 = load i64, ptr %b.f, align 8 - %not_err11 = icmp eq i64 %14, 0 - br i1 %not_err11, label %after_check13, label %assign_optional12 +testblock11: ; preds = %if.exit + %optval12 = load i64, ptr %b.f, align 8 + %not_err13 = icmp eq i64 %optval12, 0 + br i1 %not_err13, label %after_check15, label %assign_optional14 -assign_optional12: ; preds = %testblock10 - store i64 %14, ptr %err9, align 8 - br label %end_block14 +assign_optional14: ; preds = %testblock11 + store i64 %optval12, ptr %err10, align 8 + br label %end_block16 -after_check13: ; preds = %testblock10 - store i64 0, ptr %err9, align 8 - br label %end_block14 +after_check15: ; preds = %testblock11 + store i64 0, ptr %err10, align 8 + br label %end_block16 -end_block14: ; preds = %after_check13, %assign_optional12 - %15 = load i64, ptr %err9, align 8 - %neq15 = icmp ne i64 %15, 0 - br i1 %neq15, label %if.then16, label %if.exit28 +end_block16: ; preds = %after_check15, %assign_optional14 + %12 = load i64, ptr %err10, align 8 + %neq17 = icmp ne i64 %12, 0 + br i1 %neq17, label %if.then18, label %if.exit30 -if.then16: ; preds = %end_block14 - store %"char[]" { ptr @.str.5, i64 13 }, ptr %taddr18, align 8 - %16 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 0 - %lo19 = load ptr, ptr %16, align 8 - %17 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 1 - %hi20 = load i64, ptr %17, align 8 - %18 = insertvalue %variant undef, ptr %err9, 0 - %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %20 = getelementptr inbounds [1 x %variant], ptr %varargslots22, i64 0, i64 0 - store %variant %19, ptr %20, align 16 - %21 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 1 - store i64 1, ptr %21, align 8 - %22 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 0 - store ptr %varargslots22, ptr %22, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 0 - %lo23 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 1 - %hi24 = load i64, ptr %24, align 8 - %25 = call i64 @std_io_printfln(ptr %retparam17, ptr %lo19, i64 %hi20, ptr %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %25, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +if.then18: ; preds = %end_block16 + store %"char[]" { ptr @.str.5, i64 13 }, ptr %taddr20, align 8 + %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0 + %lo21 = load ptr, ptr %13, align 8 + %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1 + %hi22 = load i64, ptr %14, align 8 + %15 = insertvalue %variant undef, ptr %err10, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 + store %variant %16, ptr %17, align 16 + %18 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1 + store i64 1, ptr %18, align 8 + %19 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0 + store ptr %varargslots24, ptr %19, align 8 + %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 + %lo25 = load ptr, ptr %20, align 8 + %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 + %hi26 = load i64, ptr %21, align 8 + %22 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26) + %not_err27 = icmp eq i64 %22, 0 + br i1 %not_err27, label %after_check28, label %voiderr29 -after_check26: ; preds = %if.then16 - br label %voiderr27 +after_check28: ; preds = %if.then18 + br label %voiderr29 -voiderr27: ; preds = %after_check26, %if.then16 - br label %if.exit28 +voiderr29: ; preds = %after_check28, %if.then18 + br label %if.exit30 -if.exit28: ; preds = %voiderr27, %end_block14 - store %"char[]" { ptr @.str.6, i64 9 }, ptr %taddr30, align 8 - %26 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 0 - %lo31 = load ptr, ptr %26, align 8 - %27 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 1 - %hi32 = load i64, ptr %27, align 8 - %28 = load i64, ptr %a.f, align 8 - %not_err35 = icmp eq i64 %28, 0 - br i1 %not_err35, label %after_check36, label %voiderr41 +if.exit30: ; preds = %voiderr29, %end_block16 + store %"char[]" { ptr @.str.6, i64 9 }, ptr %taddr32, align 8 + %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 0 + %lo33 = load ptr, ptr %23, align 8 + %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 1 + %hi34 = load i64, ptr %24, align 8 + %optval37 = load i64, ptr %a.f, align 8 + %not_err38 = icmp eq i64 %optval37, 0 + br i1 %not_err38, label %after_check39, label %voiderr44 -after_check36: ; preds = %if.exit28 - %29 = insertvalue %variant undef, ptr %a, 0 - %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %31 = getelementptr inbounds [1 x %variant], ptr %varargslots34, i64 0, i64 0 - store %variant %30, ptr %31, align 16 - %32 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 1 - store i64 1, ptr %32, align 8 - %33 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 0 - store ptr %varargslots34, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 0 - %lo37 = load ptr, ptr %34, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 1 - %hi38 = load i64, ptr %35, align 8 - %36 = call i64 @std_io_printfln(ptr %retparam29, ptr %lo31, i64 %hi32, ptr %lo37, i64 %hi38) - %not_err39 = icmp eq i64 %36, 0 - br i1 %not_err39, label %after_check40, label %voiderr41 +after_check39: ; preds = %if.exit30 + %25 = insertvalue %variant undef, ptr %a, 0 + %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %27 = getelementptr inbounds [1 x %variant], ptr %varargslots36, i64 0, i64 0 + store %variant %26, ptr %27, align 16 + %28 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 1 + store i64 1, ptr %28, align 8 + %29 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 0 + store ptr %varargslots36, ptr %29, align 8 + %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 0 + %lo40 = load ptr, ptr %30, align 8 + %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 1 + %hi41 = load i64, ptr %31, align 8 + %32 = call i64 @std_io_printfln(ptr %retparam31, ptr %lo33, i64 %hi34, ptr %lo40, i64 %hi41) + %not_err42 = icmp eq i64 %32, 0 + br i1 %not_err42, label %after_check43, label %voiderr44 -after_check40: ; preds = %after_check36 - br label %voiderr41 +after_check43: ; preds = %after_check39 + br label %voiderr44 -voiderr41: ; preds = %after_check40, %after_check36, %if.exit28 - store %"char[]" { ptr @.str.7, i64 9 }, ptr %taddr43, align 8 - %37 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 0 - %lo44 = load ptr, ptr %37, align 8 - %38 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 1 - %hi45 = load i64, ptr %38, align 8 - %39 = load i64, ptr %b.f, align 8 - %not_err48 = icmp eq i64 %39, 0 - br i1 %not_err48, label %after_check49, label %voiderr54 +voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 + store %"char[]" { ptr @.str.7, i64 9 }, ptr %taddr46, align 8 + %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 0 + %lo47 = load ptr, ptr %33, align 8 + %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 1 + %hi48 = load i64, ptr %34, align 8 + %optval51 = load i64, ptr %b.f, align 8 + %not_err52 = icmp eq i64 %optval51, 0 + br i1 %not_err52, label %after_check53, label %voiderr58 -after_check49: ; preds = %voiderr41 - %40 = insertvalue %variant undef, ptr %b, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %42 = getelementptr inbounds [1 x %variant], ptr %varargslots47, i64 0, i64 0 - store %variant %41, ptr %42, align 16 - %43 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 1 - store i64 1, ptr %43, align 8 - %44 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 0 - store ptr %varargslots47, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 0 - %lo50 = load ptr, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 1 - %hi51 = load i64, ptr %46, align 8 - %47 = call i64 @std_io_printfln(ptr %retparam42, ptr %lo44, i64 %hi45, ptr %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %47, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 +after_check53: ; preds = %voiderr44 + %35 = insertvalue %variant undef, ptr %b, 0 + %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %37 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0 + store %variant %36, ptr %37, align 16 + %38 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 1 + store i64 1, ptr %38, align 8 + %39 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 0 + store ptr %varargslots50, ptr %39, align 8 + %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 0 + %lo54 = load ptr, ptr %40, align 8 + %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 1 + %hi55 = load i64, ptr %41, align 8 + %42 = call i64 @std_io_printfln(ptr %retparam45, ptr %lo47, i64 %hi48, ptr %lo54, i64 %hi55) + %not_err56 = icmp eq i64 %42, 0 + br i1 %not_err56, label %after_check57, label %voiderr58 -after_check53: ; preds = %after_check49 - br label %voiderr54 +after_check57: ; preds = %after_check53 + 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 - %retparam17 = alloca i64, align 8 - %taddr18 = alloca %"char[]", align 8 - %vararg21 = alloca %"variant[]", align 8 - %varargslots22 = alloca [1 x %variant], align 16 - %retparam29 = alloca i64, align 8 - %taddr30 = alloca %"char[]", align 8 - %vararg33 = alloca %"variant[]", align 8 - %varargslots34 = alloca [1 x %variant], align 16 - %retparam42 = alloca i64, align 8 - %taddr43 = alloca %"char[]", align 8 - %vararg46 = alloca %"variant[]", align 8 - %varargslots47 = alloca [1 x %variant], align 16 + %err10 = alloca i64, align 8 + %retparam19 = alloca i64, align 8 + %taddr20 = alloca %"char[]", align 8 + %vararg23 = alloca %"variant[]", align 8 + %varargslots24 = alloca [1 x %variant], align 16 + %retparam31 = alloca i64, align 8 + %taddr32 = alloca %"char[]", align 8 + %vararg35 = alloca %"variant[]", align 8 + %varargslots36 = alloca [1 x %variant], align 16 + %retparam45 = alloca i64, align 8 + %taddr46 = alloca %"char[]", align 8 + %vararg49 = alloca %"variant[]", align 8 + %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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %x.f, align 8 + %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 - store i32 %1, ptr %a, align 4 + %0 = load i32, ptr %x, 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 - %not_err2 = icmp eq i64 %2, 0 - br i1 %not_err2, label %after_check4, label %assign_optional3 + %optval2 = load i64, ptr %a.f, align 8 + %not_err3 = icmp eq i64 %optval2, 0 + br i1 %not_err3, label %after_check5, label %assign_optional4 -assign_optional3: ; preds = %testblock - store i64 %2, ptr %err, align 8 +assign_optional4: ; preds = %testblock + 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 - %3 = load i64, ptr %err, align 8 - %neq = icmp ne i64 %3, 0 +end_block: ; preds = %after_check5, %assign_optional4 + %1 = load i64, ptr %err, align 8 + %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 - %lo = load ptr, ptr %4, align 8 - %5 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 - %hi = load i64, ptr %5, align 8 - %6 = insertvalue %variant undef, ptr %err, 0 - %7 = insertvalue %variant %6, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %8 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 - store %variant %7, ptr %8, align 16 - %9 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 - store i64 1, ptr %9, align 8 - %10 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 - store ptr %varargslots, ptr %10, align 8 - %11 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 - %lo5 = load ptr, ptr %11, align 8 - %12 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 - %hi6 = load i64, ptr %12, align 8 - %13 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo5, i64 %hi6) - %not_err7 = icmp eq i64 %13, 0 - br i1 %not_err7, label %after_check8, label %voiderr + %2 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 0 + %lo = load ptr, ptr %2, align 8 + %3 = getelementptr inbounds { ptr, i64 }, ptr %taddr, i32 0, i32 1 + %hi = load i64, ptr %3, align 8 + %4 = insertvalue %variant undef, ptr %err, 0 + %5 = insertvalue %variant %4, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %6 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0 + store %variant %5, ptr %6, align 16 + %7 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 1 + store i64 1, ptr %7, align 8 + %8 = getelementptr inbounds %"variant[]", ptr %vararg, i32 0, i32 0 + store ptr %varargslots, ptr %8, align 8 + %9 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 0 + %lo6 = load ptr, ptr %9, align 8 + %10 = getelementptr inbounds { ptr, i64 }, ptr %vararg, i32 0, i32 1 + %hi7 = load i64, ptr %10, align 8 + %11 = call i64 @std_io_printfln(ptr %retparam, ptr %lo, i64 %hi, ptr %lo6, i64 %hi7) + %not_err8 = icmp eq i64 %11, 0 + 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 - %14 = load i64, ptr %b.f, align 8 - %not_err11 = icmp eq i64 %14, 0 - br i1 %not_err11, label %after_check13, label %assign_optional12 +testblock11: ; preds = %if.exit + %optval12 = load i64, ptr %b.f, align 8 + %not_err13 = icmp eq i64 %optval12, 0 + br i1 %not_err13, label %after_check15, label %assign_optional14 -assign_optional12: ; preds = %testblock10 - store i64 %14, ptr %err9, align 8 - br label %end_block14 +assign_optional14: ; preds = %testblock11 + store i64 %optval12, ptr %err10, align 8 + br label %end_block16 -after_check13: ; preds = %testblock10 - store i64 0, ptr %err9, align 8 - br label %end_block14 +after_check15: ; preds = %testblock11 + store i64 0, ptr %err10, align 8 + br label %end_block16 -end_block14: ; preds = %after_check13, %assign_optional12 - %15 = load i64, ptr %err9, align 8 - %neq15 = icmp ne i64 %15, 0 - br i1 %neq15, label %if.then16, label %if.exit28 +end_block16: ; preds = %after_check15, %assign_optional14 + %12 = load i64, ptr %err10, align 8 + %neq17 = icmp ne i64 %12, 0 + br i1 %neq17, label %if.then18, label %if.exit30 -if.then16: ; preds = %end_block14 - store %"char[]" { ptr @.str.9, i64 13 }, ptr %taddr18, align 8 - %16 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 0 - %lo19 = load ptr, ptr %16, align 8 - %17 = getelementptr inbounds { ptr, i64 }, ptr %taddr18, i32 0, i32 1 - %hi20 = load i64, ptr %17, align 8 - %18 = insertvalue %variant undef, ptr %err9, 0 - %19 = insertvalue %variant %18, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 - %20 = getelementptr inbounds [1 x %variant], ptr %varargslots22, i64 0, i64 0 - store %variant %19, ptr %20, align 16 - %21 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 1 - store i64 1, ptr %21, align 8 - %22 = getelementptr inbounds %"variant[]", ptr %vararg21, i32 0, i32 0 - store ptr %varargslots22, ptr %22, align 8 - %23 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 0 - %lo23 = load ptr, ptr %23, align 8 - %24 = getelementptr inbounds { ptr, i64 }, ptr %vararg21, i32 0, i32 1 - %hi24 = load i64, ptr %24, align 8 - %25 = call i64 @std_io_printfln(ptr %retparam17, ptr %lo19, i64 %hi20, ptr %lo23, i64 %hi24) - %not_err25 = icmp eq i64 %25, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 +if.then18: ; preds = %end_block16 + store %"char[]" { ptr @.str.9, i64 13 }, ptr %taddr20, align 8 + %13 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 0 + %lo21 = load ptr, ptr %13, align 8 + %14 = getelementptr inbounds { ptr, i64 }, ptr %taddr20, i32 0, i32 1 + %hi22 = load i64, ptr %14, align 8 + %15 = insertvalue %variant undef, ptr %err10, 0 + %16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$anyerr" to i64), 1 + %17 = getelementptr inbounds [1 x %variant], ptr %varargslots24, i64 0, i64 0 + store %variant %16, ptr %17, align 16 + %18 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 1 + store i64 1, ptr %18, align 8 + %19 = getelementptr inbounds %"variant[]", ptr %vararg23, i32 0, i32 0 + store ptr %varargslots24, ptr %19, align 8 + %20 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 0 + %lo25 = load ptr, ptr %20, align 8 + %21 = getelementptr inbounds { ptr, i64 }, ptr %vararg23, i32 0, i32 1 + %hi26 = load i64, ptr %21, align 8 + %22 = call i64 @std_io_printfln(ptr %retparam19, ptr %lo21, i64 %hi22, ptr %lo25, i64 %hi26) + %not_err27 = icmp eq i64 %22, 0 + br i1 %not_err27, label %after_check28, label %voiderr29 -after_check26: ; preds = %if.then16 - br label %voiderr27 +after_check28: ; preds = %if.then18 + br label %voiderr29 -voiderr27: ; preds = %after_check26, %if.then16 - br label %if.exit28 +voiderr29: ; preds = %after_check28, %if.then18 + br label %if.exit30 -if.exit28: ; preds = %voiderr27, %end_block14 - store %"char[]" { ptr @.str.10, i64 9 }, ptr %taddr30, align 8 - %26 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 0 - %lo31 = load ptr, ptr %26, align 8 - %27 = getelementptr inbounds { ptr, i64 }, ptr %taddr30, i32 0, i32 1 - %hi32 = load i64, ptr %27, align 8 - %28 = load i64, ptr %a.f, align 8 - %not_err35 = icmp eq i64 %28, 0 - br i1 %not_err35, label %after_check36, label %voiderr41 +if.exit30: ; preds = %voiderr29, %end_block16 + store %"char[]" { ptr @.str.10, i64 9 }, ptr %taddr32, align 8 + %23 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 0 + %lo33 = load ptr, ptr %23, align 8 + %24 = getelementptr inbounds { ptr, i64 }, ptr %taddr32, i32 0, i32 1 + %hi34 = load i64, ptr %24, align 8 + %optval37 = load i64, ptr %a.f, align 8 + %not_err38 = icmp eq i64 %optval37, 0 + br i1 %not_err38, label %after_check39, label %voiderr44 -after_check36: ; preds = %if.exit28 - %29 = insertvalue %variant undef, ptr %a, 0 - %30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %31 = getelementptr inbounds [1 x %variant], ptr %varargslots34, i64 0, i64 0 - store %variant %30, ptr %31, align 16 - %32 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 1 - store i64 1, ptr %32, align 8 - %33 = getelementptr inbounds %"variant[]", ptr %vararg33, i32 0, i32 0 - store ptr %varargslots34, ptr %33, align 8 - %34 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 0 - %lo37 = load ptr, ptr %34, align 8 - %35 = getelementptr inbounds { ptr, i64 }, ptr %vararg33, i32 0, i32 1 - %hi38 = load i64, ptr %35, align 8 - %36 = call i64 @std_io_printfln(ptr %retparam29, ptr %lo31, i64 %hi32, ptr %lo37, i64 %hi38) - %not_err39 = icmp eq i64 %36, 0 - br i1 %not_err39, label %after_check40, label %voiderr41 +after_check39: ; preds = %if.exit30 + %25 = insertvalue %variant undef, ptr %a, 0 + %26 = insertvalue %variant %25, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %27 = getelementptr inbounds [1 x %variant], ptr %varargslots36, i64 0, i64 0 + store %variant %26, ptr %27, align 16 + %28 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 1 + store i64 1, ptr %28, align 8 + %29 = getelementptr inbounds %"variant[]", ptr %vararg35, i32 0, i32 0 + store ptr %varargslots36, ptr %29, align 8 + %30 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 0 + %lo40 = load ptr, ptr %30, align 8 + %31 = getelementptr inbounds { ptr, i64 }, ptr %vararg35, i32 0, i32 1 + %hi41 = load i64, ptr %31, align 8 + %32 = call i64 @std_io_printfln(ptr %retparam31, ptr %lo33, i64 %hi34, ptr %lo40, i64 %hi41) + %not_err42 = icmp eq i64 %32, 0 + br i1 %not_err42, label %after_check43, label %voiderr44 -after_check40: ; preds = %after_check36 - br label %voiderr41 +after_check43: ; preds = %after_check39 + br label %voiderr44 -voiderr41: ; preds = %after_check40, %after_check36, %if.exit28 - store %"char[]" { ptr @.str.11, i64 9 }, ptr %taddr43, align 8 - %37 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 0 - %lo44 = load ptr, ptr %37, align 8 - %38 = getelementptr inbounds { ptr, i64 }, ptr %taddr43, i32 0, i32 1 - %hi45 = load i64, ptr %38, align 8 - %39 = load i64, ptr %b.f, align 8 - %not_err48 = icmp eq i64 %39, 0 - br i1 %not_err48, label %after_check49, label %voiderr54 +voiderr44: ; preds = %after_check43, %after_check39, %if.exit30 + store %"char[]" { ptr @.str.11, i64 9 }, ptr %taddr46, align 8 + %33 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 0 + %lo47 = load ptr, ptr %33, align 8 + %34 = getelementptr inbounds { ptr, i64 }, ptr %taddr46, i32 0, i32 1 + %hi48 = load i64, ptr %34, align 8 + %optval51 = load i64, ptr %b.f, align 8 + %not_err52 = icmp eq i64 %optval51, 0 + br i1 %not_err52, label %after_check53, label %voiderr58 -after_check49: ; preds = %voiderr41 - %40 = insertvalue %variant undef, ptr %b, 0 - %41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$int" to i64), 1 - %42 = getelementptr inbounds [1 x %variant], ptr %varargslots47, i64 0, i64 0 - store %variant %41, ptr %42, align 16 - %43 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 1 - store i64 1, ptr %43, align 8 - %44 = getelementptr inbounds %"variant[]", ptr %vararg46, i32 0, i32 0 - store ptr %varargslots47, ptr %44, align 8 - %45 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 0 - %lo50 = load ptr, ptr %45, align 8 - %46 = getelementptr inbounds { ptr, i64 }, ptr %vararg46, i32 0, i32 1 - %hi51 = load i64, ptr %46, align 8 - %47 = call i64 @std_io_printfln(ptr %retparam42, ptr %lo44, i64 %hi45, ptr %lo50, i64 %hi51) - %not_err52 = icmp eq i64 %47, 0 - br i1 %not_err52, label %after_check53, label %voiderr54 +after_check53: ; preds = %voiderr44 + %35 = insertvalue %variant undef, ptr %b, 0 + %36 = insertvalue %variant %35, i64 ptrtoint (ptr @"ct$int" to i64), 1 + %37 = getelementptr inbounds [1 x %variant], ptr %varargslots50, i64 0, i64 0 + store %variant %36, ptr %37, align 16 + %38 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 1 + store i64 1, ptr %38, align 8 + %39 = getelementptr inbounds %"variant[]", ptr %vararg49, i32 0, i32 0 + store ptr %varargslots50, ptr %39, align 8 + %40 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 0 + %lo54 = load ptr, ptr %40, align 8 + %41 = getelementptr inbounds { ptr, i64 }, ptr %vararg49, i32 0, i32 1 + %hi55 = load i64, ptr %41, align 8 + %42 = call i64 @std_io_printfln(ptr %retparam45, ptr %lo47, i64 %hi48, ptr %lo54, i64 %hi55) + %not_err56 = icmp eq i64 %42, 0 + br i1 %not_err56, label %after_check57, label %voiderr58 -after_check53: ; preds = %after_check49 - br label %voiderr54 +after_check57: ; preds = %after_check53 + br label %voiderr58 -voiderr54: ; preds = %after_check53, %after_check49, %voiderr41 +voiderr58: ; preds = %after_check57, %after_check53, %voiderr44 ret void } diff --git a/test/test_suite2/errors/failable_inits.c3t b/test/test_suite2/errors/failable_inits.c3t index eea3ce878..e21850667 100644 --- a/test/test_suite2/errors/failable_inits.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %x.f, align 8 + %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 - ret i64 %1 + %0 = load i64, ptr %error_var, align 8 + 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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %x.f, align 8 + %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 - ret i64 %1 + %0 = load i64, ptr %error_var, align 8 + 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) diff --git a/test/test_suite2/errors/failable_taddr_and_access.c3t b/test/test_suite2/errors/failable_taddr_and_access.c3t index aca3b89a0..e3ccb5135 100644 --- a/test/test_suite2/errors/failable_taddr_and_access.c3t +++ b/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 - %not_err = icmp eq i64 %1, 0 + %optval = load i64, ptr %z.f, align 8 + %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 - store i32 %2, ptr %0, align 4 - %3 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1 - store i32 0, ptr %3, align 4 + %1 = load i32, ptr %z, align 4 + store i32 %1, ptr %0, align 4 + %2 = getelementptr inbounds %Foo, ptr %literal, i32 0, i32 1 + 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 - %not_err1 = icmp eq i64 %4, 0 - br i1 %not_err1, label %after_check2, label %voiderr + %optval1 = load i64, ptr %w.f, align 8 + %not_err2 = icmp eq i64 %optval1, 0 + br i1 %not_err2, label %after_check3, label %voiderr -after_check2: ; preds = %after_assign - %5 = load ptr, ptr %w, align 8 - %6 = getelementptr inbounds %Foo, ptr %5, i32 0, i32 0 - %7 = load i32, ptr %6, align 8 - %8 = call i32 (ptr, ...) @printf(ptr @.str, i32 %7) +after_check3: ; preds = %after_assign + %3 = load ptr, ptr %w, align 8 + %4 = getelementptr inbounds %Foo, ptr %3, i32 0, i32 0 + %5 = load i32, ptr %4, align 8 + %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 - %9 = getelementptr inbounds %Foo, ptr %literal5, i32 0, i32 0 - %10 = load i64, ptr %z.f, align 8 - %not_err6 = icmp eq i64 %10, 0 - br i1 %not_err6, label %after_check8, label %assign_optional7 +voiderr5: ; preds = %voiderr + %7 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 0 + %optval7 = load i64, ptr %z.f, align 8 + %not_err8 = icmp eq i64 %optval7, 0 + br i1 %not_err8, label %after_check10, label %assign_optional9 -assign_optional7: ; preds = %voiderr4 - store i64 %10, ptr %w.f, align 8 - br label %after_assign9 +assign_optional9: ; preds = %voiderr5 + store i64 %optval7, ptr %w.f, align 8 + br label %after_assign11 -after_check8: ; preds = %voiderr4 - %11 = load i32, ptr %z, align 4 - store i32 %11, ptr %9, align 4 - %12 = getelementptr inbounds %Foo, ptr %literal5, i32 0, i32 1 - store i32 0, ptr %12, align 4 - store ptr %literal5, ptr %w, align 8 +after_check10: ; preds = %voiderr5 + %8 = load i32, ptr %z, align 4 + store i32 %8, ptr %7, align 4 + %9 = getelementptr inbounds %Foo, ptr %literal6, i32 0, i32 1 + store i32 0, ptr %9, align 4 + 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 - br label %voiderr10 +after_assign11: ; preds = %after_check10, %assign_optional9 + br label %voiderr12 -voiderr10: ; preds = %after_assign9 - %13 = load i64, ptr %w.f, align 8 - %not_err11 = icmp eq i64 %13, 0 - br i1 %not_err11, label %after_check12, label %voiderr13 +voiderr12: ; preds = %after_assign11 + %optval13 = load i64, ptr %w.f, align 8 + %not_err14 = icmp eq i64 %optval13, 0 + br i1 %not_err14, label %after_check15, label %voiderr16 -after_check12: ; preds = %voiderr10 - %14 = load ptr, ptr %w, align 8 - %15 = getelementptr inbounds %Foo, ptr %14, i32 0, i32 0 - %16 = load i32, ptr %15, align 8 - %17 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %16) - br label %voiderr13 +after_check15: ; preds = %voiderr12 + %10 = load ptr, ptr %w, align 8 + %11 = getelementptr inbounds %Foo, ptr %10, i32 0, i32 0 + %12 = load i32, ptr %11, align 8 + %13 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %12) + br label %voiderr16 -voiderr13: ; preds = %after_check12, %voiderr10 +voiderr16: ; preds = %after_check15, %voiderr12 ret void } \ No newline at end of file diff --git a/test/test_suite2/errors/or_err_bool.c3t b/test/test_suite2/errors/or_err_bool.c3t index 907278754..0c5ebd276 100644 --- a/test/test_suite2/errors/or_err_bool.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %x.f, align 8 + %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 - %2 = trunc i8 %1 to i1 + %0 = load i8, ptr %x, align 1 + %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 } \ No newline at end of file diff --git a/test/test_suite2/errors/rethrow.c3t b/test/test_suite2/errors/rethrow.c3t index a92db5682..1f729d736 100644 --- a/test/test_suite2/errors/rethrow.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %i.f, align 8 + %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 - ret i64 %1 + %0 = load i64, ptr %error_var, align 8 + ret i64 %0 noerr_block: ; preds = %after_check ret i64 0 diff --git a/test/test_suite2/errors/rethrow_mingw.c3t b/test/test_suite2/errors/rethrow_mingw.c3t index cf7882821..0c12b0f39 100644 --- a/test/test_suite2/errors/rethrow_mingw.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %i.f, align 8 + %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 - ret i64 %1 + %0 = load i64, ptr %error_var, align 8 + ret i64 %0 noerr_block: ; preds = %after_check ret i64 0 diff --git a/test/test_suite2/errors/try_assign.c3t b/test/test_suite2/errors/try_assign.c3t index ad85abaf9..77fca57ad 100644 --- a/test/test_suite2/errors/try_assign.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %z.f, align 8 + %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 - store i32 %1, ptr %x, align 4 + %0 = load i32, ptr %z, 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 - %not_err1 = icmp eq i64 %2, 0 - br i1 %not_err1, label %after_check2, label %catch_landing3 + %optval1 = load i64, ptr %w.f, align 8 + %not_err2 = icmp eq i64 %optval1, 0 + br i1 %not_err2, label %after_check3, label %catch_landing4 -after_check2: ; preds = %chain_next - %3 = load i32, ptr %w, align 4 - store i32 %3, ptr %gh, align 4 - br label %phi_try_catch4 +after_check3: ; preds = %chain_next + %1 = load i32, ptr %w, align 4 + store i32 %1, ptr %gh, align 4 + br label %phi_try_catch5 -catch_landing3: ; preds = %chain_next - br label %phi_try_catch4 +catch_landing4: ; preds = %chain_next + br label %phi_try_catch5 -phi_try_catch4: ; preds = %catch_landing3, %after_check2 - %val5 = phi i1 [ true, %after_check2 ], [ false, %catch_landing3 ] - br i1 %val5, label %chain_next6, label %fail_chain +phi_try_catch5: ; preds = %catch_landing4, %after_check3 + %val6 = phi i1 [ true, %after_check3 ], [ false, %catch_landing4 ] + 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 - %chain.phi = phi i1 [ true, %chain_next6 ], [ false, %fail_chain ] +end_chain: ; preds = %fail_chain, %chain_next7 + %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 - %5 = load i32, ptr %gh, align 4 - %6 = call i32 (ptr, ...) @printf(ptr @.str, i32 %4, i32 %5) + %2 = load i32, ptr %x, align 4 + %3 = load i32, ptr %gh, align 4 + %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 - %not_err7 = icmp eq i64 %7, 0 - br i1 %not_err7, label %after_check8, label %catch_landing11 + %optval8 = load i64, ptr %z.f, align 8 + %not_err9 = icmp eq i64 %optval8, 0 + br i1 %not_err9, label %after_check10, label %catch_landing14 -after_check8: ; preds = %if.exit - %8 = load i32, ptr %z, align 4 - %9 = load i64, ptr %w.f, align 8 - %not_err9 = icmp eq i64 %9, 0 - br i1 %not_err9, label %after_check10, label %catch_landing11 +after_check10: ; preds = %if.exit + %5 = load i32, ptr %z, align 4 + %optval11 = load i64, ptr %w.f, align 8 + %not_err12 = icmp eq i64 %optval11, 0 + br i1 %not_err12, label %after_check13, label %catch_landing14 -after_check10: ; preds = %after_check8 - %10 = load i32, ptr %w, align 4 - %add = add i32 %8, %10 +after_check13: ; preds = %after_check10 + %6 = load i32, ptr %w, align 4 + %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 - br label %phi_try_catch12 +catch_landing14: ; preds = %after_check10, %if.exit + br label %phi_try_catch15 -phi_try_catch12: ; preds = %catch_landing11, %after_check10 - %val13 = phi i1 [ true, %after_check10 ], [ false, %catch_landing11 ] - br i1 %val13, label %if.then14, label %if.exit15 +phi_try_catch15: ; preds = %catch_landing14, %after_check13 + %val16 = phi i1 [ true, %after_check13 ], [ false, %catch_landing14 ] + br i1 %val16, label %if.then17, label %if.exit18 -if.then14: ; preds = %phi_try_catch12 - %11 = call i32 (ptr, ...) @printf(ptr @.str.1) - br label %if.exit15 +if.then17: ; preds = %phi_try_catch15 + %7 = call i32 (ptr, ...) @printf(ptr @.str.1) + 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 - %12 = load i64, ptr %z.f, align 8 - %not_err16 = icmp eq i64 %12, 0 - br i1 %not_err16, label %after_check17, label %assign_optional +testblock: ; preds = %if.exit18 + %optval19 = load i64, ptr %z.f, align 8 + %not_err20 = icmp eq i64 %optval19, 0 + 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 - %13 = load i64, ptr %e, align 8 - %neq = icmp ne i64 %13, 0 - br i1 %neq, label %if.then18, label %if.exit19 +end_block: ; preds = %after_check21, %assign_optional + %8 = load i64, ptr %e, align 8 + %neq = icmp ne i64 %8, 0 + br i1 %neq, label %if.then22, label %if.exit23 -if.then18: ; preds = %end_block - %14 = call i32 (ptr, ...) @printf(ptr @.str.2) - br label %if.exit19 +if.then22: ; preds = %end_block + %9 = call i32 (ptr, ...) @printf(ptr @.str.2) + br label %if.exit23 -if.exit19: ; preds = %if.then18, %end_block +if.exit23: ; preds = %if.then22, %end_block ret void } diff --git a/test/test_suite2/errors/try_catch_if.c3t b/test/test_suite2/errors/try_catch_if.c3t index f7cc257f3..086e11959 100644 --- a/test/test_suite2/errors/try_catch_if.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %a.f, align 8 + %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) - %not_err2 = icmp eq i64 %1, 0 + %0 = call i64 @try_catch_if_tester(ptr %retparam) + %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 - %neq = icmp ne i64 %2, 0 + %1 = load i64, ptr %err, align 8 + %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 - %5 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %4) + %3 = load i32, ptr %a, align 4 + %4 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %3) br label %if.exit if.exit: ; preds = %if.else, %if.then diff --git a/test/test_suite2/errors/try_with_unwrapper.c3t b/test/test_suite2/errors/try_with_unwrapper.c3t index 8ac494b8a..1ee16122e 100644 --- a/test/test_suite2/errors/try_with_unwrapper.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %a.f, align 8 + %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 - store i32 %1, ptr %b, align 4 + %0 = load i32, ptr %a, 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) - %not_err1 = icmp eq i64 %2, 0 + %1 = call i64 @try_with_unwrapper_tester(ptr %retparam) + %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 - store i32 %3, ptr %c, align 4 + %2 = load i32, ptr %retparam, 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 - %5 = call i32 @try_with_unwrapper_hello(i32 %4) - %6 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %5) - %7 = load i32, ptr %c, align 4 - %8 = call i32 (ptr, ...) @printf(ptr @.str.2, i32 %7) + %3 = load i32, ptr %b, align 4 + %4 = call i32 @try_with_unwrapper_hello(i32 %3) + %5 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %4) + %6 = load i32, ptr %c, align 4 + %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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %a.f, align 8 + %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 - store i32 %1, ptr %b, align 4 + %0 = load i32, ptr %a, 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 - %3 = call i32 @try_with_unwrapper_hello(i32 %2) - %intbool = icmp ne i32 %3, 0 + %1 = load i32, ptr %b, align 4 + %2 = call i32 @try_with_unwrapper_hello(i32 %1) + %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 - %add = add i32 %4, 1 - %5 = call i32 @try_with_unwrapper_hello(i32 %add) + %3 = load i32, ptr %b, align 4 + %add = add i32 %3, 1 + %4 = call i32 @try_with_unwrapper_hello(i32 %add) br label %if.exit if.exit: ; preds = %if.then, %end_chain diff --git a/test/test_suite2/expressions/chained_ternary.c3t b/test/test_suite2/expressions/chained_ternary.c3t index ee7e9b9f2..2e0bf0daf 100644 --- a/test/test_suite2/expressions/chained_ternary.c3t +++ b/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 - %not_err = icmp eq i64 %6, 0 + %optval = load i64, ptr %x.f, align 8 + %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 - %not11 = icmp eq ptr %9, null + %8 = load ptr, ptr %a, align 8 + %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 - br label %cond.phi17 + %9 = load ptr, ptr %b, align 8 + br label %cond.phi18 cond.rhs13: ; preds = %after_assign - %11 = load i64, ptr %x.f, align 8 - %not_err14 = icmp eq i64 %11, 0 - br i1 %not_err14, label %after_check16, label %assign_optional15 + %optval14 = load i64, ptr %x.f, align 8 + %not_err15 = icmp eq i64 %optval14, 0 + br i1 %not_err15, label %after_check17, label %assign_optional16 -assign_optional15: ; preds = %cond.rhs13 - store i64 %11, ptr %y.f, align 8 - br label %after_assign19 +assign_optional16: ; preds = %cond.rhs13 + store i64 %optval14, ptr %y.f, align 8 + br label %after_assign20 -after_check16: ; preds = %cond.rhs13 - %12 = load ptr, ptr %x, align 8 - br label %cond.phi17 +after_check17: ; preds = %cond.rhs13 + %10 = load ptr, ptr %x, align 8 + br label %cond.phi18 -cond.phi17: ; preds = %after_check16, %cond.lhs12 - %val18 = phi ptr [ %10, %cond.lhs12 ], [ %12, %after_check16 ] - store ptr %val18, ptr %y, align 8 +cond.phi18: ; preds = %after_check17, %cond.lhs12 + %val19 = phi ptr [ %9, %cond.lhs12 ], [ %10, %after_check17 ] + 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 - %13 = load ptr, ptr %a, align 8 - %not20 = icmp eq ptr %13, null - br i1 %not20, label %cond.lhs21, label %cond.rhs25 +voiderr: ; preds = %after_assign20 + %11 = load ptr, ptr %a, align 8 + %not21 = icmp eq ptr %11, null + br i1 %not21, label %cond.lhs22, label %cond.rhs27 -cond.lhs21: ; preds = %voiderr - %14 = load i64, ptr %x.f, align 8 - %not_err22 = icmp eq i64 %14, 0 - br i1 %not_err22, label %after_check24, label %assign_optional23 +cond.lhs22: ; preds = %voiderr + %optval23 = load i64, ptr %x.f, align 8 + %not_err24 = icmp eq i64 %optval23, 0 + br i1 %not_err24, label %after_check26, label %assign_optional25 -assign_optional23: ; preds = %cond.lhs21 - store i64 %14, ptr %y.f, align 8 - br label %after_assign31 +assign_optional25: ; preds = %cond.lhs22 + store i64 %optval23, ptr %y.f, align 8 + 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 - %16 = load i64, ptr %x.f, align 8 - %not_err26 = icmp eq i64 %16, 0 - br i1 %not_err26, label %after_check28, label %assign_optional27 +cond.rhs42: ; preds = %voiderr35 + store i64 ptrtoint (ptr @"test_Test$FOO" to i64), ptr %y.f, align 8 + br label %after_assign44 -assign_optional27: ; preds = %cond.rhs25 - store i64 %16, ptr %y.f, align 8 - br label %after_assign31 +cond.phi43: ; preds = %after_check41 + store ptr %15, ptr %y, align 8 + 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 - %val30 = phi ptr [ %15, %after_check24 ], [ %17, %after_check28 ] - store ptr %val30, ptr %y, align 8 +cond.phi53: ; preds = %after_check52 + store ptr %17, 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 - br label %voiderr32 +after_assign54: ; preds = %cond.phi53, %assign_optional51, %cond.lhs47 + br label %voiderr55 -voiderr32: ; preds = %after_assign31 +voiderr55: ; preds = %after_assign54 %18 = load ptr, ptr %a, align 8 - %not33 = icmp eq ptr %18, null - br i1 %not33, label %cond.lhs34, label %cond.rhs38 + %not56 = icmp eq ptr %18, null + br i1 %not56, label %cond.lhs57, label %cond.rhs58 -cond.lhs34: ; preds = %voiderr32 - %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 +cond.lhs57: ; preds = %voiderr55 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 - 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 +cond.rhs58: ; preds = %voiderr55 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 - br label %voiderr56 +after_assign60: ; preds = %cond.rhs58, %cond.lhs57 + br label %voiderr61 -voiderr56: ; preds = %after_assign55 +voiderr61: ; preds = %after_assign60 ret void +} \ No newline at end of file diff --git a/test/test_suite2/failable_catch.c3t b/test/test_suite2/failable_catch.c3t index ce1b96c90..a67979bb7 100644 --- a/test/test_suite2/failable_catch.c3t +++ b/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 - %not_err = icmp eq i64 %3, 0 + %optval = load i64, ptr %a.f, align 8 + %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 - %add = add i32 %4, 3 + %3 = load i32, ptr %a, align 4 + %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 - %intbool3 = icmp ne i32 %5, 0 + %4 = load i32, ptr %x1, align 4 + %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 - store i32 %6, ptr %blockret2, align 4 + %5 = load i32, ptr %x1, 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 - store i32 %7, ptr %b, align 4 + %6 = load i32, ptr %blockret2, 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 - %intbool10 = icmp ne i32 %8, 0 + %7 = load i32, ptr %x8, align 4 + %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 - store i32 %9, ptr %blockret9, align 4 + %8 = load i32, ptr %x8, 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 - store i32 %10, ptr %c, align 4 + %9 = load i32, ptr %blockret9, 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 - %not_err15 = icmp eq i64 %11, 0 - br i1 %not_err15, label %after_check16, label %voiderr + %optval15 = load i64, ptr %a.f, align 8 + %not_err16 = icmp eq i64 %optval15, 0 + br i1 %not_err16, label %after_check17, label %voiderr -after_check16: ; preds = %after_assign14 - %12 = load i32, ptr %a, align 4 - call void (ptr, ...) @printf(ptr @.str, i32 %12) +after_check17: ; preds = %after_assign14 + %10 = load i32, ptr %a, align 4 + call void (ptr, ...) @printf(ptr @.str, i32 %10) br label %voiderr -voiderr: ; preds = %after_check16, %after_assign14 - %13 = load i64, ptr %b.f, align 8 - %not_err17 = icmp eq i64 %13, 0 - br i1 %not_err17, label %after_check18, label %voiderr19 +voiderr: ; preds = %after_check17, %after_assign14 + %optval18 = load i64, ptr %b.f, align 8 + %not_err19 = icmp eq i64 %optval18, 0 + br i1 %not_err19, label %after_check20, label %voiderr21 -after_check18: ; preds = %voiderr - %14 = load i32, ptr %b, align 4 - call void (ptr, ...) @printf(ptr @.str.1, i32 %14) - br label %voiderr19 +after_check20: ; preds = %voiderr + %11 = load i32, ptr %b, align 4 + call void (ptr, ...) @printf(ptr @.str.1, i32 %11) + br label %voiderr21 -voiderr19: ; preds = %after_check18, %voiderr - %15 = load i64, ptr %c.f, align 8 - %not_err20 = icmp eq i64 %15, 0 - br i1 %not_err20, label %after_check21, label %voiderr22 +voiderr21: ; preds = %after_check20, %voiderr + %optval22 = load i64, ptr %c.f, align 8 + %not_err23 = icmp eq i64 %optval22, 0 + br i1 %not_err23, label %after_check24, label %voiderr25 -after_check21: ; preds = %voiderr19 - %16 = load i32, ptr %c, align 4 - call void (ptr, ...) @printf(ptr @.str.2, i32 %16) - br label %voiderr22 +after_check24: ; preds = %voiderr21 + %12 = load i32, ptr %c, align 4 + call void (ptr, ...) @printf(ptr @.str.2, i32 %12) + br label %voiderr25 -voiderr22: ; preds = %after_check21, %voiderr19 - %17 = load i64, ptr %c.f, align 8 - %neq = icmp ne i64 %17, 0 - br i1 %neq, label %if.then23, label %if.exit24 +voiderr25: ; preds = %after_check24, %voiderr21 + %13 = load i64, ptr %c.f, align 8 + %neq = icmp ne i64 %13, 0 + 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 - %not_err25 = icmp eq i64 %18, 0 - br i1 %not_err25, label %after_check26, label %voiderr27 + %optval28 = load i64, ptr %c.f, align 8 + %not_err29 = icmp eq i64 %optval28, 0 + br i1 %not_err29, label %after_check30, label %voiderr31 -after_check26: ; preds = %if.exit24 - %19 = load i32, ptr %c, align 4 - call void (ptr, ...) @printf(ptr @.str.4, i32 %19) - br label %voiderr27 +after_check30: ; preds = %if.exit27 + %14 = load i32, ptr %c, align 4 + call void (ptr, ...) @printf(ptr @.str.4, i32 %14) + br label %voiderr31 -voiderr27: ; preds = %after_check26, %if.exit24 +voiderr31: ; preds = %after_check30, %if.exit27 ret i32 0 } diff --git a/test/test_suite2/from_docs/examples_if_catch.c3t b/test/test_suite2/from_docs/examples_if_catch.c3t index c2e39c17c..636c04a6b 100644 --- a/test/test_suite2/from_docs/examples_if_catch.c3t +++ b/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 - %not_err1 = icmp eq i64 %4, 0 + %optval = load i64, ptr %ratio.f, align 8 + %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 - %neq = icmp ne i64 %5, 0 + %4 = load i64, ptr %err, align 8 + %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 - %eq = icmp eq i64 ptrtoint (ptr @"demo_MathError$DIVISION_BY_ZERO" to i64), %6 + %5 = load i64, ptr %switch, align 8 + %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 - %10 = call i32 (ptr, ...) @printf(ptr @.str.2, double %9) + %8 = load double, ptr %ratio, align 8 + %9 = call i32 (ptr, ...) @printf(ptr @.str.2, double %8) ret void } \ No newline at end of file diff --git a/test/test_suite2/functions/assorted_tests.c3t b/test/test_suite2/functions/assorted_tests.c3t index a5f4b0a7b..0691478a4 100644 --- a/test/test_suite2/functions/assorted_tests.c3t +++ b/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 - %add = add i32 %0, %uiuiext + %zext = zext i8 %2 to i32 + %add = add i32 %0, %zext store i32 %add, ptr %w_cnt, align 4 %3 = load i32, ptr %w_cnt, align 4 ret i32 %3 diff --git a/test/test_suite2/functions/simple_test.c3t b/test/test_suite2/functions/simple_test.c3t index af119919c..cd197087a 100644 --- a/test/test_suite2/functions/simple_test.c3t +++ b/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 - %add = add i32 %0, %uiuiext + %zext = zext i8 %2 to i32 + %add = add i32 %0, %zext store i32 %add, ptr %w_cnt, align 4 %3 = load i32, ptr %w_cnt, align 4 ret i32 %3 diff --git a/test/test_suite2/macros/macro_with_body.c3t b/test/test_suite2/macros/macro_with_body.c3t index 46e5034e2..ba165e9da 100644 --- a/test/test_suite2/macros/macro_with_body.c3t +++ b/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 - store %Foo %0, ptr %foo, align 4 - %1 = getelementptr inbounds %Foo, ptr %foo, i32 0, i32 0 - %2 = load i32, ptr %1, align 4 - store i32 %2, ptr %y, align 4 - %3 = call i32 @withbody_Foo_mutate(ptr %foo) - store i32 %3, ptr %x, align 4 - %4 = load i32, ptr %y, align 4 - store i32 %4, ptr %dy, align 4 - %5 = load i32, ptr %x, align 4 - %6 = load i32, ptr %dy, align 4 - %7 = call i32 (ptr, ...) @printf(ptr @.str, i32 %5, i32 %6) + call void @llvm.memcpy.p0.p0.i32(ptr align 4 %foo, ptr align 4 %f, i32 4, i1 false) + %0 = getelementptr inbounds %Foo, ptr %foo, i32 0, i32 0 + %1 = load i32, ptr %0, align 4 + store i32 %1, ptr %y, align 4 + %2 = call i32 @withbody_Foo_mutate(ptr %foo) + store i32 %2, ptr %x, align 4 + %3 = load i32, ptr %y, align 4 + store i32 %3, ptr %dy, align 4 + %4 = load i32, ptr %x, align 4 + %5 = load i32, ptr %dy, align 4 + %6 = call i32 (ptr, ...) @printf(ptr @.str, i32 %4, i32 %5) 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 - %9 = load i32, ptr %times, align 4 - %lt = icmp slt i32 %8, %9 + %7 = load i32, ptr %i, align 4 + %8 = load i32, ptr %times, align 4 + %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 - %add = add i32 %10, 1 + %9 = load i32, ptr %i, align 4 + %add = add i32 %9, 1 store i32 %add, ptr %loop, align 4 - %11 = load i32, ptr %loop, align 4 - %12 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %11) - %13 = load i32, ptr %i, align 4 - %add1 = add i32 %13, 1 + %10 = load i32, ptr %loop, align 4 + %11 = call i32 (ptr, ...) @printf(ptr @.str.1, i32 %10) + %12 = load i32, ptr %i, align 4 + %add1 = add i32 %12, 1 store i32 %add1, ptr %i, align 4 br label %loop.cond diff --git a/test/test_suite2/macros/userland_bitcast.c3t b/test/test_suite2/macros/userland_bitcast.c3t index 4ad32380a..7c4ce2190 100644 --- a/test/test_suite2/macros/userland_bitcast.c3t +++ b/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 - store %Foo %7, ptr %expr, align 2 + call void @llvm.memcpy.p0.p0.i32(ptr align 2 %expr, ptr align 2 %z, i32 8, i1 false) 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 - %lt = icmp ult i64 %8, 8 + %7 = load i64, ptr %i, align 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 - %10 = load i64, ptr %i, align 8 - %ptroffset = getelementptr inbounds i16, ptr %9, i64 %10 - %11 = load ptr, ptr %b, align 8 - %12 = load i64, ptr %i, align 8 - %ptroffset1 = getelementptr inbounds i16, ptr %11, i64 %12 - %13 = load i16, ptr %ptroffset1, align 2 - store i16 %13, ptr %ptroffset, align 2 - %14 = load i64, ptr %i, align 8 - %add = add i64 %14, 2 + %8 = load ptr, ptr %to, align 8 + %9 = load i64, ptr %i, align 8 + %ptroffset = getelementptr inbounds i16, ptr %8, i64 %9 + %10 = load ptr, ptr %b, align 8 + %11 = load i64, ptr %i, align 8 + %ptroffset1 = getelementptr inbounds i16, ptr %10, i64 %11 + %12 = load i16, ptr %ptroffset1, align 2 + store i16 %12, ptr %ptroffset, align 2 + %13 = load i64, ptr %i, align 8 + %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 - ret i64 %15 + %14 = load i64, ptr %x, align 8 + ret i64 %14 } define i32 @userland_bitcast_test(float %0) #0 { diff --git a/test/test_suite2/statements/comparison_widening.c3t b/test/test_suite2/statements/comparison_widening.c3t index 7f4895058..9134aa87e 100644 --- a/test/test_suite2/statements/comparison_widening.c3t +++ b/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 - %gt = icmp sgt i32 %0, %uiuiext - %check = icmp sge i32 %uiuiext, 0 + %zext = zext i8 %1 to i32 + %gt = icmp sgt i32 %0, %zext + %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 diff --git a/test/test_suite2/statements/foreach_common.c3t b/test/test_suite2/statements/foreach_common.c3t index 74047c75b..8674f1846 100644 --- a/test/test_suite2/statements/foreach_common.c3t +++ b/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 - store i8 %uiuitrunc, ptr %i29, align 1 + %ztrunc = trunc i64 %29 to i8 + 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 - store i8 %uiuitrunc66, ptr %i65, align 1 + %ztrunc66 = trunc i64 %60 to i8 + 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 diff --git a/test/test_suite2/statements/various_switching.c3t b/test/test_suite2/statements/various_switching.c3t index 5c0189a26..8962c0bb4 100644 --- a/test/test_suite2/statements/various_switching.c3t +++ b/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 - %not_err = icmp eq i64 %0, 0 + %optval = load i64, ptr %x.f, align 8 + %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 - %neq = icmp ne i64 %1, 0 + %0 = load i64, ptr %err, align 8 + %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 - %eq = icmp eq i64 ptrtoint (ptr @"mymodule_HelloErr$FOO" to i64), %2 + %1 = load i64, ptr %switch, align 8 + %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 - store i64 %3, ptr %switch4, align 8 + %2 = load i64, ptr %z, 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 - %eq6 = icmp eq i64 ptrtoint (ptr @"ct$int" to i64), %4 + %3 = load i64, ptr %switch4, align 8 + %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 - %6 = load i32, ptr %a, align 4 - %add = add i32 %5, %6 + %4 = load i32, ptr %b, align 4 + %5 = load i32, ptr %a, align 4 + %add = add i32 %4, %5 store i32 %add, ptr %zy, align 4 - %7 = load i32, ptr %zy, align 4 - store i32 %7, ptr %switch17, align 4 + %6 = load i32, ptr %zy, 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 - %9 = load i32, ptr %a, align 4 - %eq19 = icmp eq i32 %9, %8 + %7 = load i32, ptr %switch17, align 4 + %8 = load i32, ptr %a, align 4 + %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 - %eq22 = icmp eq i32 %10, %8 + %9 = load i32, ptr %b, align 4 + %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 - %12 = trunc i8 %11 to i1 - %13 = load i32, ptr %a, align 4 - %lt = icmp slt i32 %13, 0 - %eq29 = icmp eq i1 %lt, %12 + %10 = load i8, ptr %switch27, align 1 + %11 = trunc i8 %10 to i1 + %12 = load i32, ptr %a, align 4 + %lt = icmp slt i32 %12, 0 + %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 - %eq32 = icmp eq i32 %14, 1 - %eq33 = icmp eq i1 %eq32, %12 + %13 = load i32, ptr %a, align 4 + %eq32 = icmp eq i32 %13, 1 + %eq33 = icmp eq i1 %eq32, %11 br i1 %eq33, label %switch.case34, label %next_if35 switch.case34: ; preds = %next_if31