Commit 67d565136a
Changed files (7)
doc/langref.md
@@ -538,12 +538,12 @@ expression is not known at compile time.
The result of the function is the result of the expression.
-### @ctz(inline T: type, x: T) -> T
+### @ctz(x: T) -> T
This function counts the number of trailing zeroes in x which is an integer
type T.
-### @clz(inline T: type, x: T) -> T
+### @clz(x: T) -> T
This function counts the number of leading zeroes in x which is an integer
type T.
src/all_types.hpp
@@ -1455,6 +1455,8 @@ enum IrInstructionId {
IrInstructionIdSizeOf,
IrInstructionIdTestNull,
IrInstructionIdUnwrapMaybe,
+ IrInstructionIdClz,
+ IrInstructionIdCtz,
};
struct IrInstruction {
@@ -1766,6 +1768,18 @@ struct IrInstructionUnwrapMaybe {
bool safety_check_on;
};
+struct IrInstructionCtz {
+ IrInstruction base;
+
+ IrInstruction *value;
+};
+
+struct IrInstructionClz {
+ IrInstruction base;
+
+ IrInstruction *value;
+};
+
enum LValPurpose {
LValPurposeNone,
LValPurposeAssign,
src/bignum.cpp
@@ -360,3 +360,37 @@ bool bignum_multiply_by_scalar(BigNum *bignum, uint64_t scalar) {
assert(!bignum->is_negative);
return __builtin_umulll_overflow(bignum->data.x_uint, scalar, &bignum->data.x_uint);
}
+
+uint32_t bignum_ctz(BigNum *bignum, uint32_t bit_count) {
+ assert(bignum->kind == BigNumKindInt);
+
+ uint64_t x = bignum_to_twos_complement(bignum);
+ uint32_t result = 0;
+ for (uint32_t i = 0; i < bit_count; i += 1) {
+ if ((x & 0x1) != 0)
+ break;
+
+ result += 1;
+ x = x >> 1;
+ }
+ return result;
+}
+
+uint32_t bignum_clz(BigNum *bignum, uint32_t bit_count) {
+ assert(bignum->kind == BigNumKindInt);
+
+ if (bit_count == 0)
+ return 0;
+
+ uint64_t x = bignum_to_twos_complement(bignum);
+ uint64_t mask = ((uint64_t)1) << ((uint64_t)bit_count - 1);
+ uint32_t result = 0;
+ for (uint32_t i = 0; i < bit_count; i += 1) {
+ if ((x & mask) != 0)
+ break;
+
+ result += 1;
+ x = x << 1;
+ }
+ return result;
+}
src/bignum.hpp
@@ -66,4 +66,7 @@ bool bignum_multiply_by_scalar(BigNum *bignum, uint64_t scalar);
struct Buf;
Buf *bignum_to_buf(BigNum *bn);
+uint32_t bignum_ctz(BigNum *bignum, uint32_t bit_count);
+uint32_t bignum_clz(BigNum *bignum, uint32_t bit_count);
+
#endif
src/codegen.cpp
@@ -1478,6 +1478,46 @@ static LLVMValueRef ir_render_unwrap_maybe(CodeGen *g, IrExecutable *executable,
}
}
+static LLVMValueRef get_int_builtin_fn(CodeGen *g, TypeTableEntry *int_type, BuiltinFnId fn_id) {
+ // [0-ctz,1-clz][0-8,1-16,2-32,3-64]
+ size_t index0 = (fn_id == BuiltinFnIdCtz) ? 0 : 1;
+ size_t index1 = bits_index(int_type->data.integral.bit_count);
+ LLVMValueRef *fn = &g->int_builtin_fns[index0][index1];
+ if (!*fn) {
+ const char *fn_name = (fn_id == BuiltinFnIdCtz) ? "cttz" : "ctlz";
+ Buf *llvm_name = buf_sprintf("llvm.%s.i%zu", fn_name, int_type->data.integral.bit_count);
+ LLVMTypeRef param_types[] = {
+ int_type->type_ref,
+ LLVMInt1Type(),
+ };
+ LLVMTypeRef fn_type = LLVMFunctionType(int_type->type_ref, param_types, 2, false);
+ *fn = LLVMAddFunction(g->module, buf_ptr(llvm_name), fn_type);
+ }
+ return *fn;
+}
+
+static LLVMValueRef ir_render_clz(CodeGen *g, IrExecutable *executable, IrInstructionClz *instruction) {
+ TypeTableEntry *int_type = instruction->base.type_entry;
+ LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdClz);
+ LLVMValueRef operand = ir_llvm_value(g, instruction->value);
+ LLVMValueRef params[] {
+ operand,
+ LLVMConstNull(LLVMInt1Type()),
+ };
+ return LLVMBuildCall(g->builder, fn_val, params, 2, "");
+}
+
+static LLVMValueRef ir_render_ctz(CodeGen *g, IrExecutable *executable, IrInstructionCtz *instruction) {
+ TypeTableEntry *int_type = instruction->base.type_entry;
+ LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, BuiltinFnIdCtz);
+ LLVMValueRef operand = ir_llvm_value(g, instruction->value);
+ LLVMValueRef params[] {
+ operand,
+ LLVMConstNull(LLVMInt1Type()),
+ };
+ return LLVMBuildCall(g->builder, fn_val, params, 2, "");
+}
+
static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable, IrInstruction *instruction) {
set_debug_source_node(g, instruction->source_node);
@@ -1529,6 +1569,10 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
return ir_render_test_null(g, executable, (IrInstructionTestNull *)instruction);
case IrInstructionIdUnwrapMaybe:
return ir_render_unwrap_maybe(g, executable, (IrInstructionUnwrapMaybe *)instruction);
+ case IrInstructionIdClz:
+ return ir_render_clz(g, executable, (IrInstructionClz *)instruction);
+ case IrInstructionIdCtz:
+ return ir_render_ctz(g, executable, (IrInstructionCtz *)instruction);
case IrInstructionIdSwitchBr:
case IrInstructionIdPhi:
case IrInstructionIdContainerInitList:
@@ -2774,8 +2818,8 @@ static void define_builtin_fns(CodeGen *g) {
create_builtin_fn_with_arg_count(g, BuiltinFnIdCUndef, "cUndef", 1);
create_builtin_fn_with_arg_count(g, BuiltinFnIdCompileVar, "compileVar", 1);
create_builtin_fn_with_arg_count(g, BuiltinFnIdConstEval, "constEval", 1);
- create_builtin_fn_with_arg_count(g, BuiltinFnIdCtz, "ctz", 2);
- create_builtin_fn_with_arg_count(g, BuiltinFnIdClz, "clz", 2);
+ create_builtin_fn_with_arg_count(g, BuiltinFnIdCtz, "ctz", 1);
+ create_builtin_fn_with_arg_count(g, BuiltinFnIdClz, "clz", 1);
create_builtin_fn_with_arg_count(g, BuiltinFnIdImport, "import", 1);
create_builtin_fn_with_arg_count(g, BuiltinFnIdCImport, "cImport", 1);
create_builtin_fn_with_arg_count(g, BuiltinFnIdErrName, "errorName", 1);
src/ir.cpp
@@ -234,6 +234,14 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionUnwrapMaybe *) {
return IrInstructionIdUnwrapMaybe;
}
+static constexpr IrInstructionId ir_instruction_id(IrInstructionClz *) {
+ return IrInstructionIdClz;
+}
+
+static constexpr IrInstructionId ir_instruction_id(IrInstructionCtz *) {
+ return IrInstructionIdCtz;
+}
+
template<typename T>
static T *ir_create_instruction(IrExecutable *exec, AstNode *source_node) {
T *special_instruction = allocate<T>(1);
@@ -924,6 +932,36 @@ static IrInstruction *ir_build_unwrap_maybe_from(IrBuilder *irb, IrInstruction *
return new_instruction;
}
+static IrInstruction *ir_build_clz(IrBuilder *irb, AstNode *source_node, IrInstruction *value) {
+ IrInstructionClz *instruction = ir_build_instruction<IrInstructionClz>(irb, source_node);
+ instruction->value = value;
+
+ ir_ref_instruction(value);
+
+ return &instruction->base;
+}
+
+static IrInstruction *ir_build_clz_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
+ IrInstruction *new_instruction = ir_build_clz(irb, old_instruction->source_node, value);
+ ir_link_new_instruction(new_instruction, old_instruction);
+ return new_instruction;
+}
+
+static IrInstruction *ir_build_ctz(IrBuilder *irb, AstNode *source_node, IrInstruction *value) {
+ IrInstructionCtz *instruction = ir_build_instruction<IrInstructionCtz>(irb, source_node);
+ instruction->value = value;
+
+ ir_ref_instruction(value);
+
+ return &instruction->base;
+}
+
+static IrInstruction *ir_build_ctz_from(IrBuilder *irb, IrInstruction *old_instruction, IrInstruction *value) {
+ IrInstruction *new_instruction = ir_build_ctz(irb, old_instruction->source_node, value);
+ ir_link_new_instruction(new_instruction, old_instruction);
+ return new_instruction;
+}
+
static void ir_gen_defers_for_block(IrBuilder *irb, BlockContext *inner_block, BlockContext *outer_block,
bool gen_error_defers, bool gen_maybe_defers)
{
@@ -964,9 +1002,9 @@ static IrInstruction *ir_gen_return(IrBuilder *irb, AstNode *node) {
return ir_build_return(irb, node, return_value);
}
case ReturnKindError:
- zig_panic("TODO %%return");
+ zig_panic("TODO gen IR for %%return");
case ReturnKindMaybe:
- zig_panic("TODO ?return");
+ zig_panic("TODO gen IR for ?return");
}
zig_unreachable();
}
@@ -1188,7 +1226,7 @@ static IrInstruction *ir_gen_bin_op(IrBuilder *irb, AstNode *node) {
case BinOpTypeArrayMult:
return ir_gen_bin_op_id(irb, node, IrBinOpArrayMult);
case BinOpTypeUnwrapMaybe:
- zig_panic("TODO gen IR for unwrap maybe");
+ zig_panic("TODO gen IR for unwrap maybe binary operation");
}
zig_unreachable();
}
@@ -1357,7 +1395,7 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, AstNode *node) {
if (builtin_fn->param_count != actual_param_count) {
add_node_error(irb->codegen, node,
- buf_sprintf("expected %zu arguments, got %zu",
+ buf_sprintf("expected %zu arguments, found %zu",
builtin_fn->param_count, actual_param_count));
return irb->codegen->invalid_instruction;
}
@@ -1423,6 +1461,24 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, AstNode *node) {
return ir_build_size_of(irb, node, arg0_value);
}
+ case BuiltinFnIdCtz:
+ {
+ AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+ IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->block_context);
+ if (arg0_value == irb->codegen->invalid_instruction)
+ return arg0_value;
+
+ return ir_build_ctz(irb, node, arg0_value);
+ }
+ case BuiltinFnIdClz:
+ {
+ AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+ IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, node->block_context);
+ if (arg0_value == irb->codegen->invalid_instruction)
+ return arg0_value;
+
+ return ir_build_clz(irb, node, arg0_value);
+ }
case BuiltinFnIdMemcpy:
case BuiltinFnIdMemset:
case BuiltinFnIdAlignof:
@@ -1438,8 +1494,6 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, AstNode *node) {
case BuiltinFnIdCUndef:
case BuiltinFnIdCompileErr:
case BuiltinFnIdConstEval:
- case BuiltinFnIdCtz:
- case BuiltinFnIdClz:
case BuiltinFnIdImport:
case BuiltinFnIdCImport:
case BuiltinFnIdErrName:
@@ -1547,13 +1601,17 @@ static IrInstruction *ir_gen_prefix_op_id(IrBuilder *irb, AstNode *node, IrUnOp
return ir_gen_prefix_op_id_lval(irb, node, op_id, LValPurposeNone);
}
-static IrInstruction *ir_gen_prefix_op_unwrap_maybe(IrBuilder *irb, AstNode *node) {
+static IrInstruction *ir_gen_prefix_op_unwrap_maybe(IrBuilder *irb, AstNode *node, LValPurpose lval) {
AstNode *expr = node->data.prefix_op_expr.primary_expr;
- IrInstruction *value = ir_gen_node(irb, expr, node->block_context);
+ IrInstruction *value = ir_gen_node_extra(irb, expr, node->block_context, LValPurposeAddressOf);
if (value == irb->codegen->invalid_instruction)
return value;
- return ir_build_unwrap_maybe(irb, node, value, true);
+ IrInstruction *unwrapped_ptr = ir_build_unwrap_maybe(irb, node, value, true);
+ if (lval == LValPurposeNone)
+ return ir_build_load_ptr(irb, node, unwrapped_ptr);
+ else
+ return unwrapped_ptr;
}
static IrInstruction *ir_gen_prefix_op_expr(IrBuilder *irb, AstNode *node, LValPurpose lval) {
@@ -1585,7 +1643,7 @@ static IrInstruction *ir_gen_prefix_op_expr(IrBuilder *irb, AstNode *node, LValP
case PrefixOpUnwrapError:
return ir_gen_prefix_op_id(irb, node, IrUnOpUnwrapError);
case PrefixOpUnwrapMaybe:
- return ir_gen_prefix_op_unwrap_maybe(irb, node);
+ return ir_gen_prefix_op_unwrap_maybe(irb, node, lval);
}
zig_unreachable();
}
@@ -2349,7 +2407,7 @@ static IrInstruction *ir_resolve_cast(IrAnalyze *ira, IrInstruction *source_inst
return result;
} else {
IrInstruction *result = ir_build_cast(&ira->new_irb, source_instr->source_node,
- dest_type->other, value->other, cast_op);
+ dest_type, value, cast_op);
result->type_entry = wanted_type;
if (need_alloca && source_instr->source_node->block_context->fn_entry) {
IrInstructionCast *cast_instruction = (IrInstructionCast *)result;
@@ -2776,7 +2834,7 @@ static IrInstruction *ir_get_casted_value(IrAnalyze *ira, IrInstruction *value,
switch (result) {
case ImplicitCastMatchResultNo:
add_node_error(ira->codegen, first_executing_node(value->source_node),
- buf_sprintf("expected type '%s', got '%s'",
+ buf_sprintf("expected type '%s', found '%s'",
buf_ptr(&expected_type->name),
buf_ptr(&value->type_entry->name)));
return ira->codegen->invalid_instruction;
@@ -3346,7 +3404,7 @@ static TypeTableEntry *ir_analyze_instruction_call(IrAnalyze *ira, IrInstruction
return ira->codegen->builtin_types.entry_invalid;
}
- IrInstruction *arg = call_instruction->args[0];
+ IrInstruction *arg = call_instruction->args[0]->other;
IrInstruction *cast_instruction = ir_analyze_cast(ira, &call_instruction->base, fn_ref, arg);
if (cast_instruction == ira->codegen->invalid_instruction)
return ira->codegen->builtin_types.entry_invalid;
@@ -3701,7 +3759,7 @@ static TypeTableEntry *ir_analyze_instruction_un_op(IrAnalyze *ira, IrInstructio
// return type_entry->data.error.child_type;
// } else {
// add_node_error(g, *expr_node,
- // buf_sprintf("expected error type, got '%s'", buf_ptr(&type_entry->name)));
+ // buf_sprintf("expected error type, found '%s'", buf_ptr(&type_entry->name)));
// return g->builtin_types.entry_invalid;
// }
//}
@@ -4175,6 +4233,7 @@ static TypeTableEntry *ir_analyze_instruction_store_ptr(IrAnalyze *ira, IrInstru
if (ptr->static_value.special != ConstValSpecialRuntime) {
// This memory location is transforming from known at compile time to known at runtime.
// We must emit our own var ptr instruction.
+ // TODO can we delete this code now that we have inline var?
ptr->static_value.special = ConstValSpecialRuntime;
IrInstruction *new_ptr_inst;
if (ptr->id == IrInstructionIdVarPtr) {
@@ -4347,12 +4406,12 @@ static TypeTableEntry *ir_analyze_instruction_set_debug_safety(IrAnalyze *ira,
target_context = type_arg->data.unionation.block_context;
} else {
add_node_error(ira->codegen, target_instruction->source_node,
- buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&type_arg->name)));
+ buf_sprintf("expected scope reference, found type '%s'", buf_ptr(&type_arg->name)));
return ira->codegen->builtin_types.entry_invalid;
}
} else {
add_node_error(ira->codegen, target_instruction->source_node,
- buf_sprintf("expected scope reference, got type '%s'", buf_ptr(&target_type->name)));
+ buf_sprintf("expected scope reference, found type '%s'", buf_ptr(&target_type->name)));
return ira->codegen->builtin_types.entry_invalid;
}
@@ -4682,6 +4741,54 @@ static TypeTableEntry *ir_analyze_instruction_unwrap_maybe(IrAnalyze *ira,
return result_type;
}
+static TypeTableEntry *ir_analyze_instruction_ctz(IrAnalyze *ira, IrInstructionCtz *ctz_instruction) {
+ IrInstruction *value = ctz_instruction->value->other;
+ if (value->type_entry->id == TypeTableEntryIdInvalid) {
+ return ira->codegen->builtin_types.entry_invalid;
+ } else if (value->type_entry->id == TypeTableEntryIdInt) {
+ if (value->static_value.special != ConstValSpecialRuntime) {
+ uint32_t result = bignum_ctz(&value->static_value.data.x_bignum,
+ value->type_entry->data.integral.bit_count);
+ bool depends_on_compile_var = value->static_value.depends_on_compile_var;
+ ConstExprValue *out_val = ir_build_const_from(ira, &ctz_instruction->base,
+ depends_on_compile_var);
+ bignum_init_unsigned(&out_val->data.x_bignum, result);
+ return value->type_entry;
+ }
+
+ ir_build_ctz_from(&ira->new_irb, &ctz_instruction->base, value);
+ return value->type_entry;
+ } else {
+ add_node_error(ira->codegen, ctz_instruction->base.source_node,
+ buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->type_entry->name)));
+ return ira->codegen->builtin_types.entry_invalid;
+ }
+}
+
+static TypeTableEntry *ir_analyze_instruction_clz(IrAnalyze *ira, IrInstructionClz *clz_instruction) {
+ IrInstruction *value = clz_instruction->value->other;
+ if (value->type_entry->id == TypeTableEntryIdInvalid) {
+ return ira->codegen->builtin_types.entry_invalid;
+ } else if (value->type_entry->id == TypeTableEntryIdInt) {
+ if (value->static_value.special != ConstValSpecialRuntime) {
+ uint32_t result = bignum_clz(&value->static_value.data.x_bignum,
+ value->type_entry->data.integral.bit_count);
+ bool depends_on_compile_var = value->static_value.depends_on_compile_var;
+ ConstExprValue *out_val = ir_build_const_from(ira, &clz_instruction->base,
+ depends_on_compile_var);
+ bignum_init_unsigned(&out_val->data.x_bignum, result);
+ return value->type_entry;
+ }
+
+ ir_build_clz_from(&ira->new_irb, &clz_instruction->base, value);
+ return value->type_entry;
+ } else {
+ add_node_error(ira->codegen, clz_instruction->base.source_node,
+ buf_sprintf("expected integer type, found '%s'", buf_ptr(&value->type_entry->name)));
+ return ira->codegen->builtin_types.entry_invalid;
+ }
+}
+
static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstruction *instruction) {
switch (instruction->id) {
case IrInstructionIdInvalid:
@@ -4742,6 +4849,10 @@ static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructi
return ir_analyze_instruction_test_null(ira, (IrInstructionTestNull *)instruction);
case IrInstructionIdUnwrapMaybe:
return ir_analyze_instruction_unwrap_maybe(ira, (IrInstructionUnwrapMaybe *)instruction);
+ case IrInstructionIdClz:
+ return ir_analyze_instruction_clz(ira, (IrInstructionClz *)instruction);
+ case IrInstructionIdCtz:
+ return ir_analyze_instruction_ctz(ira, (IrInstructionCtz *)instruction);
case IrInstructionIdSwitchBr:
case IrInstructionIdCast:
case IrInstructionIdContainerInitList:
@@ -4854,6 +4965,8 @@ bool ir_has_side_effects(IrInstruction *instruction) {
case IrInstructionIdSizeOf:
case IrInstructionIdTestNull:
case IrInstructionIdUnwrapMaybe:
+ case IrInstructionIdClz:
+ case IrInstructionIdCtz:
return false;
case IrInstructionIdAsm:
{
@@ -5117,7 +5230,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// return g->builtin_types.entry_invalid;
// } else if (ptr_type->id != TypeTableEntryIdPointer) {
// add_node_error(g, *ptr_arg,
-// buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&ptr_type->name)));
+// buf_sprintf("expected pointer argument, found '%s'", buf_ptr(&ptr_type->name)));
// return g->builtin_types.entry_invalid;
// }
//
@@ -5223,7 +5336,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// zig_panic("TODO");
// } else {
// add_node_error(g, node,
-// buf_sprintf("expected integer type, got '%s'", buf_ptr(&result_type->name)));
+// buf_sprintf("expected integer type, found '%s'", buf_ptr(&result_type->name)));
// return g->builtin_types.entry_invalid;
// }
//}
@@ -5243,16 +5356,16 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// return g->builtin_types.entry_invalid;
// } else if (dest_type->id != TypeTableEntryIdInt) {
// add_node_error(g, *op1,
-// buf_sprintf("expected integer type, got '%s'", buf_ptr(&dest_type->name)));
+// buf_sprintf("expected integer type, found '%s'", buf_ptr(&dest_type->name)));
// return g->builtin_types.entry_invalid;
// } else if (src_type->id != TypeTableEntryIdInt) {
// add_node_error(g, *op2,
-// buf_sprintf("expected integer type, got '%s'", buf_ptr(&src_type->name)));
+// buf_sprintf("expected integer type, found '%s'", buf_ptr(&src_type->name)));
// return g->builtin_types.entry_invalid;
// } else if (src_type->data.integral.is_signed != dest_type->data.integral.is_signed) {
// const char *sign_str = dest_type->data.integral.is_signed ? "signed" : "unsigned";
// add_node_error(g, *op2,
-// buf_sprintf("expected %s integer type, got '%s'", sign_str, buf_ptr(&src_type->name)));
+// buf_sprintf("expected %s integer type, found '%s'", sign_str, buf_ptr(&src_type->name)));
// return g->builtin_types.entry_invalid;
// } else if (src_type->data.integral.bit_count <= dest_type->data.integral.bit_count) {
// add_node_error(g, *op2,
@@ -5459,7 +5572,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// result_node);
// } else {
// add_node_error(g, type_node,
-// buf_sprintf("expected integer type, got '%s'", buf_ptr(&int_type->name)));
+// buf_sprintf("expected integer type, found '%s'", buf_ptr(&int_type->name)));
// }
//
// // TODO constant expression evaluation
@@ -5479,14 +5592,14 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// dest_type->id != TypeTableEntryIdPointer)
// {
// add_node_error(g, dest_node,
-// buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&dest_type->name)));
+// buf_sprintf("expected pointer argument, found '%s'", buf_ptr(&dest_type->name)));
// }
//
// if (src_type->id != TypeTableEntryIdInvalid &&
// src_type->id != TypeTableEntryIdPointer)
// {
// add_node_error(g, src_node,
-// buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&src_type->name)));
+// buf_sprintf("expected pointer argument, found '%s'", buf_ptr(&src_type->name)));
// }
//
// if (dest_type->id == TypeTableEntryIdPointer &&
@@ -5517,7 +5630,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// dest_type->id != TypeTableEntryIdPointer)
// {
// add_node_error(g, dest_node,
-// buf_sprintf("expected pointer argument, got '%s'", buf_ptr(&dest_type->name)));
+// buf_sprintf("expected pointer argument, found '%s'", buf_ptr(&dest_type->name)));
// }
//
// return builtin_fn->return_type;
@@ -5622,29 +5735,6 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
//
// return resolved_type;
// }
-// case BuiltinFnIdCtz:
-// case BuiltinFnIdClz:
-// {
-// AstNode *type_node = node->data.fn_call_expr.params.at(0);
-// TypeTableEntry *int_type = analyze_type_expr(g, import, context, type_node);
-// if (int_type->id == TypeTableEntryIdInvalid) {
-// return int_type;
-// } else if (int_type->id == TypeTableEntryIdInt) {
-// AstNode **expr_node = node->data.fn_call_expr.params.at(1)->parent_field;
-// TypeTableEntry *resolved_type = analyze_expression(g, import, context, int_type, *expr_node);
-// if (resolved_type->id == TypeTableEntryIdInvalid) {
-// return resolved_type;
-// }
-//
-// // TODO const expr eval
-//
-// return resolved_type;
-// } else {
-// add_node_error(g, type_node,
-// buf_sprintf("expected integer type, got '%s'", buf_ptr(&int_type->name)));
-// return g->builtin_types.entry_invalid;
-// }
-// }
// case BuiltinFnIdImport:
// return analyze_import(g, import, context, node);
// case BuiltinFnIdCImport:
@@ -6192,7 +6282,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// return child_type;
// } else {
// add_node_error(g, op1,
-// buf_sprintf("expected maybe type, got '%s'",
+// buf_sprintf("expected maybe type, found '%s'",
// buf_ptr(&lhs_type->name)));
// return g->builtin_types.entry_invalid;
// }
@@ -6212,7 +6302,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// op1_type->data.pointer.child_type == g->builtin_types.entry_u8) {
// child_type = op1_type->data.pointer.child_type;
// } else {
-// add_node_error(g, *op1, buf_sprintf("expected array or C string literal, got '%s'",
+// add_node_error(g, *op1, buf_sprintf("expected array or C string literal, found '%s'",
// buf_ptr(&op1_type->name)));
// return g->builtin_types.entry_invalid;
// }
@@ -6223,7 +6313,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// return g->builtin_types.entry_invalid;
// } else if (op2_type->id == TypeTableEntryIdArray) {
// if (op2_type->data.array.child_type != child_type) {
-// add_node_error(g, *op2, buf_sprintf("expected array of type '%s', got '%s'",
+// add_node_error(g, *op2, buf_sprintf("expected array of type '%s', found '%s'",
// buf_ptr(&child_type->name),
// buf_ptr(&op2_type->name)));
// return g->builtin_types.entry_invalid;
@@ -6231,7 +6321,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// } else if (op2_type->id == TypeTableEntryIdPointer &&
// op2_type->data.pointer.child_type == g->builtin_types.entry_u8) {
// } else {
-// add_node_error(g, *op2, buf_sprintf("expected array or C string literal, got '%s'",
+// add_node_error(g, *op2, buf_sprintf("expected array or C string literal, found '%s'",
// buf_ptr(&op2_type->name)));
// return g->builtin_types.entry_invalid;
// }
@@ -6271,12 +6361,12 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// } else if (op1_type->id == TypeTableEntryIdPointer) {
// if (!op1_val->data.x_ptr.is_c_str) {
// add_node_error(g, *op1,
-// buf_sprintf("expected array or C string literal, got '%s'",
+// buf_sprintf("expected array or C string literal, found '%s'",
// buf_ptr(&op1_type->name)));
// return g->builtin_types.entry_invalid;
// } else if (!op2_val->data.x_ptr.is_c_str) {
// add_node_error(g, *op2,
-// buf_sprintf("expected array or C string literal, got '%s'",
+// buf_sprintf("expected array or C string literal, found '%s'",
// buf_ptr(&op2_type->name)));
// return g->builtin_types.entry_invalid;
// }
@@ -6510,12 +6600,12 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// if (call_param_count < expect_arg_count) {
// ok_invocation = false;
// add_node_error(g, node,
-// buf_sprintf("expected at least %zu arguments, got %zu", src_param_count, call_param_count));
+// buf_sprintf("expected at least %zu arguments, found %zu", src_param_count, call_param_count));
// }
// } else if (expect_arg_count != call_param_count) {
// ok_invocation = false;
// add_node_error(g, node,
-// buf_sprintf("expected %zu arguments, got %zu", expect_arg_count, call_param_count));
+// buf_sprintf("expected %zu arguments, found %zu", expect_arg_count, call_param_count));
// }
//
// bool all_args_const_expr = true;
@@ -6631,7 +6721,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
//
// if (src_param_count != call_param_count + struct_node_1_or_0) {
// add_node_error(g, call_node,
-// buf_sprintf("expected %zu arguments, got %zu", src_param_count - struct_node_1_or_0, call_param_count));
+// buf_sprintf("expected %zu arguments, found %zu", src_param_count - struct_node_1_or_0, call_param_count));
// return g->builtin_types.entry_invalid;
// }
//
@@ -6759,7 +6849,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
//
// if (actual_param_count != expected_param_count) {
// add_node_error(g, first_executing_node(node),
-// buf_sprintf("expected %zu arguments, got %zu", expected_param_count, actual_param_count));
+// buf_sprintf("expected %zu arguments, found %zu", expected_param_count, actual_param_count));
// return g->builtin_types.entry_invalid;
// }
//
@@ -7180,7 +7270,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// return resolved_type->data.error.child_type;
// } else {
// add_node_error(g, node->data.return_expr.expr,
-// buf_sprintf("expected error type, got '%s'", buf_ptr(&resolved_type->name)));
+// buf_sprintf("expected error type, found '%s'", buf_ptr(&resolved_type->name)));
// return g->builtin_types.entry_invalid;
// }
// }
@@ -7208,7 +7298,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// return resolved_type->data.maybe.child_type;
// } else {
// add_node_error(g, node->data.return_expr.expr,
-// buf_sprintf("expected maybe type, got '%s'", buf_ptr(&resolved_type->name)));
+// buf_sprintf("expected maybe type, found '%s'", buf_ptr(&resolved_type->name)));
// return g->builtin_types.entry_invalid;
// }
// }
@@ -7502,14 +7592,14 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
//
// if (op1_type->id != TypeTableEntryIdArray) {
// add_node_error(g, *op1,
-// buf_sprintf("expected array type, got '%s'", buf_ptr(&op1_type->name)));
+// buf_sprintf("expected array type, found '%s'", buf_ptr(&op1_type->name)));
// return g->builtin_types.entry_invalid;
// }
//
// if (op2_type->id != TypeTableEntryIdNumLitInt &&
// op2_type->id != TypeTableEntryIdInt)
// {
-// add_node_error(g, *op2, buf_sprintf("expected integer type, got '%s'", buf_ptr(&op2_type->name)));
+// add_node_error(g, *op2, buf_sprintf("expected integer type, found '%s'", buf_ptr(&op2_type->name)));
// return g->builtin_types.entry_invalid;
// }
//
@@ -7576,7 +7666,7 @@ IrInstruction *ir_exec_const_result(IrExecutable *exec) {
// return child_type;
// } else {
// add_node_error(g, op1,
-// buf_sprintf("expected error type, got '%s'", buf_ptr(&lhs_type->name)));
+// buf_sprintf("expected error type, found '%s'", buf_ptr(&lhs_type->name)));
// return g->builtin_types.entry_invalid;
// }
//}
@@ -8076,21 +8166,6 @@ static void analyze_goto_pass2(CodeGen *g, ImportTableEntry *import, AstNode *no
// case BuiltinFnIdCompileErr:
// case BuiltinFnIdIntType:
// zig_unreachable();
-// case BuiltinFnIdCtz:
-// case BuiltinFnIdClz:
-// {
-// size_t fn_call_param_count = node->data.fn_call_expr.params.length;
-// assert(fn_call_param_count == 2);
-// TypeTableEntry *int_type = get_type_for_type_node(node->data.fn_call_expr.params.at(0));
-// assert(int_type->id == TypeTableEntryIdInt);
-// LLVMValueRef fn_val = get_int_builtin_fn(g, int_type, builtin_fn->id);
-// LLVMValueRef operand = gen_expr(g, node->data.fn_call_expr.params.at(1));
-// LLVMValueRef params[] {
-// operand,
-// LLVMConstNull(LLVMInt1Type()),
-// };
-// return LLVMBuildCall(g->builder, fn_val, params, 2, "");
-// }
// case BuiltinFnIdAddWithOverflow:
// case BuiltinFnIdSubWithOverflow:
// case BuiltinFnIdMulWithOverflow:
@@ -9539,24 +9614,6 @@ static void analyze_goto_pass2(CodeGen *g, ImportTableEntry *import, AstNode *no
// return gen_var_decl_raw(g, node, &node->data.variable_declaration, false, &init_val, &init_val_type, false);
//}
//
-//static LLVMValueRef get_int_builtin_fn(CodeGen *g, TypeTableEntry *int_type, BuiltinFnId fn_id) {
-// // [0-ctz,1-clz][0-8,1-16,2-32,3-64]
-// size_t index0 = (fn_id == BuiltinFnIdCtz) ? 0 : 1;
-// size_t index1 = bits_index(int_type->data.integral.bit_count);
-// LLVMValueRef *fn = &g->int_builtin_fns[index0][index1];
-// if (!*fn) {
-// const char *fn_name = (fn_id == BuiltinFnIdCtz) ? "cttz" : "ctlz";
-// Buf *llvm_name = buf_sprintf("llvm.%s.i%zu", fn_name, int_type->data.integral.bit_count);
-// LLVMTypeRef param_types[] = {
-// int_type->type_ref,
-// LLVMInt1Type(),
-// };
-// LLVMTypeRef fn_type = LLVMFunctionType(int_type->type_ref, param_types, 2, false);
-// *fn = LLVMAddFunction(g->module, buf_ptr(llvm_name), fn_type);
-// }
-// return *fn;
-//}
-//
//static LLVMValueRef gen_fence(CodeGen *g, AstNode *node) {
// assert(node->type == NodeTypeFnCallExpr);
//
src/ir_print.cpp
@@ -511,6 +511,18 @@ static void ir_print_unwrap_maybe(IrPrint *irp, IrInstructionUnwrapMaybe *instru
}
}
+static void ir_print_clz(IrPrint *irp, IrInstructionClz *instruction) {
+ fprintf(irp->f, "@clz(");
+ ir_print_other_instruction(irp, instruction->value);
+ fprintf(irp->f, ")");
+}
+
+static void ir_print_ctz(IrPrint *irp, IrInstructionCtz *instruction) {
+ fprintf(irp->f, "@ctz(");
+ ir_print_other_instruction(irp, instruction->value);
+ fprintf(irp->f, ")");
+}
+
static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
ir_print_prefix(irp, instruction);
switch (instruction->id) {
@@ -612,6 +624,12 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
case IrInstructionIdUnwrapMaybe:
ir_print_unwrap_maybe(irp, (IrInstructionUnwrapMaybe *)instruction);
break;
+ case IrInstructionIdCtz:
+ ir_print_ctz(irp, (IrInstructionCtz *)instruction);
+ break;
+ case IrInstructionIdClz:
+ ir_print_clz(irp, (IrInstructionClz *)instruction);
+ break;
case IrInstructionIdSwitchBr:
zig_panic("TODO print more IR instructions");
}