diff --git a/releasenotes.md b/releasenotes.md index a10860fe4..90b39df25 100644 --- a/releasenotes.md +++ b/releasenotes.md @@ -29,6 +29,7 @@ - `--max-mem` now works correctly again. - Casting a fault to a pointer would trigger an assert. - Make `to_float` more tolerant to spaces. +- Fixes to thread local pointer handling. ### Stdlib changes diff --git a/src/compiler/llvm_codegen.c b/src/compiler/llvm_codegen.c index ebc930535..0b30707d3 100644 --- a/src/compiler/llvm_codegen.c +++ b/src/compiler/llvm_codegen.c @@ -440,10 +440,10 @@ void llvm_emit_ptr_from_array(GenContext *c, BEValue *value) BEValue member; llvm_emit_slice_pointer(c, value, &member); llvm_value_rvalue(c, &member); - llvm_value_set_address(value, - member.value, - type_get_ptr(value->type->array.base), - type_abi_alignment(value->type->array.base)); + llvm_value_set_address(c, + value, + member.value, + type_get_ptr(value->type->array.base), type_abi_alignment(value->type->array.base)); return; } default: @@ -856,6 +856,7 @@ static void llvm_codegen_setup() intrinsic_id.ssub_overflow = lookup_intrinsic("llvm.ssub.with.overflow"); intrinsic_id.ssub_sat = lookup_intrinsic("llvm.ssub.sat"); intrinsic_id.smul_fixed_sat = lookup_intrinsic("llvm.smul.fix.sat"); + intrinsic_id.threadlocal_address = lookup_intrinsic("llvm.threadlocal.address"); intrinsic_id.trap = lookup_intrinsic("llvm.trap"); intrinsic_id.trunc = lookup_intrinsic("llvm.trunc"); intrinsic_id.uadd_overflow = lookup_intrinsic("llvm.uadd.with.overflow"); diff --git a/src/compiler/llvm_codegen_builtins.c b/src/compiler/llvm_codegen_builtins.c index 99dfeac61..9e4273904 100644 --- a/src/compiler/llvm_codegen_builtins.c +++ b/src/compiler/llvm_codegen_builtins.c @@ -658,7 +658,7 @@ static void llvm_emit_overflow_builtin(GenContext *c, BEValue *be_value, Expr *e llvm_emit_expr(c, &ref, ret_addr); llvm_value_rvalue(c, &ref); // Note that we can make additional improvements here! - llvm_value_set_address(&ref, ref.value, ref.type->pointer, type_abi_alignment(ref.type->pointer)); + llvm_value_set_address(c, &ref, ref.value, ref.type->pointer, type_abi_alignment(ref.type->pointer)); LLVMTypeRef call_type[1] = { LLVMTypeOf(arg_slots[0]) }; unsigned intrinsic = type_is_signed(type_lowering(args[0]->type)) ? intrinsic_signed : intrinsic_unsigned; LLVMValueRef result = llvm_emit_call_intrinsic(c, intrinsic, call_type, 1, arg_slots, 2); diff --git a/src/compiler/llvm_codegen_expr.c b/src/compiler/llvm_codegen_expr.c index d32ba7dc3..e21b0abd2 100644 --- a/src/compiler/llvm_codegen_expr.c +++ b/src/compiler/llvm_codegen_expr.c @@ -186,7 +186,7 @@ BEValue llvm_emit_assign_expr(GenContext *c, BEValue *ref, Expr *expr, LLVMValue BEValue val; AlignSize alignment = type_alloca_alignment(ref->type); LLVMValueRef temp = llvm_emit_alloca(c, llvm_get_type(c, ref->type), alignment, ".assign_list"); - llvm_value_set_address(&val, temp, ref->type, alignment); + llvm_value_set_address(c, &val, temp, ref->type, alignment); llvm_emit_initialize_reference(c, &val, expr); llvm_store(c, ref, &val); } @@ -588,7 +588,7 @@ void llvm_emit_convert_value_from_coerced(GenContext *c, BEValue *result, LLVMTy LLVMTypeRef target_type = llvm_get_type(c, original_type); LLVMValueRef addr = llvm_emit_alloca(c, target_type, type_abi_alignment(original_type), "result"); llvm_emit_coerce_store(c, addr, type_abi_alignment(original_type), coerced, value, target_type); - llvm_value_set_address_abi_aligned(result, addr, original_type); + llvm_value_set_address_abi_aligned(c, result, addr, original_type); } static inline LLVMValueRef llvm_emit_sub_int(GenContext *c, Type *type, LLVMValueRef left, LLVMValueRef right, SourceSpan loc) @@ -645,11 +645,11 @@ static inline void llvm_emit_subscript_addr_with_base(GenContext *c, BEValue *re switch (type->type_kind) { case TYPE_POINTER: - llvm_value_set_address_abi_aligned(result, llvm_emit_pointer_inbounds_gep_raw( - c, - llvm_get_pointee_type(c, parent->type), - parent->value, - index->value), type->pointer); + llvm_value_set_address_abi_aligned(c, result, llvm_emit_pointer_inbounds_gep_raw( + c, + llvm_get_pointee_type(c, parent->type), + parent->value, + index->value), type->pointer); return; case TYPE_ARRAY: case TYPE_FLEXIBLE_ARRAY: @@ -657,13 +657,13 @@ static inline void llvm_emit_subscript_addr_with_base(GenContext *c, BEValue *re { AlignSize alignment; LLVMValueRef ptr = llvm_emit_array_gep_raw_index(c, parent->value, llvm_get_type(c, type), index, parent->alignment, &alignment); - llvm_value_set_address(result, ptr, type->array.base, alignment); + llvm_value_set_address(c, result, ptr, type->array.base, alignment); return; } case TYPE_SLICE: { LLVMValueRef ptr = llvm_emit_pointer_inbounds_gep_raw(c, llvm_get_type(c, type->array.base), parent->value, index->value); - llvm_value_set_address(result, ptr, type->array.base, type_abi_alignment(type->array.base)); + llvm_value_set_address(c, result, ptr, type->array.base, type_abi_alignment(type->array.base)); } return; default: @@ -1223,14 +1223,14 @@ static inline void llvm_emit_access_addr(GenContext *c, BEValue *be_value, Expr AlignSize align = LLVMGetAlignment(member->backend_ref); AlignSize alignment; LLVMValueRef ptr = llvm_emit_array_gep_raw_index(c, member->backend_ref, value_type, be_value, align, &alignment); - llvm_value_set_address(be_value, ptr, member->type, alignment); + llvm_value_set_address(c, be_value, ptr, member->type, alignment); return; } if (expr_is_deref(parent)) { llvm_emit_expr(c, be_value, parent->unary_expr.expr); llvm_value_rvalue(c, be_value); - llvm_value_set_address_abi_aligned(be_value, be_value->value, parent->type); + llvm_value_set_address_abi_aligned(c, be_value, be_value->value, parent->type); } else { @@ -1452,7 +1452,7 @@ static void llvm_emit_const_init_ref(GenContext *c, BEValue *ref, ConstInitializ AlignSize alignment; LLVMValueRef array_pointer = llvm_emit_array_gep_raw(c, array_ref, array_type_llvm, (unsigned)i, ref->alignment, &alignment); BEValue value; - llvm_value_set_address(&value, array_pointer, element_type, alignment); + llvm_value_set_address(c, &value, array_pointer, element_type, alignment); llvm_emit_const_init_ref(c, &value, const_init->init_array_full[i], false); } return; @@ -1472,7 +1472,7 @@ static void llvm_emit_const_init_ref(GenContext *c, BEValue *ref, ConstInitializ AlignSize alignment; LLVMValueRef array_pointer = llvm_emit_array_gep_raw(c, array_ref, array_type_llvm, (unsigned)element_index, ref->alignment, &alignment); BEValue value; - llvm_value_set_address(&value, array_pointer, element_type, alignment); + llvm_value_set_address(c, &value, array_pointer, element_type, alignment); llvm_emit_const_init_ref(c, &value, element->init_array_value.element, false); } return; @@ -1615,11 +1615,11 @@ static inline void llvm_emit_initialize_reference_list(GenContext *c, BEValue *r REMINDER("Optimize array reference list init"); AlignSize alignment; LLVMValueRef ptr = llvm_emit_array_gep_raw(c, value, llvm_type, i, ref->alignment, &alignment); - llvm_value_set_address(&pointer, ptr, element->type, alignment); + llvm_value_set_address(c, &pointer, ptr, element->type, alignment); } else { - llvm_value_set_address(&pointer, value, element->type, ref->alignment); + llvm_value_set_address(c, &pointer, value, element->type, ref->alignment); } // If this is an initializer, we want to actually run the initialization recursively. if (expr_is_const_initializer(element)) @@ -1657,7 +1657,7 @@ static void llvm_emit_initialize_designated_const_range(GenContext *c, BEValue * BEValue new_ref; AlignSize alignment; LLVMValueRef ptr = llvm_emit_array_gep_raw(c, ref->value, ref_type, (unsigned)i, ref->alignment, &alignment); - llvm_value_set_address(&new_ref, ptr, type_get_indexed_type(ref->type), alignment); + llvm_value_set_address(c, &new_ref, ptr, type_get_indexed_type(ref->type), alignment); llvm_emit_initialize_designated_element(c, &new_ref, offset, current + 1, last, expr, emitted_value); } } @@ -1699,10 +1699,10 @@ static void llvm_emit_initialize_designated_element(GenContext *c, BEValue *ref, unsigned decl_alignment = decl->alignment; if (ref->type->type_kind == TYPE_UNION) { - llvm_value_set_address(&value, - ref->value, - type, - type_min_alignment(offset, decl_alignment)); + llvm_value_set_address(c, + &value, + ref->value, + type, type_min_alignment(offset, decl_alignment)); } else { @@ -1739,7 +1739,7 @@ static void llvm_emit_initialize_designated_element(GenContext *c, BEValue *ref, offset += (unsigned)curr->index * type_size(type); AlignSize alignment; LLVMValueRef ptr = llvm_emit_array_gep_raw(c, ref->value, llvm_get_type(c, ref->type), (unsigned)curr->index, ref->alignment, &alignment); - llvm_value_set_address(&value, ptr, type, alignment); + llvm_value_set_address(c, &value, ptr, type, alignment); llvm_emit_initialize_designated_element(c, &value, offset, current + 1, last, expr, emitted_value); break; } @@ -2427,7 +2427,7 @@ static void llvm_emit_unary_expr(GenContext *c, BEValue *value, Expr *expr) val = LLVMBuildNot(c->builder, val, "bnot"); LLVMValueRef store = llvm_emit_alloca(c, big_int, value->alignment, ""); llvm_store_to_ptr_raw_aligned(c, store, val, value->alignment); - llvm_value_set_address(value, store, value->type, value->alignment); + llvm_value_set_address(c, value, store, value->type, value->alignment); return; } llvm_value_rvalue(c, value); @@ -2752,7 +2752,7 @@ static void llvm_emit_slice_values(GenContext *c, Expr *slice, BEValue *parent_r llvm_value_set(end_ref, end_index.value, end_type); llvm_value_set(start_ref, start_index.value, end_type); - llvm_value_set_address(parent_ref, parent_base, parent_type, type_abi_alignment(parent_type)); + llvm_value_set_address(c, parent_ref, parent_base, parent_type, type_abi_alignment(parent_type)); } static void gencontext_emit_slice(GenContext *c, BEValue *be_value, Expr *expr) @@ -2858,7 +2858,7 @@ static void llvm_emit_slice_assign(GenContext *c, BEValue *be_value, Expr *expr) LLVMValueRef address = llvm_emit_alloca(c, llvm_get_type(c, be_value->type), be_value->alignment, "tempval"); llvm_store_to_ptr(c, address, be_value); // Replace the old value with this temp - llvm_value_set_address(be_value, address, be_value->type, be_value->alignment); + llvm_value_set_address(c, be_value, address, be_value->type, be_value->alignment); } else { @@ -3358,7 +3358,7 @@ static void llvm_emit_slice_comp(GenContext *c, BEValue *be_value, BEValue *lhs, llvm_emit_block(c, value_cmp); BEValue index_var; - llvm_value_set_address_abi_aligned(&index_var, llvm_emit_alloca_aligned(c, type_isz, "cmp.idx"), type_isz); + llvm_value_set_address_abi_aligned(c, &index_var, llvm_emit_alloca_aligned(c, type_isz, "cmp.idx"), type_isz); LLVMValueRef one = llvm_const_int(c, type_isz, 1); llvm_store_raw(c, &index_var, llvm_get_zero(c, type_isz)); llvm_emit_br(c, loop_begin); @@ -3374,18 +3374,18 @@ static void llvm_emit_slice_comp(GenContext *c, BEValue *be_value, BEValue *lhs, llvm_emit_block(c, comparison); BEValue lhs_to_compare; BEValue rhs_to_compare; - llvm_value_set_address_abi_aligned(&lhs_to_compare, - llvm_emit_pointer_inbounds_gep_raw(c, - llvm_base_type, - lhs_value.value, - current_index.value), - array_base_type); - llvm_value_set_address_abi_aligned(&rhs_to_compare, - llvm_emit_pointer_inbounds_gep_raw(c, - llvm_base_type, - rhs_value.value, - current_index.value), - array_base_type); + llvm_value_set_address_abi_aligned(c, + &lhs_to_compare, + llvm_emit_pointer_inbounds_gep_raw(c, + llvm_base_type, + lhs_value.value, + current_index.value), array_base_type); + llvm_value_set_address_abi_aligned(c, + &rhs_to_compare, + llvm_emit_pointer_inbounds_gep_raw(c, + llvm_base_type, + rhs_value.value, + current_index.value), array_base_type); llvm_emit_comp(c, &cmp, &lhs_to_compare, &rhs_to_compare, BINARYOP_EQ); LLVMBasicBlockRef match_fail_block = c->current_block; llvm_store_raw(c, &index_var, LLVMBuildAdd(c->builder, current_index.value, one, "")); @@ -3558,11 +3558,11 @@ MEMCMP: AlignSize align_lhs; BEValue lhs_v; LLVMValueRef lhs_ptr = llvm_emit_array_gep_raw(c, lhs->value, array_type, i, lhs->alignment, &align_lhs); - llvm_value_set_address(&lhs_v, lhs_ptr, array_base_type, align_lhs); + llvm_value_set_address(c, &lhs_v, lhs_ptr, array_base_type, align_lhs); AlignSize align_rhs; BEValue rhs_v; LLVMValueRef rhs_ptr = llvm_emit_array_gep_raw(c, rhs->value, array_type, i, rhs->alignment, &align_rhs); - llvm_value_set_address(&rhs_v, rhs_ptr, array_base_type, align_rhs); + llvm_value_set_address(c, &rhs_v, rhs_ptr, array_base_type, align_rhs); BEValue comp; llvm_emit_comp(c, &comp, &lhs_v, &rhs_v, BINARYOP_EQ); blocks[i] = c->current_block; @@ -3588,7 +3588,7 @@ MEMCMP: LLVMValueRef len_val = llvm_const_int(c, type_isz, len); LLVMValueRef one = llvm_const_int(c, type_isz, 1); BEValue index_var; - llvm_value_set_address_abi_aligned(&index_var, llvm_emit_alloca_aligned(c, type_isz, "cmp.idx"), type_isz); + llvm_value_set_address_abi_aligned(c, &index_var, llvm_emit_alloca_aligned(c, type_isz, "cmp.idx"), type_isz); llvm_store_raw(c, &index_var, llvm_get_zero(c, type_isz)); llvm_emit_br(c, loop_begin); @@ -3599,11 +3599,11 @@ MEMCMP: BEValue index_copy = index_var; llvm_value_rvalue(c, &index_copy); LLVMValueRef lhs_ptr = llvm_emit_array_gep_raw_index(c, lhs->value, array_type, &index_copy, lhs->alignment, &align_lhs); - llvm_value_set_address(&lhs_v, lhs_ptr, array_base_type, align_lhs); + llvm_value_set_address(c, &lhs_v, lhs_ptr, array_base_type, align_lhs); AlignSize align_rhs; BEValue rhs_v; LLVMValueRef rhs_ptr = llvm_emit_array_gep_raw_index(c, rhs->value, array_type, &index_copy, rhs->alignment, &align_rhs); - llvm_value_set_address(&rhs_v, rhs_ptr, array_base_type, align_rhs); + llvm_value_set_address(c, &rhs_v, rhs_ptr, array_base_type, align_rhs); BEValue comp; llvm_emit_comp(c, &comp, &lhs_v, &rhs_v, BINARYOP_EQ); LLVMBasicBlockRef loop_begin_phi = c->current_block; @@ -3957,7 +3957,7 @@ void llvm_emit_bitstruct_binary_op(GenContext *c, BEValue *be_value, BEValue *lh } LLVMValueRef store = llvm_emit_alloca(c, big_int, lhs->alignment, ""); llvm_store_to_ptr_raw_aligned(c, store, val, lhs->alignment); - llvm_value_set_address(be_value, store, lhs->type, lhs->alignment); + llvm_value_set_address(c, be_value, store, lhs->type, lhs->alignment); } INLINE void llvm_fold_for_compare(GenContext *c, BEValue *be_value) @@ -4296,7 +4296,7 @@ static inline void llvm_emit_rethrow_expr(GenContext *c, BEValue *be_value, Expr llvm_emit_statement_chain(c, expr->rethrow_expr.cleanup); POP_DEFER_ERROR(); BEValue value; - llvm_value_set_address_abi_aligned(&value, error_var, type_fault); + llvm_value_set_address_abi_aligned(c, &value, error_var, type_fault); if (expr->rethrow_expr.in_block) { BlockExit *exit = *expr->rethrow_expr.in_block; @@ -4351,7 +4351,7 @@ static inline void llvm_emit_force_unwrap_expr(GenContext *c, BEValue *be_value, SourceSpan loc = expr->span; BEValue *varargs = NULL; BEValue fault_arg; - llvm_value_set_address(&fault_arg, error_var, type_fault, type_abi_alignment(type_fault)); + llvm_value_set_address(c, &fault_arg, error_var, type_fault, type_abi_alignment(type_fault)); llvm_emit_any_from_value(c, &fault_arg, type_fault); vec_add(varargs, fault_arg); llvm_emit_panic(c, "Force unwrap failed!", loc, "Unexpected fault '%s' was unwrapped!", varargs); @@ -4598,7 +4598,7 @@ static inline void llvm_emit_const_initializer_list_expr(GenContext *c, BEValue llvm_value_set(value, llvm_emit_const_initializer(c, expr->const_expr.initializer), expr->type); return; } - llvm_value_set_address_abi_aligned(value, llvm_emit_alloca_aligned(c, expr->type, "literal"), expr->type); + llvm_value_set_address_abi_aligned(c, value, llvm_emit_alloca_aligned(c, expr->type, "literal"), expr->type); llvm_emit_const_initialize_reference(c, value, expr); } @@ -4666,7 +4666,7 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr) else { ASSERT(type_is_arraylike(init->type)); - llvm_value_set_address_abi_aligned(be_value, llvm_emit_alloca_aligned(c, init->type, "literal"), init->type); + llvm_value_set_address_abi_aligned(c, be_value, llvm_emit_alloca_aligned(c, init->type, "literal"), init->type); llvm_emit_const_init_ref(c, be_value, init, true); LLVMValueRef val = llvm_emit_aggregate_two(c, type, be_value->value, llvm_const_int(c, type_usz, init->type->array.len)); llvm_value_set(be_value, val, type); @@ -4746,7 +4746,7 @@ static void llvm_emit_const_expr(GenContext *c, BEValue *be_value, Expr *expr) LLVMSetInitializer(global_name, data); if (is_array) { - llvm_value_set_address(be_value, global_name, type, 1); + llvm_value_set_address(c, be_value, global_name, type, 1); } else { @@ -4857,7 +4857,7 @@ void llvm_emit_struct_member_ref(GenContext *c, BEValue *struct_ref, BEValue *me 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); - llvm_value_set_address(member_ref, ptr, struct_ref->type->decl->strukt.members[member_id]->type, align); + llvm_value_set_address(c, member_ref, ptr, struct_ref->type->decl->strukt.members[member_id]->type, align); } LLVMValueRef llvm_emit_struct_gep_raw(GenContext *c, LLVMValueRef ptr, LLVMTypeRef struct_type, unsigned index, @@ -4978,7 +4978,7 @@ void llvm_emit_slice_len(GenContext *c, BEValue *slice, BEValue *len) 1, slice->alignment, &alignment); - llvm_value_set_address(len, len_addr, type_usz, alignment); + llvm_value_set_address(c, len, len_addr, type_usz, alignment); } void llvm_emit_slice_pointer(GenContext *c, BEValue *slice, BEValue *pointer) @@ -4990,7 +4990,7 @@ void llvm_emit_slice_pointer(GenContext *c, BEValue *slice, BEValue *pointer) { AlignSize alignment; LLVMValueRef ptr = llvm_emit_struct_gep_raw(c, slice->value, llvm_get_type(c, slice->type), 0, slice->alignment, &alignment); - llvm_value_set_address(pointer, ptr, ptr_type, alignment); + llvm_value_set_address(c, pointer, ptr, ptr_type, alignment); return; } LLVMValueRef ptr = llvm_emit_extract_value(c, slice->value, 0); @@ -5004,7 +5004,7 @@ static void llvm_emit_any_pointer(GenContext *c, BEValue *value, BEValue *pointe { AlignSize alignment; LLVMValueRef ptr = llvm_emit_struct_gep_raw(c, value->value, llvm_get_type(c, value->type), 0, value->alignment, &alignment); - llvm_value_set_address(pointer, ptr, type_voidptr, alignment); + llvm_value_set_address(c, pointer, ptr, type_voidptr, alignment); return; } LLVMValueRef ptr = llvm_emit_extract_value(c, value->value, 0); @@ -5032,7 +5032,7 @@ void llvm_value_struct_gep(GenContext *c, BEValue *element, BEValue *struct_poin (unsigned)actual_index, struct_pointer->alignment, &alignment); - llvm_value_set_address_abi_aligned(element, ref, member->type); + llvm_value_set_address_abi_aligned(c, element, ref, member->type); element->alignment = alignment; } @@ -5312,7 +5312,7 @@ void llvm_emit_raw_call(GenContext *c, BEValue *result_value, FunctionPrototype // COERCE UPDATE bitcast removed, check for ways to optimize LLVMValueRef addr = llvm_emit_alloca_aligned(c, call_return_type, ""); - llvm_value_set_address_abi_aligned(result_value, addr, call_return_type); + llvm_value_set_address_abi_aligned(c, result_value, addr, call_return_type); // Store lower AlignSize align = result_value->alignment; @@ -5377,7 +5377,7 @@ void llvm_emit_raw_call(GenContext *c, BEValue *result_value, FunctionPrototype BEValue error_holder = *result_value; if (error_var) { - llvm_value_set_address_abi_aligned(&error_holder, c->catch.fault, type_fault); + llvm_value_set_address_abi_aligned(c, &error_holder, c->catch.fault, type_fault); } LLVMValueRef stored_error; @@ -5607,10 +5607,10 @@ INLINE void llvm_emit_call_invocation(GenContext *c, BEValue *result_value, sret_return = true; break; } - llvm_value_set_address(result_value, + llvm_value_set_address(c, + result_value, llvm_emit_alloca(c, llvm_get_type(c, call_return_type), alignment, "sretparam"), - call_return_type, - alignment); + call_return_type, alignment); // 6c. Add the pointer to the list of arguments. arg_values[arg_count++] = result_value->value; @@ -5639,7 +5639,7 @@ INLINE void llvm_emit_call_invocation(GenContext *c, BEValue *result_value, // 7c. Emit it as a parameter as a pointer (will implicitly add it to the value list) llvm_emit_parameter(c, arg_values, &arg_count, prototype->ret_by_ref_abi_info, &synthetic_return_param, synthetic_return_param.type); // 7d. Update the be_value to actually be an address. - llvm_value_set_address_abi_aligned(&synthetic_return_param, synthetic_return_param.value, actual_return_type); + llvm_value_set_address_abi_aligned(c, &synthetic_return_param, synthetic_return_param.value, actual_return_type); } // 8. Add all other arguments. @@ -6073,7 +6073,7 @@ static inline void llvm_emit_return_block(GenContext *c, BEValue *be_value, Type if (exit.block_return_out) { - llvm_value_set_address_abi_aligned(be_value, exit.block_return_out, type_lowered); + llvm_value_set_address_abi_aligned(c, be_value, exit.block_return_out, type_lowered); } else { @@ -6263,7 +6263,7 @@ static inline void llvm_emit_initializer_list_expr(GenContext *c, BEValue *value return; } ASSERT(!IS_OPTIONAL(expr) || c->catch.block); - llvm_value_set_address_abi_aligned(value, llvm_emit_alloca_aligned(c, type, "literal"), type); + llvm_value_set_address_abi_aligned(c, value, llvm_emit_alloca_aligned(c, type, "literal"), type); llvm_emit_initialize_reference(c, value, expr); } @@ -6348,7 +6348,7 @@ void llvm_emit_catch_unwrap(GenContext *c, BEValue *value, Expr *expr) else { LLVMValueRef temp_err = llvm_emit_alloca_aligned(c, type_fault, "temp_err"); - llvm_value_set_address_abi_aligned(&addr, temp_err, type_fault); + llvm_value_set_address_abi_aligned(c, &addr, temp_err, type_fault); } LLVMBasicBlockRef catch_block = llvm_basic_block_new(c, "end_block"); @@ -6584,7 +6584,7 @@ static inline void llvm_emit_type_from_any(GenContext *c, BEValue *be_value) 1, be_value->alignment, &alignment); - llvm_value_set_address(be_value, pointer_addr, type_typeid, alignment); + llvm_value_set_address(c, be_value, pointer_addr, type_typeid, alignment); } else { @@ -6607,7 +6607,7 @@ static inline void llvm_emit_builtin_access(GenContext *c, BEValue *be_value, Ex llvm_value_rvalue(c, be_value); LLVMValueRef val = llvm_emit_alloca_aligned(c, type_chars, "faultname_zero"); BEValue zero; - llvm_value_set_address_abi_aligned(&zero, val, type_chars); + llvm_value_set_address_abi_aligned(c, &zero, val, type_chars); LLVMBasicBlockRef exit_block = llvm_basic_block_new(c, "faultname_exit"); LLVMBasicBlockRef zero_block = llvm_basic_block_new(c, "faultname_no"); LLVMBasicBlockRef ok_block = llvm_basic_block_new(c, "faultname_ok"); @@ -6623,7 +6623,7 @@ static inline void llvm_emit_builtin_access(GenContext *c, BEValue *be_value, Ex llvm_emit_block(c, exit_block); LLVMValueRef phi = LLVMBuildPhi(c->builder, c->ptr_type, "faultname"); llvm_set_phi(phi, zero.value, zero_block, fault_data, ok_block); - llvm_value_set_address_abi_aligned(be_value, phi, type_chars); + llvm_value_set_address_abi_aligned(c, be_value, phi, type_chars); return; } case ACCESS_ENUMNAME: @@ -6636,15 +6636,15 @@ static inline void llvm_emit_builtin_access(GenContext *c, BEValue *be_value, Ex c->ptr_type, ""); LLVMValueRef ptr = LLVMBuildStructGEP2(c->builder, c->introspect_type, to_introspect, INTROSPECT_INDEX_ADDITIONAL, ""); LLVMValueRef val = llvm_zext_trunc(c, be_value->value, c->size_type); - llvm_value_set_address(be_value, llvm_emit_pointer_gep_raw(c, slice, ptr, val), - type_chars, llvm_abi_alignment(c, slice)); + llvm_value_set_address(c, be_value, + llvm_emit_pointer_gep_raw(c, slice, ptr, val), type_chars, llvm_abi_alignment(c, slice)); return; } case ACCESS_TYPEOFANYFAULT: { llvm_value_addr(c, be_value); LLVMValueRef value = llvm_load(c, c->ptr_type, be_value->value, be_value->alignment, ""); - llvm_value_set_address(be_value, value, type_typeid, type_alloca_alignment(type_typeid)); + llvm_value_set_address(c, be_value, value, type_typeid, type_alloca_alignment(type_typeid)); return; } case ACCESS_TYPEOFANY: @@ -6679,13 +6679,13 @@ static LLVMValueRef llvm_get_benchmark_hook_global(GenContext *c, Expr *expr) INLINE void llvm_emit_last_fault(GenContext *c, BEValue *value) { ASSERT(c->defer_error_var); - llvm_value_set_address_abi_aligned(value, c->defer_error_var, type_fault); + llvm_value_set_address_abi_aligned(c, value, c->defer_error_var, type_fault); } INLINE void llmv_emit_benchmark_hook(GenContext *c, BEValue *value, Expr *expr) { LLVMValueRef get_global = llvm_get_benchmark_hook_global(c, expr); - llvm_value_set_address_abi_aligned(value, get_global, expr->type); + llvm_value_set_address_abi_aligned(c, value, get_global, expr->type); } static LLVMValueRef llvm_get_test_hook_global(GenContext *c, Expr *expr) @@ -6713,7 +6713,7 @@ static LLVMValueRef llvm_get_test_hook_global(GenContext *c, Expr *expr) static void llmv_emit_test_hook(GenContext *c, BEValue *value, Expr *expr) { LLVMValueRef get_global = llvm_get_test_hook_global(c, expr); - llvm_value_set_address_abi_aligned(value, get_global, expr->type); + llvm_value_set_address_abi_aligned(c, value, get_global, expr->type); } static void llvm_emit_swizzle_from_value(GenContext *c, LLVMValueRef vector_value, BEValue *value, Expr *expr) @@ -6834,7 +6834,7 @@ static void llvm_emit_ptr_access(GenContext *c, BEValue *value, Expr *expr) { AlignSize alignment; LLVMValueRef ptr = llvm_emit_struct_gep_raw(c, value->value, llvm_get_type(c, value->type), 0, value->alignment, &alignment); - llvm_value_set_address(value, ptr, expr->type, alignment); + llvm_value_set_address(c, value, ptr, expr->type, alignment); return; } LLVMValueRef ptr = llvm_emit_extract_value(c, value->value, 0); @@ -6951,7 +6951,7 @@ void llvm_emit_slice_to_vec_array(GenContext *c, BEValue *value, Expr *expr) AlignSize alignment = llvm_abi_alignment(c, type); LLVMValueRef temp = llvm_emit_alloca(c, type, alignment, ".temp"); llvm_emit_memcpy(c, temp, alignment, pointer.value, element_alignment, llvm_abi_size(c, type)); - llvm_value_set_address(value, temp, to_type, alignment); + llvm_value_set_address(c, value, temp, to_type, alignment); } static inline void llvm_emit_make_slice(GenContext *c, BEValue *value, Expr *expr) diff --git a/src/compiler/llvm_codegen_internal.h b/src/compiler/llvm_codegen_internal.h index f02711bf6..961a8932d 100644 --- a/src/compiler/llvm_codegen_internal.h +++ b/src/compiler/llvm_codegen_internal.h @@ -233,6 +233,7 @@ typedef struct unsigned ssub_sat; unsigned trap; unsigned debugtrap; + unsigned threadlocal_address; unsigned trunc; unsigned uadd_overflow; unsigned uadd_sat; @@ -333,8 +334,8 @@ void llvm_value_rvalue(GenContext *c, BEValue *value); void llvm_value_deref(GenContext *c, BEValue *value); void llvm_value_set(BEValue *value, LLVMValueRef llvm_value, Type *type); void llvm_value_set_int(GenContext *c, BEValue *value, Type *type, uint64_t i); -void llvm_value_set_address(BEValue *value, LLVMValueRef llvm_value, Type *type, AlignSize alignment); -void llvm_value_set_address_abi_aligned(BEValue *value, LLVMValueRef llvm_value, Type *type); +void llvm_value_set_address(GenContext *c, BEValue *value, LLVMValueRef llvm_value, Type *type, AlignSize alignment); +void llvm_value_set_address_abi_aligned(GenContext *c, 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_optional(GenContext *c, BEValue *value); diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c index c584e1f04..ef5fded38 100644 --- a/src/compiler/llvm_codegen_stmt.c +++ b/src/compiler/llvm_codegen_stmt.c @@ -268,7 +268,7 @@ static inline void llvm_emit_return(GenContext *c, Ast *ast) { LLVMValueRef temp = llvm_emit_alloca_aligned(c, return_value.type, "ret$temp"); llvm_store_to_ptr(c, temp, &return_value); - llvm_value_set_address_abi_aligned(&return_value, temp, return_value.type); + llvm_value_set_address_abi_aligned(c, &return_value, temp, return_value.type); } else { @@ -297,7 +297,7 @@ static inline void llvm_emit_return(GenContext *c, Ast *ast) llvm_emit_statement_chain(c, ast->return_stmt.cleanup_fail); POP_DEFER_ERROR(); BEValue value; - llvm_value_set_address_abi_aligned(&value, error_out, type_fault); + llvm_value_set_address_abi_aligned(c, &value, error_out, type_fault); llvm_emit_return_abi(c, NULL, &value); } } @@ -987,7 +987,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); + llvm_value_set_address_abi_aligned(c, &switch_var, llvm_emit_alloca_aligned(c, switch_type, "switch"), switch_type); switch_ast->switch_stmt.codegen.retry.var = &switch_var; llvm_store(c, &switch_var, switch_value); diff --git a/src/compiler/llvm_codegen_storeload.c b/src/compiler/llvm_codegen_storeload.c index 357678750..f8c08a2e2 100644 --- a/src/compiler/llvm_codegen_storeload.c +++ b/src/compiler/llvm_codegen_storeload.c @@ -155,7 +155,7 @@ LLVMValueRef llvm_store_zero(GenContext *c, BEValue *ref) AlignSize align; LLVMValueRef element_ptr = llvm_emit_array_gep_raw(c, ref->value, array_type, i, ref->alignment, &align); BEValue be_value; - llvm_value_set_address(&be_value, element_ptr, type->array.base, align); + llvm_value_set_address(c, &be_value, element_ptr, type->array.base, align); llvm_store_zero(c, &be_value); } return NULL; diff --git a/src/compiler/llvm_codegen_value.c b/src/compiler/llvm_codegen_value.c index 00cb40440..d7e7de963 100644 --- a/src/compiler/llvm_codegen_value.c +++ b/src/compiler/llvm_codegen_value.c @@ -42,22 +42,26 @@ void llvm_value_set(BEValue *value, LLVMValueRef llvm_value, Type *type) } } -void llvm_value_set_address(BEValue *value, LLVMValueRef llvm_value, Type *type, AlignSize alignment) +void llvm_value_set_address(GenContext *c, BEValue *value, LLVMValueRef llvm_value, Type *type, AlignSize alignment) { if (alignment == 0) { puts("TODO"); } ASSERT(alignment > 0); + if (LLVMIsAGlobalVariable(llvm_value) && LLVMIsThreadLocal(llvm_value)) + { + llvm_value = llvm_emit_call_intrinsic(c, intrinsic_id.threadlocal_address, &c->ptr_type, 1, &llvm_value, 1); + } value->value = llvm_value; value->alignment = alignment; value->kind = BE_ADDRESS; value->type = type_lowering(type); } -void llvm_value_set_address_abi_aligned(BEValue *value, LLVMValueRef llvm_value, Type *type) +void llvm_value_set_address_abi_aligned(GenContext *c, BEValue *value, LLVMValueRef llvm_value, Type *type) { - llvm_value_set_address(value, llvm_value, type_lowering(type), type_abi_alignment(type)); + llvm_value_set_address(c, value, llvm_value, type_lowering(type), type_abi_alignment(type)); } void llvm_value_addr(GenContext *c, BEValue *value) @@ -70,13 +74,13 @@ void llvm_value_addr(GenContext *c, BEValue *value) LLVMValueRef ref = llvm_add_global_raw(c, ".taddr", LLVMTypeOf(val), 0); llvm_set_private_declaration(ref); LLVMSetInitializer(ref, val); - llvm_value_set_address_abi_aligned(value, ref, value->type); + llvm_value_set_address_abi_aligned(c, value, ref, value->type); } else { LLVMValueRef temp = llvm_emit_alloca_aligned(c, value->type, "taddr"); llvm_store_to_ptr(c, temp, value); - llvm_value_set_address_abi_aligned(value, temp, value->type); + llvm_value_set_address_abi_aligned(c, value, temp, value->type); } } @@ -169,7 +173,7 @@ void llvm_value_set_decl_address(GenContext *c, BEValue *value, Decl *decl) { ASSERT(!decl->is_value); LLVMValueRef backend_ref = llvm_get_ref(c, decl); - llvm_value_set_address(value, backend_ref, decl->type, decl->alignment); + llvm_value_set_address(c, value, backend_ref, decl->type, decl->alignment); if ((value->optional = llvm_get_opt_ref(c, decl))) { diff --git a/test/test_suite/debug_symbols/defer_macro.c3t b/test/test_suite/debug_symbols/defer_macro.c3t index 38ded9f74..6e01f47d8 100644 --- a/test/test_suite/debug_symbols/defer_macro.c3t +++ b/test/test_suite/debug_symbols/defer_macro.c3t @@ -399,165 +399,165 @@ entry: %6 = load i32, ptr %argc2, align 4, !dbg !150 %sext = sext i32 %6 to i64, !dbg !150 store i64 %sext, ptr %elements, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator, ptr align 8 @std.core.mem.allocator.thread_allocator, i32 16, i1 false) - %7 = load i64, ptr %elements, align 8 - store i64 %7, ptr %elements6, align 8 + %7 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator), !dbg !151 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator, ptr align 8 %7, i32 16, i1 false) + %8 = load i64, ptr %elements, align 8 + store i64 %8, ptr %elements6, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator7, ptr align 8 %allocator, i32 16, i1 false) - %8 = load i64, ptr %elements6, align 8 - store i64 %8, ptr %elements8, align 8 + %9 = load i64, ptr %elements6, align 8 + store i64 %9, ptr %elements8, align 8 call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator10, ptr align 8 %allocator7, i32 16, i1 false) - %9 = load i64, ptr %elements8, align 8, !dbg !151 - %mul = mul i64 16, %9, !dbg !159 + %10 = load i64, ptr %elements8, align 8, !dbg !154 + %mul = mul i64 16, %10, !dbg !160 store i64 %mul, ptr %size, align 8 - %10 = load i64, ptr %size, align 8, !dbg !160 - %i2nb = icmp eq i64 %10, 0, !dbg !160 - br i1 %i2nb, label %if.then, label %if.exit, !dbg !160 + %11 = load i64, ptr %size, align 8, !dbg !161 + %i2nb = icmp eq i64 %11, 0, !dbg !161 + br i1 %i2nb, label %if.then, label %if.exit, !dbg !161 if.then: ; preds = %entry - store ptr null, ptr %blockret11, align 8, !dbg !163 - br label %expr_block.exit, !dbg !163 + store ptr null, ptr %blockret11, align 8, !dbg !164 + br label %expr_block.exit, !dbg !164 if.exit: ; preds = %entry - %ptradd = getelementptr inbounds i8, ptr %allocator10, i64 8, !dbg !164 - %11 = load i64, ptr %ptradd, align 8, !dbg !164 - %12 = inttoptr i64 %11 to ptr, !dbg !164 + %ptradd = getelementptr inbounds i8, ptr %allocator10, i64 8, !dbg !165 + %12 = load i64, ptr %ptradd, align 8, !dbg !165 + %13 = inttoptr i64 %12 to ptr, !dbg !165 %type = load ptr, ptr %.cachedtype, align 8 - %13 = icmp eq ptr %12, %type - br i1 %13, label %cache_hit, label %cache_miss + %14 = icmp eq ptr %13, %type + br i1 %14, label %cache_hit, label %cache_miss cache_miss: ; preds = %if.exit - %ptradd12 = getelementptr inbounds i8, ptr %12, i64 16 - %14 = load ptr, ptr %ptradd12, align 8 - %15 = call ptr @.dyn_search(ptr %14, ptr @"$sel.acquire") - store ptr %15, ptr %.inlinecache, align 8 - store ptr %12, ptr %.cachedtype, align 8 - br label %16 + %ptradd12 = getelementptr inbounds i8, ptr %13, i64 16 + %15 = load ptr, ptr %ptradd12, align 8 + %16 = call ptr @.dyn_search(ptr %15, ptr @"$sel.acquire") + store ptr %16, ptr %.inlinecache, align 8 + store ptr %13, ptr %.cachedtype, align 8 + br label %17 cache_hit: ; preds = %if.exit %cache_hit_fn = load ptr, ptr %.inlinecache, align 8 - br label %16 + br label %17 -16: ; preds = %cache_hit, %cache_miss - %fn_phi = phi ptr [ %cache_hit_fn, %cache_hit ], [ %15, %cache_miss ] - %17 = icmp eq ptr %fn_phi, null - br i1 %17, label %missing_function, label %match +17: ; preds = %cache_hit, %cache_miss + %fn_phi = phi ptr [ %cache_hit_fn, %cache_hit ], [ %16, %cache_miss ] + %18 = icmp eq ptr %fn_phi, null + br i1 %18, label %missing_function, label %match -missing_function: ; preds = %16 - %18 = load ptr, ptr @std.core.builtin.panic, align 8, !dbg !166 - call void %18(ptr @.panic_msg, i64 44, ptr @.file, i64 16, ptr @.func - unreachable, !dbg !166 +missing_function: ; preds = %17 + %19 = load ptr, ptr @std.core.builtin.panic, align 8, !dbg !167 + call void %19(ptr @.panic_msg, i64 44, ptr @.file, i64 16, ptr @.func, i64 6, i32 85) #5, !dbg !167 + unreachable, !dbg !167 -match: ; preds = %16 - %19 = load ptr, ptr %allocator10, align 8 - %20 = load i64, ptr %size, align 8 - %21 = call i64 %fn_phi(ptr %retparam, ptr %19, i64 %20, i32 0, i64 0), !dbg !166 - %not_err = icmp eq i64 %21, 0, !dbg !166 - %22 = call i1 @llvm.expect.i1(i1 %not_err, i1 true), !dbg !166 - br i1 %22, label %after_check, label %assign_optional, !dbg !166 +match: ; preds = %17 + %20 = load ptr, ptr %allocator10, align 8 + %21 = load i64, ptr %size, align 8 + %22 = call i64 %fn_phi(ptr %retparam, ptr %20, i64 %21, i32 0, i64 0), !dbg !167 + %not_err = icmp eq i64 %22, 0, !dbg !167 + %23 = call i1 @llvm.expect.i1(i1 %not_err, i1 true), !dbg !167 + br i1 %23, label %after_check, label %assign_optional, !dbg !167 assign_optional: ; preds = %match - store i64 %21, ptr %error_var, align 8, !dbg !166 - br label %panic_block, !dbg !166 + store i64 %22, ptr %error_var, align 8, !dbg !167 + br label %panic_block, !dbg !167 after_check: ; preds = %match - %23 = load ptr, ptr %retparam, align 8, !dbg !166 - store ptr %23, ptr %blockret11, align 8, !dbg !166 - br label %expr_block.exit, !dbg !166 + %24 = load ptr, ptr %retparam, align 8, !dbg !167 + store ptr %24, ptr %blockret11, align 8, !dbg !167 + br label %expr_block.exit, !dbg !167 expr_block.exit: ; preds = %after_check, %if.then - %24 = load ptr, ptr %blockret11, align 8, !dbg !166 - store ptr %24, ptr %taddr, align 8 - %25 = load ptr, ptr %taddr, align 8 - %26 = load i64, ptr %elements8, align 8, !dbg !167 - %add = add i64 0, %26, !dbg !167 - %size13 = sub i64 %add, 0, !dbg !167 - %27 = insertvalue %"char[][]" undef, ptr %25, 0, !dbg !167 - %28 = insertvalue %"char[][]" %27, i64 %size13, 1, !dbg !167 - br label %noerr_block, !dbg !167 + %25 = load ptr, ptr %blockret11, align 8, !dbg !167 + store ptr %25, ptr %taddr, align 8 + %26 = load ptr, ptr %taddr, align 8 + %27 = load i64, ptr %elements8, align 8, !dbg !168 + %add = add i64 0, %27, !dbg !168 + %size13 = sub i64 %add, 0, !dbg !168 + %28 = insertvalue %"char[][]" undef, ptr %26, 0, !dbg !168 + %29 = insertvalue %"char[][]" %28, i64 %size13, 1, !dbg !168 + br label %noerr_block, !dbg !168 panic_block: ; preds = %assign_optional - %29 = insertvalue %any undef, ptr %error_var, 0, !dbg !167 - %30 = insertvalue %any %29, i64 ptrtoint (ptr @"$ct.fault" to i64), 1, !dbg !167 - store %any %30, ptr %varargslots, align 16 - %31 = insertvalue %"any[]" undef, ptr %varargslots, 0 - %"$$temp" = insertvalue %"any[]" %31, i64 1, 1 + %30 = insertvalue %any undef, ptr %error_var, 0, !dbg !168 + %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.fault" to i64), 1, !dbg !168 + store %any %31, ptr %varargslots, align 16 + %32 = insertvalue %"any[]" undef, ptr %varargslots, 0 + %"$$temp" = insertvalue %"any[]" %32, i64 1, 1 store %"any[]" %"$$temp", ptr %indirectarg, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg.1 - unreachable, !dbg !154 + unreachable, !dbg !157 noerr_block: ; preds = %expr_block.exit - store %"char[][]" %28, ptr %list5, align 8, !dbg !154 - !170 - store i32 0, ptr %i, align 4, !dbg !171 - br label %loop.cond, !dbg !171 + store %"char[][]" %29, ptr %list5, align 8, !dbg !157 + + store i32 0, ptr %i, align 4, !dbg !172 + br label %loop.cond, !dbg !172 loop.cond: ; preds = %loop.exit, %noerr_block - %32 = load i32, ptr %i, align 4, !dbg !172 - %33 = load i32, ptr %argc2, align 4, !dbg !173 - %lt = icmp slt i32 %32, %33, !dbg !172 - br i1 %lt, label %loop.body, label %loop.exit26, !dbg !172 + %33 = load i32, ptr %i, align 4, !dbg !173 + %34 = load i32, ptr %argc2, align 4, !dbg !174 + %lt = icmp slt i32 %33, %34, !dbg !173 + br i1 %lt, label %loop.body, label %loop.exit26, !dbg !173 loop.body: ; preds = %loop.cond - !176 - %34 = load ptr, ptr %argv3, align 8, !dbg !177 - %35 = load i32, ptr %i, align 4, !dbg !178 - %sext14 = sext i32 %35 to i64, !dbg !178 - %ptroffset = getelementptr inbounds [8 x i8], ptr %34, i64 %sext14, !dbg !178 - %36 = load ptr, ptr %ptroffset, align 8, !dbg !178 - store ptr %36, ptr %arg, align 8, !dbg !178 - !180 - store i64 0, ptr %len, align 8, !dbg !181 - %37 = load ptr, ptr %list5, align 8, !dbg !182 - %38 = load i32, ptr %i, align 4, !dbg !183 - %sext15 = sext i32 %38 to i64, !dbg !183 - %ptroffset16 = getelementptr inbounds [16 x i8], ptr %37, i64 %sext15, !dbg !183 - %39 = load ptr, ptr %arg, align 8, !dbg !184 - %40 = load ptr, ptr %arg, align 8 - store ptr %40, ptr %ptr, align 8 - !187 - store i64 0, ptr %len18, align 8, !dbg !189 - br label %loop.cond19, !dbg !190 + %35 = load ptr, ptr %argv3, align 8, !dbg !178 + %36 = load i32, ptr %i, align 4, !dbg !179 + %sext14 = sext i32 %36 to i64, !dbg !179 + %ptroffset = getelementptr inbounds [8 x i8], ptr %35, i64 %sext14, !dbg !179 + %37 = load ptr, ptr %ptroffset, align 8, !dbg !179 + store ptr %37, ptr %arg, align 8, !dbg !179 + + store i64 0, ptr %len, align 8, !dbg !182 + %38 = load ptr, ptr %list5, align 8, !dbg !183 + %39 = load i32, ptr %i, align 4, !dbg !184 + %sext15 = sext i32 %39 to i64, !dbg !184 + %ptroffset16 = getelementptr inbounds [16 x i8], ptr %38, i64 %sext15, !dbg !184 + %40 = load ptr, ptr %arg, align 8, !dbg !185 + %41 = load ptr, ptr %arg, align 8 + store ptr %41, ptr %ptr, align 8 + + store i64 0, ptr %len18, align 8, !dbg !190 + br label %loop.cond19, !dbg !191 loop.cond19: ; preds = %loop.body21, %loop.body - %41 = load ptr, ptr %ptr, align 8, !dbg !191 - %42 = load i64, ptr %len18, align 8, !dbg !193 - %ptradd20 = getelementptr inbounds i8, ptr %41, i64 %42, !dbg !193 - %43 = load i8, ptr %ptradd20, align 1, !dbg !193 - %i2b = icmp ne i8 %43, 0, !dbg !193 - br i1 %i2b, label %loop.body21, label %loop.exit, !dbg !193 + %42 = load ptr, ptr %ptr, align 8, !dbg !192 + %43 = load i64, ptr %len18, align 8, !dbg !194 + %ptradd20 = getelementptr inbounds i8, ptr %42, i64 %43, !dbg !194 + %44 = load i8, ptr %ptradd20, align 1, !dbg !194 + %i2b = icmp ne i8 %44, 0, !dbg !194 + br i1 %i2b, label %loop.body21, label %loop.exit, !dbg !194 loop.body21: ; preds = %loop.cond19 - %44 = load i64, ptr %len18, align 8, !dbg !194 - %add22 = add i64 %44, 1, !dbg !194 - store i64 %add22, ptr %len18, align 8, !dbg !194 - br label %loop.cond19, !dbg !194 + %45 = load i64, ptr %len18, align 8, !dbg !195 + %add22 = add i64 %45, 1, !dbg !195 + store i64 %add22, ptr %len18, align 8, !dbg !195 + br label %loop.cond19, !dbg !195 loop.exit: ; preds = %loop.cond19 - %45 = load i64, ptr %len18, align 8, !dbg !195 - %add23 = add i64 0, %45, !dbg !195 - %size24 = sub i64 %add23, 0, !dbg !195 - %46 = insertvalue %"char[]" undef, ptr %39, 0, !dbg !195 - %47 = insertvalue %"char[]" %46, i64 %size24, 1, !dbg !195 - store %"char[]" %47, ptr %ptroffset16, align 8, !dbg !195 - %48 = load i32, ptr %i, align 4, !dbg !196 - %add25 = add i32 %48, 1, !dbg !196 - store i32 %add25, ptr %i, align 4, !dbg !196 - br label %loop.cond, !dbg !196 + %46 = load i64, ptr %len18, align 8, !dbg !196 + %add23 = add i64 0, %46, !dbg !196 + %size24 = sub i64 %add23, 0, !dbg !196 + %47 = insertvalue %"char[]" undef, ptr %40, 0, !dbg !196 + %48 = insertvalue %"char[]" %47, i64 %size24, 1, !dbg !196 + store %"char[]" %48, ptr %ptroffset16, align 8, !dbg !196 + %49 = load i32, ptr %i, align 4, !dbg !197 + %add25 = add i32 %49, 1, !dbg !197 + store i32 %add25, ptr %i, align 4, !dbg !197 + br label %loop.cond, !dbg !197 loop.exit26: ; preds = %loop.cond - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %list, ptr align 8 %list5, i32 16, i1 false), !dbg !197 - %lo = load ptr, ptr %list, align 8, !dbg !198 - %ptradd27 = getelementptr inbounds i8, ptr %list, i64 8, !dbg !198 - %hi = load i64, ptr %ptradd27, align 8, !dbg !198 - %49 = call i32 @test.main(ptr %lo, i64 %hi), !dbg !199 - store i32 %49, ptr %blockret, align 4, !dbg !199 - %50 = load ptr, ptr %list, align 8, !dbg !200 - call void @std.core.mem.free(ptr %50) - br label %expr_block.exit28, !dbg !202 + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %list, ptr align 8 %list5, i32 16, i1 false), !dbg !198 + %lo = load ptr, ptr %list, align 8, !dbg !199 + %ptradd27 = getelementptr inbounds i8, ptr %list, i64 8, !dbg !199 + %hi = load i64, ptr %ptradd27, align 8, !dbg !199 + %50 = call i32 @test.main(ptr %lo, i64 %hi), !dbg !200 + store i32 %50, ptr %blockret, align 4, !dbg !200 + %51 = load ptr, ptr %list, align 8, !dbg !201 + call void @std.core.mem.free(ptr %51) #4, !dbg !203 + br label %expr_block.exit28, !dbg !203 expr_block.exit28: ; preds = %loop.exit26 - %51 = load i32, ptr %blockret, align 4, !dbg !202 - ret i32 %51, !dbg !202 + %52 = load i32, ptr %blockret, align 4, !dbg !203 + ret i32 %52, !dbg !203 } declare { i32, ptr } @attach.to_scope() #0 @@ -681,9 +681,9 @@ no_match: ; preds = %compare !72 = !DILocation(line: 35, column: 49, scope: !66) !73 = !DILocalVariable(name: "name", arg: 3, scope: !66, file: !7, line: 35, type: !39) !74 = !DILocation(line: 35, column: 63, scope: !66) -!75 = !DILocation(line: -!76 = distinct !DISubprogram(name: "new", linkageName: "new", scope: !77, file: !77, line: -!77 = !DIFile(filename: "mem.c3" +!75 = !DILocation(line: 709, column: 18, scope: !76, inlinedAt: !78) +!76 = distinct !DISubprogram(name: "new", linkageName: "new", scope: !77, file: !77, line: 706, scopeLine: 706, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !6) +!77 = !DIFile(filename: "mem.c3", directory: !78 = !DILocation(line: 37, column: 9, scope: !66) !79 = distinct !DISubprogram(name: "test", linkageName: "test.test", scope: !7, file: !7, line: 45, type: !80, scopeLine: 45, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !6, retainedNodes: !21) !80 = !DISubroutineType(types: !81) @@ -753,59 +753,8 @@ no_match: ; preds = %compare !144 = !DIFile(filename: "main_stub.c3" !145 = !DILocation !146 = !DILocalVariable(name: "list", scope: !147, file: !7, line: 24, type: !35, align: 8) -!147 = distinct !DISubprogram(name: "args_to_strings", linkageName: "args_to_strings", scope: !144, file: !144 +!147 = distinct !DISubprogram(name: "args_to_strings" !148 = !DILocation !149 = !DILocation !150 = !DILocation !151 = !DILocation -!152 = distinct !DISubprogram(name: "alloc_array_try", linkageName: "alloc_array_try" -!153 = !DIFile(filename: "mem_allocator.c3" -!154 = !DILocation -!155 = distinct !DISubprogram(name: "alloc_array", linkageName: "alloc_array", scope: !153 -!156 = !DILocation -!157 = distinct !DISubprogram(name: "alloc_array", linkageName: "alloc_array", scope: !77 -!158 = !DILocation -!159 = !DILocation -!160 = !DILocation -!161 = distinct !DISubprogram(name: "malloc_try", linkageName: "malloc_try", scope: !153, file: !153 -!162 = !DILocation -!163 = !DILocation -!164 = !DILocation -!165 = distinct !DISubprogram(name: "[DEFAULT INIT]", linkageName: "[DEFAULT INIT]", scope: !153, file: !153 -!166 = !DILocation -!167 = !DILocation -!168 = !DILocalVariable(name: "i", scope: !169, file: !7, line: 25, type: !15, align: 4) -!169 = distinct !DILexicalBlock(scope: !147, file: !144, line: 25, column: 2) -!170 = !DILocation -!171 = !DILocation -!172 = !DILocation -!173 = !DILocation -!174 = !DILocalVariable(name: "arg", scope: !175, file: !7, line: 27, type: !43, align: 8) -!175 = distinct !DILexicalBlock(scope: !169, file: !144, line: 26, column: 2) -!176 = !DILocation -!177 = !DILocation -!178 = !DILocation -!179 = !DILocalVariable(name: "len", scope: !175, file: !7, line: 28, type: !46, align: 8) -!180 = !DILocation -!181 = !DILocation -!182 = !DILocation -!183 = !DILocation -!184 = !DILocation -!185 = !DILocalVariable(name: "len", scope: !186, file: !7, line: 5, type: !46, align: 8) -!186 = distinct !DISubprogram(name: "_strlen", linkageName: "_strlen", scope: !144, file: !144 -!187 = !DILocation -!188 = !DILocation -!189 = !DILocation -!190 = !DILocation -!191 = !DILocation -!192 = distinct !DILexicalBlock(scope: !186, file: !144, line: 6, column: 2) -!193 = !DILocation -!194 = !DILocation -!195 = !DILocation -!196 = !DILocation -!197 = !DILocation -!198 = !DILocation -!199 = !DILocation -!200 = !DILocation -!201 = distinct !DILexicalBlock(scope: !143, file: !144, line: 46, column: 8) -!202 = !DILocation \ No newline at end of file diff --git a/test/test_suite/defer/defer_catch_mix.c3t b/test/test_suite/defer/defer_catch_mix.c3t index 863e9c094..7e5503b86 100644 --- a/test/test_suite/defer/defer_catch_mix.c3t +++ b/test/test_suite/defer/defer_catch_mix.c3t @@ -304,90 +304,91 @@ entry: %retparam14 = alloca %"char[]", align 8 %taddr15 = alloca %"char[]", align 8 store ptr null, ptr %.cachedtype, align 8 - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator, ptr align 8 @std.core.mem.allocator.thread_allocator, i32 16, i1 false) + %0 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator, ptr align 8 %0, i32 16, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator1, ptr align 8 %allocator, i32 16, i1 false) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %allocator2, ptr align 8 %allocator1, i32 16, i1 false) br label %if.exit if.exit: ; preds = %entry %ptradd = getelementptr inbounds i8, ptr %allocator2, i64 8 - %0 = load i64, ptr %ptradd, align 8 - %1 = inttoptr i64 %0 to ptr + %1 = load i64, ptr %ptradd, align 8 + %2 = inttoptr i64 %1 to ptr %type = load ptr, ptr %.cachedtype, align 8 - %2 = icmp eq ptr %1, %type - br i1 %2, label %cache_hit, label %cache_miss + %3 = icmp eq ptr %2, %type + br i1 %3, label %cache_hit, label %cache_miss cache_miss: ; preds = %if.exit - %ptradd3 = getelementptr inbounds i8, ptr %1, i64 16 - %3 = load ptr, ptr %ptradd3, align 8 - %4 = call ptr @.dyn_search(ptr %3, ptr @"$sel.acquire") - store ptr %4, ptr %.inlinecache, align 8 - store ptr %1, ptr %.cachedtype, align 8 - br label %5 + %ptradd3 = getelementptr inbounds i8, ptr %2, i64 16 + %4 = load ptr, ptr %ptradd3, align 8 + %5 = call ptr @.dyn_search(ptr %4, ptr @"$sel.acquire") + store ptr %5, ptr %.inlinecache, align 8 + store ptr %2, ptr %.cachedtype, align 8 + br label %6 cache_hit: ; preds = %if.exit %cache_hit_fn = load ptr, ptr %.inlinecache, align 8 - br label %5 + br label %6 -5: ; preds = %cache_hit, %cache_miss - %fn_phi = phi ptr [ %cache_hit_fn, %cache_hit ], [ %4, %cache_miss ] - %6 = icmp eq ptr %fn_phi, null - br i1 %6, label %missing_function, label %match +6: ; preds = %cache_hit, %cache_miss + %fn_phi = phi ptr [ %cache_hit_fn, %cache_hit ], [ %5, %cache_miss ] + %7 = icmp eq ptr %fn_phi, null + br i1 %7, label %missing_function, label %match -missing_function: ; preds = %5 +missing_function: ; preds = %6 store %"char[]" { ptr @.panic_msg, i64 44 }, ptr %taddr, align 8 - %7 = load [2 x i64], ptr %taddr, align 8 + %8 = load [2 x i64], ptr %taddr, align 8 store %"char[]" { ptr @.file, i64 16 }, ptr %taddr4, align 8 - %8 = load [2 x i64], ptr %taddr4, align 8 + %9 = load [2 x i64], ptr %taddr4, align 8 store %"char[]" { ptr @.func, i64 4 }, ptr %taddr5, align 8 - %9 = load [2 x i64], ptr %taddr5, align 8 - %10 = load ptr, ptr @std.core.builtin.panic, align 8 - call void %10([2 x i64] %7, [2 x i64] %8, [2 x i64] %9 + %10 = load [2 x i64], ptr %taddr5, align 8 + %11 = load ptr, ptr @std.core.builtin.panic, align 8 + call void %11([2 x i64] %8, [2 x i64] %9, [2 x i64] %10, i32 97) #4 unreachable -match: ; preds = %5 - %11 = load ptr, ptr %allocator2, align 8 - %12 = call i64 %fn_phi(ptr %retparam, ptr %11, i64 12, i32 1, i64 0) - %not_err = icmp eq i64 %12, 0 - %13 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %13, label %after_check, label %assign_optional +match: ; preds = %6 + %12 = load ptr, ptr %allocator2, align 8 + %13 = call i64 %fn_phi(ptr %retparam, ptr %12, i64 12, i32 1, i64 0) + %not_err = icmp eq i64 %13, 0 + %14 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %14, label %after_check, label %assign_optional assign_optional: ; preds = %match - store i64 %12, ptr %error_var, align 8 + store i64 %13, ptr %error_var, align 8 br label %panic_block after_check: ; preds = %match - %14 = load ptr, ptr %retparam, align 8 - store ptr %14, ptr %taddr6, align 8 - %15 = load ptr, ptr %taddr6, align 8 - %16 = insertvalue %"char[]" undef, ptr %15, 0 - %17 = insertvalue %"char[]" %16, i64 12, 1 + %15 = load ptr, ptr %retparam, align 8 + store ptr %15, ptr %taddr6, align 8 + %16 = load ptr, ptr %taddr6, align 8 + %17 = insertvalue %"char[]" undef, ptr %16, 0 + %18 = insertvalue %"char[]" %17, i64 12, 1 br label %noerr_block panic_block: ; preds = %assign_optional - %18 = insertvalue %any undef, ptr %error_var, 0 - %19 = insertvalue %any %18, i64 ptrtoint (ptr @"$ct.fault" to i64), 1 + %19 = insertvalue %any undef, ptr %error_var, 0 + %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.fault" to i64), 1 store %"char[]" { ptr @.panic_msg.4, i64 36 }, ptr %taddr7, align 8 - %20 = load [2 x i64], ptr %taddr7, align 8 + %21 = load [2 x i64], ptr %taddr7, align 8 store %"char[]" { ptr @.file, i64 16 }, ptr %taddr8, align 8 - %21 = load [2 x i64], ptr %taddr8, align 8 + %22 = load [2 x i64], ptr %taddr8, align 8 store %"char[]" { ptr @.func, i64 4 }, ptr %taddr9, align 8 - %22 = load [2 x i64], ptr %taddr9, align 8 - store %any %19, ptr %varargslots, align 8 - %23 = insertvalue %"any[]" undef, ptr %varargslots, 0 - %"$$temp" = insertvalue %"any[]" %23, i64 1, 1 + %23 = load [2 x i64], ptr %taddr9, align 8 + store %any %20, ptr %varargslots, align 8 + %24 = insertvalue %"any[]" undef, ptr %varargslots, 0 + %"$$temp" = insertvalue %"any[]" %24, i64 1, 1 store %"any[]" %"$$temp", ptr %taddr10, align 8 - %24 = load [2 x i64], ptr %taddr10, align 8 - call void @std.core.builtin.panicf([2 x i64] %20, [2 x i64] %21, [2 x i64] %22 + %25 = load [2 x i64], ptr %taddr10, align 8 + call void @std.core.builtin.panicf([2 x i64] %21, [2 x i64] %22, [2 x i64] %23, i32 261, [2 x i64] %25) #4 unreachable noerr_block: ; preds = %after_check - store %"char[]" %17, ptr %buffer, align 8 + store %"char[]" %18, ptr %buffer, align 8 store i64 0, ptr %buffer.f, align 8 %optval = load i64, ptr %buffer.f, align 8 %not_err11 = icmp eq i64 %optval, 0 - %25 = call i1 @llvm.expect.i1(i1 %not_err11, i1 true) - br i1 %25, label %after_check13, label %assign_optional12 + %26 = call i1 @llvm.expect.i1(i1 %not_err11, i1 true) + br i1 %26, label %after_check13, label %assign_optional12 assign_optional12: ; preds = %noerr_block store i64 %optval, ptr %buffer.f, align 8 @@ -395,15 +396,15 @@ assign_optional12: ; preds = %noerr_block after_check13: ; preds = %noerr_block store %"char[]" { ptr @.str.5, i64 13 }, ptr %taddr15, align 8 - %26 = load [2 x i64], ptr %taddr15, align 8 - %27 = load [2 x i64], ptr %buffer, align 8 - %28 = call i64 @test.fileReader(ptr %retparam14, [2 x i64] %26, [2 x i64] %27) - %not_err16 = icmp eq i64 %28, 0 - %29 = call i1 @llvm.expect.i1(i1 %not_err16, i1 true) - br i1 %29, label %after_check18, label %assign_optional17 + %27 = load [2 x i64], ptr %taddr15, align 8 + %28 = load [2 x i64], ptr %buffer, align 8 + %29 = call i64 @test.fileReader(ptr %retparam14, [2 x i64] %27, [2 x i64] %28) + %not_err16 = icmp eq i64 %29, 0 + %30 = call i1 @llvm.expect.i1(i1 %not_err16, i1 true) + br i1 %30, label %after_check18, label %assign_optional17 assign_optional17: ; preds = %after_check13 - store i64 %28, ptr %buffer.f, align 8 + store i64 %29, ptr %buffer.f, align 8 br label %after_assign after_check18: ; preds = %after_check13 diff --git a/test/test_suite/expressions/big_incdec.c3t b/test/test_suite/expressions/big_incdec.c3t index b537d8d12..26594a8d9 100644 --- a/test/test_suite/expressions/big_incdec.c3t +++ b/test/test_suite/expressions/big_incdec.c3t @@ -27,7 +27,7 @@ entry: store ptr %0, ptr %args, align 8 %ptradd = getelementptr inbounds i8, ptr %args, i64 8 store i64 %1, ptr %ptradd, align 8 - %2 = call ptr @std.core.mem.calloc(i64 5000) #3 + %2 = call ptr @std.core.mem.calloc(i64 5000) #4 store ptr %2, ptr %x, align 8 store i32 0, ptr %i, align 4 br label %loop.cond diff --git a/test/test_suite/expressions/vector_inc_dec.c3t b/test/test_suite/expressions/vector_inc_dec.c3t index 16271dd6a..ec92759b5 100644 --- a/test/test_suite/expressions/vector_inc_dec.c3t +++ b/test/test_suite/expressions/vector_inc_dec.c3t @@ -32,7 +32,7 @@ entry: store ptr %0, ptr %args, align 8 %ptradd = getelementptr inbounds i8, ptr %args, i64 8 store i64 %1, ptr %ptradd, align 8 - %2 = call ptr @std.core.mem.calloc(i64 5000) #3 + %2 = call ptr @std.core.mem.calloc(i64 5000) #4 store ptr %2, ptr %x, align 8 %3 = load ptr, ptr %x, align 8 %4 = insertelement <1 x ptr> undef, ptr %3, i64 0 diff --git a/test/test_suite/functions/static_vars.c3t b/test/test_suite/functions/static_vars.c3t index fdb68c98c..6857d603b 100644 --- a/test/test_suite/functions/static_vars.c3t +++ b/test/test_suite/functions/static_vars.c3t @@ -15,9 +15,10 @@ fn int test() define i32 @foo.test() #0 { entry: - %0 = load i32, ptr @test.x, align 4 - %add = add i32 %0, 1 - store i32 %add, ptr @test.x, align 4 + %0 = call ptr @llvm.threadlocal.address.p0(ptr @test.y) %1 = load i32, ptr @test.x, align 4 - ret i32 %1 + %add = add i32 %1, 1 + store i32 %add, ptr @test.x, align 4 + %2 = load i32, ptr @test.x, align 4 + ret i32 %2 } \ No newline at end of file diff --git a/test/test_suite/generic/generic_lambda_complex.c3t b/test/test_suite/generic/generic_lambda_complex.c3t index e9f6fbc9a..54a5fafe3 100644 --- a/test/test_suite/generic/generic_lambda_complex.c3t +++ b/test/test_suite/generic/generic_lambda_complex.c3t @@ -180,51 +180,52 @@ entry: %indirectarg9 = alloca %"any[]", align 8 store %"char[]" { ptr @.str, i64 21 }, ptr %foo_tmpl, align 8 call void @llvm.memset.p0.i64(ptr align 8 %ft, i8 0, i64 72, i1 false) + %0 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.current_temp) %lo = load ptr, ptr %foo_tmpl, align 8 %ptradd = getelementptr inbounds i8, ptr %foo_tmpl, i64 8 %hi = load i64, ptr %ptradd, align 8 store %"char[]" { ptr @.str.2, i64 2 }, ptr %indirectarg, align 8 - %0 = call i64 @"abc$text_test.Foo$.TextTemplate.init"(ptr %ft, ptr %lo, i64 %hi, ptr @.str.1, i64 2, ptr byval(%"char[]") align 8 %indirectarg, ptr byval(%any) align 8 @std.core.mem.allocator.current_temp) - %not_err = icmp eq i64 %0, 0 - %1 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %1, label %after_check, label %assign_optional + %1 = call i64 @"abc$text_test.Foo$.TextTemplate.init"(ptr %ft, ptr %lo, i64 %hi, ptr @.str.1, i64 2, ptr byval(%"char[]") align 8 %indirectarg, ptr byval(%any) align 8 %0) + %not_err = icmp eq i64 %1, 0 + %2 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %2, label %after_check, label %assign_optional assign_optional: ; preds = %entry - store i64 %0, ptr %error_var, align 8 + store i64 %1, ptr %error_var, align 8 br label %panic_block after_check: ; preds = %entry br label %noerr_block panic_block: ; preds = %assign_optional - %2 = insertvalue %any undef, ptr %error_var, 0 - %3 = insertvalue %any %2, i64 ptrtoint (ptr @"$ct.fault" to i64), 1 - store %any %3, ptr %varargslots, align 16 - %4 = insertvalue %"any[]" undef, ptr %varargslots, 0 - %"$$temp" = insertvalue %"any[]" %4, i64 1, 1 + %3 = insertvalue %any undef, ptr %error_var, 0 + %4 = insertvalue %any %3, i64 ptrtoint (ptr @"$ct.fault" to i64), 1 + store %any %4, ptr %varargslots, align 16 + %5 = insertvalue %"any[]" undef, ptr %varargslots, 0 + %"$$temp" = insertvalue %"any[]" %5, i64 1, 1 store %"any[]" %"$$temp", ptr %indirectarg1, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg, unreachable noerr_block: ; preds = %after_check - %5 = call i64 @"abc$text_test.Foo$.TextTemplate.free"(ptr %ft) - %not_err3 = icmp eq i64 %5, 0 - %6 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true) - br i1 %6, label %after_check5, label %assign_optional4 + %6 = call i64 @"abc$text_test.Foo$.TextTemplate.free"(ptr %ft) + %not_err3 = icmp eq i64 %6, 0 + %7 = call i1 @llvm.expect.i1(i1 %not_err3, i1 true) + br i1 %7, label %after_check5, label %assign_optional4 assign_optional4: ; preds = %noerr_block - store i64 %5, ptr %error_var2, align 8 + store i64 %6, ptr %error_var2, align 8 br label %panic_block6 after_check5: ; preds = %noerr_block br label %noerr_block10 panic_block6: ; preds = %assign_optional4 - %7 = insertvalue %any undef, ptr %error_var2, 0 - %8 = insertvalue %any %7, i64 ptrtoint (ptr @"$ct.fault" to i64), 1 - store %any %8, ptr %varargslots7, align 16 - %9 = insertvalue %"any[]" undef, ptr %varargslots7, 0 - %"$$temp8" = insertvalue %"any[]" %9, i64 1, 1 + %8 = insertvalue %any undef, ptr %error_var2, 0 + %9 = insertvalue %any %8, i64 ptrtoint (ptr @"$ct.fault" to i64), 1 + store %any %9, ptr %varargslots7, align 16 + %10 = insertvalue %"any[]" undef, ptr %varargslots7, 0 + %"$$temp8" = insertvalue %"any[]" %10, i64 1, 1 store %"any[]" %"$$temp8", ptr %indirectarg9, align 8 call void @std.core.builtin.panicf(ptr @.panic_msg, i64 36, unreachable diff --git a/test/test_suite/slices/subscript_check_1519.c3t b/test/test_suite/slices/subscript_check_1519.c3t index 9fcdb695e..05a4a02a3 100644 --- a/test/test_suite/slices/subscript_check_1519.c3t +++ b/test/test_suite/slices/subscript_check_1519.c3t @@ -27,11 +27,13 @@ entry: store ptr %0, ptr %args, align 8 %ptradd = getelementptr inbounds i8, ptr %args, i64 8 store i64 %1, ptr %ptradd, align 8 - %lo = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %2 = call ptr @std.core.dstring.new(i64 %lo, ptr %hi, ptr @.str, i64 4) - store ptr %2, ptr %str, align 8 - %3 = load ptr, ptr %str, align 8 - store ptr %3, ptr %a, align 8 + %2 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo = load i64, ptr %2, align 8 + %ptradd1 = getelementptr inbounds i8, ptr %2, i64 8 + %hi = load ptr, ptr %ptradd1, align 8 + %3 = call ptr @std.core.dstring.new(i64 %lo, ptr %hi, ptr @.str, i64 4) + store ptr %3, ptr %str, align 8 + %4 = load ptr, ptr %str, align 8 + store ptr %4, ptr %a, align 8 ret i32 0 } \ No newline at end of file diff --git a/test/test_suite/stdlib/map_linux.c3t b/test/test_suite/stdlib/map_linux.c3t index b987bf525..5f9a6db71 100644 --- a/test/test_suite/stdlib/map_linux.c3t +++ b/test/test_suite/stdlib/map_linux.c3t @@ -92,163 +92,177 @@ entry: %varargslots = alloca [1 x %any], align 16 %retparam = alloca i64, align 8 %literal = alloca %Foo, align 8 - %varargslots4 = alloca [1 x %any], align 16 - %retparam6 = alloca i64, align 8 - %literal7 = alloca %Foo, align 8 - %varargslots11 = alloca [1 x %any], align 16 - %retparam13 = alloca i64, align 8 - %varargslots14 = alloca [1 x %any], align 16 - %retparam15 = alloca %Foo, align 8 - %retparam16 = alloca i64, align 8 - %varargslots19 = alloca [1 x %any], align 16 + %varargslots5 = alloca [1 x %any], align 16 + %retparam7 = alloca i64, align 8 + %literal8 = alloca %Foo, align 8 + %varargslots12 = alloca [1 x %any], align 16 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [1 x %any], align 16 + %retparam16 = alloca %Foo, align 8 + %retparam17 = alloca i64, align 8 + %varargslots20 = alloca [1 x %any], align 16 %taddr = alloca i8, align 1 - %retparam20 = alloca i64, align 8 - %varargslots23 = alloca [1 x %any], align 16 - %taddr24 = alloca i8, align 1 - %retparam25 = alloca i64, align 8 - %literal28 = alloca %Foo, align 8 - %varargslots32 = alloca [1 x %any], align 16 + %retparam21 = alloca i64, align 8 + %varargslots24 = alloca [1 x %any], align 16 + %taddr25 = alloca i8, align 1 + %retparam26 = alloca i64, align 8 + %literal29 = alloca %Foo, align 8 + %varargslots33 = alloca [1 x %any], align 16 %result = alloca %"Foo[]", align 8 - %retparam35 = alloca i64, align 8 + %retparam37 = alloca i64, align 8 %map2 = alloca %HashMap.0, align 8 - %varargslots40 = alloca [1 x %any], align 16 - %taddr41 = alloca i8, align 1 - %retparam42 = alloca i64, align 8 - %varargslots45 = alloca [1 x %any], align 16 - %taddr46 = alloca i8, align 1 - %retparam47 = alloca i64, align 8 - %varargslots50 = alloca [1 x %any], align 16 - %result53 = alloca %"int[]", align 8 - %retparam54 = alloca i64, align 8 - %varargslots57 = alloca [1 x %any], align 16 - %result60 = alloca %"double[]", align 8 - %retparam61 = alloca i64, align 8 + %varargslots43 = alloca [1 x %any], align 16 + %taddr44 = alloca i8, align 1 + %retparam45 = alloca i64, align 8 + %varargslots48 = alloca [1 x %any], align 16 + %taddr49 = alloca i8, align 1 + %retparam50 = alloca i64, align 8 + %varargslots53 = alloca [1 x %any], align 16 + %result57 = alloca %"int[]", align 8 + %retparam58 = alloca i64, align 8 + %varargslots61 = alloca [1 x %any], align 16 + %result65 = alloca %"double[]", align 8 + %retparam66 = alloca i64, align 8 %state = alloca ptr, align 8 %map3 = alloca %HashMap.0, align 8 - %varargslots66 = alloca [1 x %any], align 16 - %result69 = alloca %"int[]", align 8 - %retparam70 = alloca i64, align 8 + %varargslots72 = alloca [1 x %any], align 16 + %result76 = alloca %"int[]", align 8 + %retparam77 = alloca i64, align 8 call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false) - %lo = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %0 = call ptr @"std_collections_map$int$test.Foo$.HashMap.init"(ptr %map, i64 %lo, ptr %hi, i32 16, float 7.500000e-01) - %ptradd = getelementptr inbounds i8, ptr %map, i64 32 - %1 = insertvalue %any undef, ptr %ptradd, 0 - %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - store %any %2, ptr %varargslots, align 16 - %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1) + %0 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo = load i64, ptr %0, align 8 + %ptradd = getelementptr inbounds i8, ptr %0, i64 8 + %hi = load ptr, ptr %ptradd, align 8 + %1 = call ptr @"std_collections_map$int$test.Foo$.HashMap.init"(ptr %map, i64 %lo, ptr %hi, i32 16, float 7.500000e-01) + %ptradd1 = getelementptr inbounds i8, ptr %map, i64 32 + %2 = insertvalue %any undef, ptr %ptradd1, 0 + %3 = insertvalue %any %2, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 + store %any %3, ptr %varargslots, align 16 + %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false) - %lo1 = load i32, ptr %literal, align 8 - %ptradd2 = getelementptr inbounds i8, ptr %literal, i64 8 - %hi3 = load ptr, ptr %ptradd2, align 8 - %4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo1, ptr %hi3) - %ptradd5 = getelementptr inbounds i8, ptr %map, i64 32 - %5 = insertvalue %any undef, ptr %ptradd5, 0 - %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - store %any %6, ptr %varargslots4, align 16 - %7 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.1, i64 12, ptr %varargslots4, i64 1) - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal7, ptr align 8 @.__const.2, i32 16, i1 false) - %lo8 = load i32, ptr %literal7, align 8 - %ptradd9 = getelementptr inbounds i8, ptr %literal7, i64 8 - %hi10 = load ptr, ptr %ptradd9, align 8 - %8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo8, ptr %hi10) - %ptradd12 = getelementptr inbounds i8, ptr %map, i64 32 - %9 = insertvalue %any undef, ptr %ptradd12, 0 - %10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - store %any %10, ptr %varargslots11, align 16 - %11 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.3, i64 12, ptr %varargslots11, i64 1) - %12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam15, ptr %map, i32 1) - %not_err = icmp eq i64 %12, 0 - %13 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %13, label %after_check, label %after_check18 + %lo2 = load i32, ptr %literal, align 8 + %ptradd3 = getelementptr inbounds i8, ptr %literal, i64 8 + %hi4 = load ptr, ptr %ptradd3, align 8 + %5 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo2, ptr %hi4) + %ptradd6 = getelementptr inbounds i8, ptr %map, i64 32 + %6 = insertvalue %any undef, ptr %ptradd6, 0 + %7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 + store %any %7, ptr %varargslots5, align 16 + %8 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 12, ptr %varargslots5, i64 1) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal8, ptr align 8 @.__const.2, i32 16, i1 false) + %lo9 = load i32, ptr %literal8, align 8 + %ptradd10 = getelementptr inbounds i8, ptr %literal8, i64 8 + %hi11 = load ptr, ptr %ptradd10, align 8 + %9 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo9, ptr %hi11) + %ptradd13 = getelementptr inbounds i8, ptr %map, i64 32 + %10 = insertvalue %any undef, ptr %ptradd13, 0 + %11 = insertvalue %any %10, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 + store %any %11, ptr %varargslots12, align 16 + %12 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.3, i64 12, ptr %varargslots12, i64 1) + %13 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam16, ptr %map, i32 1) + %not_err = icmp eq i64 %13, 0 + %14 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %14, label %after_check, label %after_check19 after_check: ; preds = %entry - %14 = insertvalue %any undef, ptr %retparam15, 0 - %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %15, ptr %varargslots14, align 16 - %16 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.4, i64 7, ptr %varargslots14, i64 1) - %not_err17 = icmp eq i64 %16, 0 - %17 = call i1 @llvm.expect.i1(i1 %not_err17, i1 true) - br i1 %17, label %after_check18, label %after_check18 + %15 = insertvalue %any undef, ptr %retparam16, 0 + %16 = insertvalue %any %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %16, ptr %varargslots15, align 16 + %17 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 7, ptr %varargslots15, i64 1) + %not_err18 = icmp eq i64 %17, 0 + %18 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true) + br i1 %18, label %after_check19, label %after_check19 -after_check18: ; preds = %entry, %after_check, %after_check - %18 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1) - store i8 %18, ptr %taddr, align 1 - %19 = insertvalue %any undef, ptr %taddr, 0 - %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %20, ptr %varargslots19, align 16 - %21 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.5, i64 9, ptr %varargslots19, i64 1) - %22 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2) - store i8 %22, ptr %taddr24, align 1 - %23 = insertvalue %any undef, ptr %taddr24, 0 - %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %24, ptr %varargslots23, align 16 - %25 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 9, ptr %varargslots23, i64 1) - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal28, ptr align 8 @.__const.7, i32 16, i1 false) - %lo29 = load i32, ptr %literal28, align 8 - %ptradd30 = getelementptr inbounds i8, ptr %literal28, i64 8 - %hi31 = load ptr, ptr %ptradd30, align 8 - %26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo29, ptr %hi31) - %lo33 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi34 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.values"(ptr %map, i64 %lo33, ptr %hi34) - store { ptr, i64 } %27, ptr %result, align 8 - %28 = insertvalue %any undef, ptr %result, 0 - %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1 - store %any %29, ptr %varargslots32, align 16 - %30 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.8, i64 10, ptr %varargslots32, i64 1) +after_check19: ; preds = %entry, %after_check, %after_check + %19 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1) + store i8 %19, ptr %taddr, align 1 + %20 = insertvalue %any undef, ptr %taddr, 0 + %21 = insertvalue %any %20, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %21, ptr %varargslots20, align 16 + %22 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.5, i64 9, ptr %varargslots20, i64 1) + %23 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2) + store i8 %23, ptr %taddr25, align 1 + %24 = insertvalue %any undef, ptr %taddr25, 0 + %25 = insertvalue %any %24, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %25, ptr %varargslots24, align 16 + %26 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.6, i64 9, ptr %varargslots24, i64 1) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal29, ptr align 8 @.__const.7, i32 16, i1 false) + %lo30 = load i32, ptr %literal29, align 8 + %ptradd31 = getelementptr inbounds i8, ptr %literal29, i64 8 + %hi32 = load ptr, ptr %ptradd31, align 8 + %27 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo30, ptr %hi32) + %28 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo34 = load i64, ptr %28, align 8 + %ptradd35 = getelementptr inbounds i8, ptr %28, i64 8 + %hi36 = load ptr, ptr %ptradd35, align 8 + %29 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.values"(ptr %map, i64 %lo34, ptr %hi36) + store { ptr, i64 } %29, ptr %result, align 8 + %30 = insertvalue %any undef, ptr %result, 0 + %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1 + store %any %31, ptr %varargslots33, align 16 + %32 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.8, i64 10, ptr %varargslots33, i64 1) call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false) - %lo38 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi39 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %31 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map2, i64 %lo38, ptr %hi39, i32 16, float 7.500000e-01) - %32 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00) - %33 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00) - store i8 %33, ptr %taddr41, align 1 - %34 = insertvalue %any undef, ptr %taddr41, 0 - %35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %35, ptr %varargslots40, align 16 - %36 = call i64 @std.io.printfn(ptr %retparam42, ptr @.str.9, i64 12, ptr %varargslots40, i64 1) - %37 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00) - store i8 %37, ptr %taddr46, align 1 - %38 = insertvalue %any undef, ptr %taddr46, 0 - %39 = insertvalue %any %38, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %39, ptr %varargslots45, align 16 - %40 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.10, i64 12, ptr %varargslots45, i64 1) - %41 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00) - %lo51 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi52 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map2, i64 %lo51, ptr %hi52) - store { ptr, i64 } %42, ptr %result53, align 8 - %43 = insertvalue %any undef, ptr %result53, 0 - %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 - store %any %44, ptr %varargslots50, align 16 - %45 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.11, i64 2, ptr %varargslots50, i64 1) - %lo58 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi59 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.values"(ptr %map2, i64 %lo58, ptr %hi59) - store { ptr, i64 } %46, ptr %result60, align 8 - %47 = insertvalue %any undef, ptr %result60, 0 - %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1 - store %any %48, ptr %varargslots57, align 16 - %49 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.12, i64 2, ptr %varargslots57, i64 1) - %50 = call ptr @std.core.mem.allocator.push_pool(i64 0) #4 - store ptr %50, ptr %state, align 8 + %33 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo40 = load i64, ptr %33, align 8 + %ptradd41 = getelementptr inbounds i8, ptr %33, i64 8 + %hi42 = load ptr, ptr %ptradd41, align 8 + %34 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map2, i64 %lo40, ptr %hi42, i32 16, float 7.500000e-01) + %35 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00) + %36 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00) + store i8 %36, ptr %taddr44, align 1 + %37 = insertvalue %any undef, ptr %taddr44, 0 + %38 = insertvalue %any %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %38, ptr %varargslots43, align 16 + %39 = call i64 @std.io.printfn(ptr %retparam45, ptr @.str.9, i64 12, ptr %varargslots43, i64 1) + %40 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00) + store i8 %40, ptr %taddr49, align 1 + %41 = insertvalue %any undef, ptr %taddr49, 0 + %42 = insertvalue %any %41, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %42, ptr %varargslots48, align 16 + %43 = call i64 @std.io.printfn(ptr %retparam50, ptr @.str.10, i64 12, ptr %varargslots48, i64 1) + %44 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00) + %45 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo54 = load i64, ptr %45, align 8 + %ptradd55 = getelementptr inbounds i8, ptr %45, i64 8 + %hi56 = load ptr, ptr %ptradd55, align 8 + %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map2, i64 %lo54, ptr %hi56) + store { ptr, i64 } %46, ptr %result57, align 8 + %47 = insertvalue %any undef, ptr %result57, 0 + %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 + store %any %48, ptr %varargslots53, align 16 + %49 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.11, i64 2, ptr %varargslots53, i64 1) + %50 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo62 = load i64, ptr %50, align 8 + %ptradd63 = getelementptr inbounds i8, ptr %50, i64 8 + %hi64 = load ptr, ptr %ptradd63, align 8 + %51 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.values"(ptr %map2, i64 %lo62, ptr %hi64) + store { ptr, i64 } %51, ptr %result65, align 8 + %52 = insertvalue %any undef, ptr %result65, 0 + %53 = insertvalue %any %52, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1 + store %any %53, ptr %varargslots61, align 16 + %54 = call i64 @std.io.printfn(ptr %retparam66, ptr @.str.12, i64 2, ptr %varargslots61, i64 1) + %55 = call ptr @std.core.mem.allocator.push_pool(i64 0) #5 + store ptr %55, ptr %state, align 8 call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false) - %lo64 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi65 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %51 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map3, i64 %lo64, ptr %hi65, i32 16, float 7.500000e-01) - %52 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00) - %53 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00) - %lo67 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi68 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %54 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map3, i64 %lo67, ptr %hi68) - store { ptr, i64 } %54, ptr %result69, align 8 - %55 = insertvalue %any undef, ptr %result69, 0 - %56 = insertvalue %any %55, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 - store %any %56, ptr %varargslots66, align 16 - %57 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.13, i64 2, ptr %varargslots66, i64 1) - %58 = load ptr, ptr %state, align 8 - call void @std.core.mem.allocator.pop_pool(ptr %58) #4 + %56 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo69 = load i64, ptr %56, align 8 + %ptradd70 = getelementptr inbounds i8, ptr %56, i64 8 + %hi71 = load ptr, ptr %ptradd70, align 8 + %57 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map3, i64 %lo69, ptr %hi71, i32 16, float 7.500000e-01) + %58 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00) + %59 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00) + %60 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo73 = load i64, ptr %60, align 8 + %ptradd74 = getelementptr inbounds i8, ptr %60, i64 8 + %hi75 = load ptr, ptr %ptradd74, align 8 + %61 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map3, i64 %lo73, ptr %hi75) + store { ptr, i64 } %61, ptr %result76, align 8 + %62 = insertvalue %any undef, ptr %result76, 0 + %63 = insertvalue %any %62, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 + store %any %63, ptr %varargslots72, align 16 + %64 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.13, i64 2, ptr %varargslots72, i64 1) + %65 = load ptr, ptr %state, align 8 + call void @std.core.mem.allocator.pop_pool(ptr %65) #5 ret void } diff --git a/test/test_suite/stdlib/map_macos.c3t b/test/test_suite/stdlib/map_macos.c3t index e16ea24de..f4bc05e48 100644 --- a/test/test_suite/stdlib/map_macos.c3t +++ b/test/test_suite/stdlib/map_macos.c3t @@ -92,162 +92,176 @@ entry: %varargslots = alloca [1 x %any], align 16 %retparam = alloca i64, align 8 %literal = alloca %Foo, align 8 - %varargslots4 = alloca [1 x %any], align 16 - %retparam6 = alloca i64, align 8 - %literal7 = alloca %Foo, align 8 - %varargslots11 = alloca [1 x %any], align 16 - %retparam13 = alloca i64, align 8 - %varargslots14 = alloca [1 x %any], align 16 - %retparam15 = alloca %Foo, align 8 - %retparam16 = alloca i64, align 8 - %varargslots19 = alloca [1 x %any], align 16 + %varargslots5 = alloca [1 x %any], align 16 + %retparam7 = alloca i64, align 8 + %literal8 = alloca %Foo, align 8 + %varargslots12 = alloca [1 x %any], align 16 + %retparam14 = alloca i64, align 8 + %varargslots15 = alloca [1 x %any], align 16 + %retparam16 = alloca %Foo, align 8 + %retparam17 = alloca i64, align 8 + %varargslots20 = alloca [1 x %any], align 16 %taddr = alloca i8, align 1 - %retparam20 = alloca i64, align 8 - %varargslots23 = alloca [1 x %any], align 16 - %taddr24 = alloca i8, align 1 - %retparam25 = alloca i64, align 8 - %literal28 = alloca %Foo, align 8 - %varargslots32 = alloca [1 x %any], align 16 + %retparam21 = alloca i64, align 8 + %varargslots24 = alloca [1 x %any], align 16 + %taddr25 = alloca i8, align 1 + %retparam26 = alloca i64, align 8 + %literal29 = alloca %Foo, align 8 + %varargslots33 = alloca [1 x %any], align 16 %result = alloca %"Foo[]", align 8 - %retparam35 = alloca i64, align 8 + %retparam37 = alloca i64, align 8 %map2 = alloca %HashMap.0, align 8 - %varargslots40 = alloca [1 x %any], align 16 - %taddr41 = alloca i8, align 1 - %retparam42 = alloca i64, align 8 - %varargslots45 = alloca [1 x %any], align 16 - %taddr46 = alloca i8, align 1 - %retparam47 = alloca i64, align 8 - %varargslots50 = alloca [1 x %any], align 16 - %result53 = alloca %"int[]", align 8 - %retparam54 = alloca i64, align 8 - %varargslots57 = alloca [1 x %any], align 16 - %result60 = alloca %"double[]", align 8 - %retparam61 = alloca i64, align 8 + %varargslots43 = alloca [1 x %any], align 16 + %taddr44 = alloca i8, align 1 + %retparam45 = alloca i64, align 8 + %varargslots48 = alloca [1 x %any], align 16 + %taddr49 = alloca i8, align 1 + %retparam50 = alloca i64, align 8 + %varargslots53 = alloca [1 x %any], align 16 + %result57 = alloca %"int[]", align 8 + %retparam58 = alloca i64, align 8 + %varargslots61 = alloca [1 x %any], align 16 + %result65 = alloca %"double[]", align 8 + %retparam66 = alloca i64, align 8 %state = alloca ptr, align 8 %map3 = alloca %HashMap.0, align 8 - %varargslots66 = alloca [1 x %any], align 16 - %result69 = alloca %"int[]", align 8 - %retparam70 = alloca i64, align 8 + %varargslots72 = alloca [1 x %any], align 16 + %result76 = alloca %"int[]", align 8 + %retparam77 = alloca i64, align 8 call void @llvm.memset.p0.i64(ptr align 8 %map, i8 0, i64 48, i1 false) - %lo = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %0 = call ptr @"std_collections_map$int$test.Foo$.HashMap.init"(ptr %map, i64 %lo, ptr %hi, i32 16, float 7.500000e-01) - %ptradd = getelementptr inbounds i8, ptr %map, i64 32 - %1 = insertvalue %any undef, ptr %ptradd, 0 - %2 = insertvalue %any %1, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - store %any %2, ptr %varargslots, align 16 - %3 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1) + %0 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo = load i64, ptr %0, align 8 + %ptradd = getelementptr inbounds i8, ptr %0, i64 8 + %hi = load ptr, ptr %ptradd, align 8 + %1 = call ptr @"std_collections_map$int$test.Foo$.HashMap.init"(ptr %map, i64 %lo, ptr %hi, i32 16, float 7.500000e-01) + %ptradd1 = getelementptr inbounds i8, ptr %map, i64 32 + %2 = insertvalue %any undef, ptr %ptradd1, 0 + %3 = insertvalue %any %2, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 + store %any %3, ptr %varargslots, align 16 + %4 = call i64 @std.io.printfn(ptr %retparam, ptr @.str, i64 12, ptr %varargslots, i64 1) call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal, ptr align 8 @.__const, i32 16, i1 false) - %lo1 = load i32, ptr %literal, align 8 - %ptradd2 = getelementptr inbounds i8, ptr %literal, i64 8 - %hi3 = load ptr, ptr %ptradd2, align 8 - %4 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo1, ptr %hi3) - %ptradd5 = getelementptr inbounds i8, ptr %map, i64 32 - %5 = insertvalue %any undef, ptr %ptradd5, 0 - %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - store %any %6, ptr %varargslots4, align 16 - %7 = call i64 @std.io.printfn(ptr %retparam6, ptr @.str.1, i64 12, ptr %varargslots4, i64 1) - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal7, ptr align 8 @.__const.2, i32 16, i1 false) - %lo8 = load i32, ptr %literal7, align 8 - %ptradd9 = getelementptr inbounds i8, ptr %literal7, i64 8 - %hi10 = load ptr, ptr %ptradd9, align 8 - %8 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo8, ptr %hi10) - %ptradd12 = getelementptr inbounds i8, ptr %map, i64 32 - %9 = insertvalue %any undef, ptr %ptradd12, 0 - %10 = insertvalue %any %9, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 - store %any %10, ptr %varargslots11, align 16 - %11 = call i64 @std.io.printfn(ptr %retparam13, ptr @.str.3, i64 12, ptr %varargslots11, i64 1) - %12 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam15, ptr %map, i32 1) - %not_err = icmp eq i64 %12, 0 - %13 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %13, label %after_check, label %after_check18 + %lo2 = load i32, ptr %literal, align 8 + %ptradd3 = getelementptr inbounds i8, ptr %literal, i64 8 + %hi4 = load ptr, ptr %ptradd3, align 8 + %5 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo2, ptr %hi4) + %ptradd6 = getelementptr inbounds i8, ptr %map, i64 32 + %6 = insertvalue %any undef, ptr %ptradd6, 0 + %7 = insertvalue %any %6, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 + store %any %7, ptr %varargslots5, align 16 + %8 = call i64 @std.io.printfn(ptr %retparam7, ptr @.str.1, i64 12, ptr %varargslots5, i64 1) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal8, ptr align 8 @.__const.2, i32 16, i1 false) + %lo9 = load i32, ptr %literal8, align 8 + %ptradd10 = getelementptr inbounds i8, ptr %literal8, i64 8 + %hi11 = load ptr, ptr %ptradd10, align 8 + %9 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 1, i32 %lo9, ptr %hi11) + %ptradd13 = getelementptr inbounds i8, ptr %map, i64 32 + %10 = insertvalue %any undef, ptr %ptradd13, 0 + %11 = insertvalue %any %10, i64 ptrtoint (ptr @"$ct.uint" to i64), 1 + store %any %11, ptr %varargslots12, align 16 + %12 = call i64 @std.io.printfn(ptr %retparam14, ptr @.str.3, i64 12, ptr %varargslots12, i64 1) + %13 = call i64 @"std_collections_map$int$test.Foo$.HashMap.get"(ptr %retparam16, ptr %map, i32 1) + %not_err = icmp eq i64 %13, 0 + %14 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %14, label %after_check, label %after_check19 after_check: ; preds = %entry - %14 = insertvalue %any undef, ptr %retparam15, 0 - %15 = insertvalue %any %14, i64 ptrtoint (ptr @"$ct.int" to i64), 1 - store %any %15, ptr %varargslots14, align 16 - %16 = call i64 @std.io.printfn(ptr %retparam16, ptr @.str.4, i64 7, ptr %varargslots14, i64 1) - %not_err17 = icmp eq i64 %16, 0 - %17 = call i1 @llvm.expect.i1(i1 %not_err17, i1 true) - br i1 %17, label %after_check18, label %after_check18 + %15 = insertvalue %any undef, ptr %retparam16, 0 + %16 = insertvalue %any %15, i64 ptrtoint (ptr @"$ct.int" to i64), 1 + store %any %16, ptr %varargslots15, align 16 + %17 = call i64 @std.io.printfn(ptr %retparam17, ptr @.str.4, i64 7, ptr %varargslots15, i64 1) + %not_err18 = icmp eq i64 %17, 0 + %18 = call i1 @llvm.expect.i1(i1 %not_err18, i1 true) + br i1 %18, label %after_check19, label %after_check19 -after_check18: ; preds = %entry, %after_check, %after_check - %18 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1) - store i8 %18, ptr %taddr, align 1 - %19 = insertvalue %any undef, ptr %taddr, 0 - %20 = insertvalue %any %19, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %20, ptr %varargslots19, align 16 - %21 = call i64 @std.io.printfn(ptr %retparam20, ptr @.str.5, i64 9, ptr %varargslots19, i64 1) - %22 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2) - store i8 %22, ptr %taddr24, align 1 - %23 = insertvalue %any undef, ptr %taddr24, 0 - %24 = insertvalue %any %23, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %24, ptr %varargslots23, align 16 - %25 = call i64 @std.io.printfn(ptr %retparam25, ptr @.str.6, i64 9, ptr %varargslots23, i64 1) - call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal28, ptr align 8 @.__const.7, i32 16, i1 false) - %lo29 = load i32, ptr %literal28, align 8 - %ptradd30 = getelementptr inbounds i8, ptr %literal28, i64 8 - %hi31 = load ptr, ptr %ptradd30, align 8 - %26 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo29, ptr %hi31) - %lo33 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi34 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %27 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.values"(ptr %map, i64 %lo33, ptr %hi34) - store { ptr, i64 } %27, ptr %result, align 8 - %28 = insertvalue %any undef, ptr %result, 0 - %29 = insertvalue %any %28, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1 - store %any %29, ptr %varargslots32, align 16 - %30 = call i64 @std.io.printfn(ptr %retparam35, ptr @.str.8, i64 10, ptr %varargslots32, i64 1) +after_check19: ; preds = %entry, %after_check, %after_check + %19 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 1) + store i8 %19, ptr %taddr, align 1 + %20 = insertvalue %any undef, ptr %taddr, 0 + %21 = insertvalue %any %20, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %21, ptr %varargslots20, align 16 + %22 = call i64 @std.io.printfn(ptr %retparam21, ptr @.str.5, i64 9, ptr %varargslots20, i64 1) + %23 = call i8 @"std_collections_map$int$test.Foo$.HashMap.has_key"(ptr %map, i32 2) + store i8 %23, ptr %taddr25, align 1 + %24 = insertvalue %any undef, ptr %taddr25, 0 + %25 = insertvalue %any %24, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %25, ptr %varargslots24, align 16 + %26 = call i64 @std.io.printfn(ptr %retparam26, ptr @.str.6, i64 9, ptr %varargslots24, i64 1) + call void @llvm.memcpy.p0.p0.i32(ptr align 8 %literal29, ptr align 8 @.__const.7, i32 16, i1 false) + %lo30 = load i32, ptr %literal29, align 8 + %ptradd31 = getelementptr inbounds i8, ptr %literal29, i64 8 + %hi32 = load ptr, ptr %ptradd31, align 8 + %27 = call i8 @"std_collections_map$int$test.Foo$.HashMap.set"(ptr %map, i32 7, i32 %lo30, ptr %hi32) + %28 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo34 = load i64, ptr %28, align 8 + %ptradd35 = getelementptr inbounds i8, ptr %28, i64 8 + %hi36 = load ptr, ptr %ptradd35, align 8 + %29 = call { ptr, i64 } @"std_collections_map$int$test.Foo$.HashMap.values"(ptr %map, i64 %lo34, ptr %hi36) + store { ptr, i64 } %29, ptr %result, align 8 + %30 = insertvalue %any undef, ptr %result, 0 + %31 = insertvalue %any %30, i64 ptrtoint (ptr @"$ct.sa$test.Foo" to i64), 1 + store %any %31, ptr %varargslots33, align 16 + %32 = call i64 @std.io.printfn(ptr %retparam37, ptr @.str.8, i64 10, ptr %varargslots33, i64 1) call void @llvm.memset.p0.i64(ptr align 8 %map2, i8 0, i64 48, i1 false) - %lo38 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi39 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %31 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map2, i64 %lo38, ptr %hi39, i32 16, float 7.500000e-01) - %32 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00) - %33 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00) - store i8 %33, ptr %taddr41, align 1 - %34 = insertvalue %any undef, ptr %taddr41, 0 - %35 = insertvalue %any %34, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %35, ptr %varargslots40, align 16 - %36 = call i64 @std.io.printfn(ptr %retparam42, ptr @.str.9, i64 12, ptr %varargslots40, i64 1) - %37 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00) - store i8 %37, ptr %taddr46, align 1 - %38 = insertvalue %any undef, ptr %taddr46, 0 - %39 = insertvalue %any %38, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 - store %any %39, ptr %varargslots45, align 16 - %40 = call i64 @std.io.printfn(ptr %retparam47, ptr @.str.10, i64 12, ptr %varargslots45, i64 1) - %41 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00) - %lo51 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi52 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %42 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map2, i64 %lo51, ptr %hi52) - store { ptr, i64 } %42, ptr %result53, align 8 - %43 = insertvalue %any undef, ptr %result53, 0 - %44 = insertvalue %any %43, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 - store %any %44, ptr %varargslots50, align 16 - %45 = call i64 @std.io.printfn(ptr %retparam54, ptr @.str.11, i64 2, ptr %varargslots50, i64 1) - %lo58 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi59 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.values"(ptr %map2, i64 %lo58, ptr %hi59) - store { ptr, i64 } %46, ptr %result60, align 8 - %47 = insertvalue %any undef, ptr %result60, 0 - %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1 - store %any %48, ptr %varargslots57, align 16 - %49 = call i64 @std.io.printfn(ptr %retparam61, ptr @.str.12, i64 2, ptr %varargslots57, i64 1) - %50 = call ptr @std.core.mem.allocator.push_pool(i64 0) #4 - store ptr %50, ptr %state, align 8 + %33 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo40 = load i64, ptr %33, align 8 + %ptradd41 = getelementptr inbounds i8, ptr %33, i64 8 + %hi42 = load ptr, ptr %ptradd41, align 8 + %34 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map2, i64 %lo40, ptr %hi42, i32 16, float 7.500000e-01) + %35 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 4, double 1.300000e+00) + %36 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.300000e+00) + store i8 %36, ptr %taddr44, align 1 + %37 = insertvalue %any undef, ptr %taddr44, 0 + %38 = insertvalue %any %37, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %38, ptr %varargslots43, align 16 + %39 = call i64 @std.io.printfn(ptr %retparam45, ptr @.str.9, i64 12, ptr %varargslots43, i64 1) + %40 = call i8 @"std_collections_map$int$double$.HashMap.has_value"(ptr %map2, double 1.200000e+00) + store i8 %40, ptr %taddr49, align 1 + %41 = insertvalue %any undef, ptr %taddr49, 0 + %42 = insertvalue %any %41, i64 ptrtoint (ptr @"$ct.bool" to i64), 1 + store %any %42, ptr %varargslots48, align 16 + %43 = call i64 @std.io.printfn(ptr %retparam50, ptr @.str.10, i64 12, ptr %varargslots48, i64 1) + %44 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map2, i32 100, double 3.400000e+00) + %45 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo54 = load i64, ptr %45, align 8 + %ptradd55 = getelementptr inbounds i8, ptr %45, i64 8 + %hi56 = load ptr, ptr %ptradd55, align 8 + %46 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map2, i64 %lo54, ptr %hi56) + store { ptr, i64 } %46, ptr %result57, align 8 + %47 = insertvalue %any undef, ptr %result57, 0 + %48 = insertvalue %any %47, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 + store %any %48, ptr %varargslots53, align 16 + %49 = call i64 @std.io.printfn(ptr %retparam58, ptr @.str.11, i64 2, ptr %varargslots53, i64 1) + %50 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo62 = load i64, ptr %50, align 8 + %ptradd63 = getelementptr inbounds i8, ptr %50, i64 8 + %hi64 = load ptr, ptr %ptradd63, align 8 + %51 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.values"(ptr %map2, i64 %lo62, ptr %hi64) + store { ptr, i64 } %51, ptr %result65, align 8 + %52 = insertvalue %any undef, ptr %result65, 0 + %53 = insertvalue %any %52, i64 ptrtoint (ptr @"$ct.sa$double" to i64), 1 + store %any %53, ptr %varargslots61, align 16 + %54 = call i64 @std.io.printfn(ptr %retparam66, ptr @.str.12, i64 2, ptr %varargslots61, i64 1) + %55 = call ptr @std.core.mem.allocator.push_pool(i64 0) #5 + store ptr %55, ptr %state, align 8 call void @llvm.memset.p0.i64(ptr align 8 %map3, i8 0, i64 48, i1 false) - %lo64 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi65 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %51 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map3, i64 %lo64, ptr %hi65, i32 16, float 7.500000e-01) - %52 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00) - %53 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00) - %lo67 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi68 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %54 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map3, i64 %lo67, ptr %hi68) - store { ptr, i64 } %54, ptr %result69, align 8 - %55 = insertvalue %any undef, ptr %result69, 0 - %56 = insertvalue %any %55, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 - store %any %56, ptr %varargslots66, align 16 - %57 = call i64 @std.io.printfn(ptr %retparam70, ptr @.str.13, i64 2, ptr %varargslots66, i64 1) - %58 = load ptr, ptr %state, align 8 - call void @std.core.mem.allocator.pop_pool(ptr %58) #4 + %56 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo69 = load i64, ptr %56, align 8 + %ptradd70 = getelementptr inbounds i8, ptr %56, i64 8 + %hi71 = load ptr, ptr %ptradd70, align 8 + %57 = call ptr @"std_collections_map$int$double$.HashMap.init"(ptr %map3, i64 %lo69, ptr %hi71, i32 16, float 7.500000e-01) + %58 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 5, double 3.200000e+00) + %59 = call i8 @"std_collections_map$int$double$.HashMap.set"(ptr %map3, i32 7, double 5.200000e+00) + %60 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) + %lo73 = load i64, ptr %60, align 8 + %ptradd74 = getelementptr inbounds i8, ptr %60, i64 8 + %hi75 = load ptr, ptr %ptradd74, align 8 + %61 = call { ptr, i64 } @"std_collections_map$int$double$.HashMap.keys"(ptr %map3, i64 %lo73, ptr %hi75) + store { ptr, i64 } %61, ptr %result76, align 8 + %62 = insertvalue %any undef, ptr %result76, 0 + %63 = insertvalue %any %62, i64 ptrtoint (ptr @"$ct.sa$int" to i64), 1 + store %any %63, ptr %varargslots72, align 16 + %64 = call i64 @std.io.printfn(ptr %retparam77, ptr @.str.13, i64 2, ptr %varargslots72, i64 1) + %65 = load ptr, ptr %state, align 8 + call void @std.core.mem.allocator.pop_pool(ptr %65) #5 ret void } \ No newline at end of file diff --git a/test/test_suite/switch/switch_in_defer_macro.c3t b/test/test_suite/switch/switch_in_defer_macro.c3t index acea76d33..14da8b8ae 100644 --- a/test/test_suite/switch/switch_in_defer_macro.c3t +++ b/test/test_suite/switch/switch_in_defer_macro.c3t @@ -700,7 +700,6 @@ fn void test() @"$ct.std.io.ByteReader" = linkonce global %.introspect { i8 10, i64 0, ptr null, i64 24, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8 @std.core.mem.allocator.thread_allocator = extern_weak thread_local global %any, align 8 -; Function Attrs: define zeroext i8 @lexer_test.is_ident_char(i64 %0, i8 zeroext %1) #0 { entry: %eq = icmp eq i64 0, %0 @@ -755,7 +754,7 @@ entry: %error_var = alloca i64, align 8 %taddr = alloca %any, align 8 %kind = alloca i8, align 1 - %error_var7 = alloca i64, align 8 + %error_var8 = alloca i64, align 8 %retparam = alloca i8, align 1 store %"UintTest[]" zeroinitializer, ptr %tcases, align 8 %ptradd = getelementptr inbounds i8, ptr %tcases, i64 8 @@ -763,7 +762,7 @@ entry: store i64 0, ptr %.anon, align 8 br label %loop.cond -loop.cond: ; preds = %noerr_block12, %entry +loop.cond: ; preds = %noerr_block13, %entry %1 = load i64, ptr %.anon, align 8 %lt = icmp ult i64 %1, %0 br i1 %lt, label %loop.body, label %loop.exit @@ -781,53 +780,55 @@ loop.body: ; preds = %loop.cond %4 = call ptr @std.io.ByteReader.init(ptr %br, ptr %lo, i64 %hi) %5 = insertvalue %any undef, ptr %4, 0 %6 = insertvalue %any %5, i64 ptrtoint (ptr @"$ct.std.io.ByteReader" to i64), 1 + %7 = call ptr @llvm.threadlocal.address.p0(ptr @std.core.mem.allocator.thread_allocator) store %any %6, ptr %taddr, align 8 %lo2 = load i64, ptr %taddr, align 8 %ptradd3 = getelementptr inbounds i8, ptr %taddr, i64 8 %hi4 = load ptr, ptr %ptradd3, align 8 - %lo5 = load i64, ptr @std.core.mem.allocator.thread_allocator, align 8 - %hi6 = load ptr, ptr getelementptr inbounds (i8, ptr @std.core.mem.allocator.thread_allocator, i64 8), align 8 - %7 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.init"(ptr %lex, i64 %lo2, ptr %hi4, ptr @lexer_test.is_ident_char, i64 %lo5, ptr %hi6) - %not_err = icmp eq i64 %7, 0 - %8 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) - br i1 %8, label %after_check, label %assign_optional + %lo5 = load i64, ptr %7, align 8 + %ptradd6 = getelementptr inbounds i8, ptr %7, i64 8 + %hi7 = load ptr, ptr %ptradd6, align 8 + %8 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.init"(ptr %lex, i64 %lo2, ptr %hi4, ptr @lexer_test.is_ident_char, i64 %lo5, ptr %hi7) + %not_err = icmp eq i64 %8, 0 + %9 = call i1 @llvm.expect.i1(i1 %not_err, i1 true) + br i1 %9, label %after_check, label %assign_optional assign_optional: ; preds = %loop.body - store i64 %7, ptr %error_var, align 8 + store i64 %8, ptr %error_var, align 8 br label %guard_block after_check: ; preds = %loop.body br label %noerr_block guard_block: ; preds = %assign_optional - %9 = load i64, ptr %error_var, align 8 - ret i64 %9 + %10 = load i64, ptr %error_var, align 8 + ret i64 %10 noerr_block: ; preds = %after_check - %10 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.next"(ptr %retparam, ptr %lex) - %not_err8 = icmp eq i64 %10, 0 - %11 = call i1 @llvm.expect.i1(i1 %not_err8, i1 true) - br i1 %11, label %after_check10, label %assign_optional9 + %11 = call i64 @"lexer$lexer_test.Token$lexer_test.Comment$.Lexer.next"(ptr %retparam, ptr %lex) + %not_err9 = icmp eq i64 %11, 0 + %12 = call i1 @llvm.expect.i1(i1 %not_err9, i1 true) + br i1 %12, label %after_check11, label %assign_optional10 -assign_optional9: ; preds = %noerr_block - store i64 %10, ptr %error_var7, align 8 - br label %guard_block11 +assign_optional10: ; preds = %noerr_block + store i64 %11, ptr %error_var8, align 8 + br label %guard_block12 -after_check10: ; preds = %noerr_block - br label %noerr_block12 +after_check11: ; preds = %noerr_block + br label %noerr_block13 -guard_block11: ; preds = %assign_optional9 - %12 = load i64, ptr %error_var7, align 8 - ret i64 %12 +guard_block12: ; preds = %assign_optional10 + %13 = load i64, ptr %error_var8, align 8 + ret i64 %13 -noerr_block12: ; preds = %after_check10 - %13 = load i8, ptr %retparam, align 1 - store i8 %13, ptr %kind, align 1 - %14 = load i8, ptr %kind, align 1 - %eq = icmp eq i8 %14, 1 +noerr_block13: ; preds = %after_check11 + %14 = load i8, ptr %retparam, align 1 + store i8 %14, ptr %kind, align 1 + %15 = load i8, ptr %kind, align 1 + %eq = icmp eq i8 %15, 1 call void @llvm.assume(i1 %eq) - %15 = load i64, ptr %.anon, align 8 - %addnuw = add nuw i64 %15, 1 + %16 = load i64, ptr %.anon, align 8 + %addnuw = add nuw i64 %16, 1 store i64 %addnuw, ptr %.anon, align 8 br label %loop.cond diff --git a/test/test_suite/variables/var_init_multi.c3t b/test/test_suite/variables/var_init_multi.c3t index 595f5a311..75b38e623 100644 --- a/test/test_suite/variables/var_init_multi.c3t +++ b/test/test_suite/variables/var_init_multi.c3t @@ -21,8 +21,10 @@ entry: %y = alloca i32, align 4 %z = alloca ptr, align 16 %w = alloca ptr, align 16 + %0 = call ptr @llvm.threadlocal.address.p0(ptr @main.tx) + %1 = call ptr @llvm.threadlocal.address.p0(ptr @main.ty) store i32 0, ptr %x, align 4 store i32 0, ptr %y, align 4 - %0 = load i32, ptr %x, align 4 - ret i32 %0 + %2 = load i32, ptr %x, align 4 + ret i32 %2 }