mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-15 05:48:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix codegen for void parameters

Browse Source
This commit is contained in:
Josh Wolfe 2015-12-03 14:29:19 -07:00
parent 137fe99258
commit f4b9b03f54
2 changed files with 59 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
example/expressions/expressions.zig
View File

@ -25,5 +25,16 @@ export fn _start() -> unreachable {
no_conflict
};
if (c == 10) { puts("OK 2"); }
void_fun(1, void, 2);
other_exit();
}
fn void_fun(a : i32, b : void, c : i32) -> void {
let x = a + 1; // i32
let y = c + 1; // i32
let z = b; // void
let w : void = z; // void
if (x + y == 4) { return w; }
}

61
src/codegen.cpp
View File

@ -76,11 +76,29 @@ static LLVMZigDIType *to_llvm_debug_type(AstNode *type_node) {
return type_node->codegen_node->data.type_node.entry->di_type;
}
static bool type_is_unreachable(CodeGen *g, AstNode *type_node) {
static TypeTableEntry *get_type_for_type_node(CodeGen *g, AstNode *type_node) {
assert(type_node->type == NodeTypeType);
assert(type_node->codegen_node);
assert(type_node->codegen_node->data.type_node.entry);
return type_node->codegen_node->data.type_node.entry == g->builtin_types.entry_unreachable;
return type_node->codegen_node->data.type_node.entry;
}
static bool type_is_unreachable(CodeGen *g, AstNode *type_node) {
return get_type_for_type_node(g, type_node) == g->builtin_types.entry_unreachable;
}
static bool is_param_decl_type_void(CodeGen *g, AstNode *param_decl_node) {
assert(param_decl_node->type == NodeTypeParamDecl);
return get_type_for_type_node(g, param_decl_node->data.param_decl.type) == g->builtin_types.entry_void;
}
static int count_non_void_params(CodeGen *g, ZigList<AstNode *> *params) {
int result = 0;
for (int i = 0; i < params->length; i += 1) {
if (!is_param_decl_type_void(g, params->at(i)))
result += 1;
}
return result;
}
static void add_debug_source_node(CodeGen *g, AstNode *node) {
@ -124,15 +142,23 @@ static LLVMValueRef gen_fn_call_expr(CodeGen *g, AstNode *node) {
int actual_param_count = node->data.fn_call_expr.params.length;
assert(expected_param_count == actual_param_count);
LLVMValueRef *param_values = allocate<LLVMValueRef>(actual_param_count);
// don't really include void values
int gen_param_count = count_non_void_params(g, &fn_table_entry->proto_node->data.fn_proto.params);
LLVMValueRef *gen_param_values = allocate<LLVMValueRef>(gen_param_count);
int gen_param_index = 0;
for (int i = 0; i < actual_param_count; i += 1) {
AstNode *expr_node = node->data.fn_call_expr.params.at(i);
param_values[i] = gen_expr(g, expr_node);
LLVMValueRef param_value = gen_expr(g, expr_node);
if (!is_param_decl_type_void(g, fn_table_entry->proto_node->data.fn_proto.params.at(i))) {
gen_param_values[gen_param_index] = param_value;
gen_param_index += 1;
}
}
add_debug_source_node(g, node);
LLVMValueRef result = LLVMZigBuildCall(g->builder, fn_table_entry->fn_value,
param_values, actual_param_count, fn_table_entry->calling_convention, "");
gen_param_values, gen_param_count, fn_table_entry->calling_convention, "");
if (type_is_unreachable(g, fn_table_entry->proto_node->data.fn_proto.return_type)) {
return LLVMBuildUnreachable(g->builder);
@ -590,14 +616,19 @@ static void do_code_gen(CodeGen *g) {
AstNodeFnProto *fn_proto = &proto_node->data.fn_proto;
LLVMTypeRef ret_type = to_llvm_type(fn_proto->return_type);
LLVMTypeRef *param_types = allocate<LLVMTypeRef>(fn_proto->params.length);
int param_count = count_non_void_params(g, &fn_proto->params);
LLVMTypeRef *param_types = allocate<LLVMTypeRef>(param_count);
int gen_param_index = 0;
for (int param_decl_i = 0; param_decl_i < fn_proto->params.length; param_decl_i += 1) {
AstNode *param_node = fn_proto->params.at(param_decl_i);
assert(param_node->type == NodeTypeParamDecl);
if (is_param_decl_type_void(g, param_node))
continue;
AstNode *type_node = param_node->data.param_decl.type;
param_types[param_decl_i] = to_llvm_type(type_node);
param_types[gen_param_index] = to_llvm_type(type_node);
gen_param_index += 1;
}
LLVMTypeRef function_type = LLVMFunctionType(ret_type, param_types, fn_proto->params.length, 0);
LLVMTypeRef function_type = LLVMFunctionType(ret_type, param_types, param_count, 0);
LLVMValueRef fn = LLVMAddFunction(g->module, buf_ptr(&fn_proto->name), function_type);
LLVMSetLinkage(fn, fn_table_entry->internal_linkage ? LLVMInternalLinkage : LLVMExternalLinkage);
@ -647,16 +678,20 @@ static void do_code_gen(CodeGen *g) {
FnDefNode *codegen_fn_def = &codegen_node->data.fn_def_node;
assert(codegen_fn_def);
int param_count = fn_proto->params.length;
assert(param_count == (int)LLVMCountParams(fn));
LLVMValueRef *params = allocate<LLVMValueRef>(param_count);
int non_void_param_count = count_non_void_params(g, &fn_proto->params);
assert(non_void_param_count == (int)LLVMCountParams(fn));
LLVMValueRef *params = allocate<LLVMValueRef>(non_void_param_count);
LLVMGetParams(fn, params);
for (int i = 0; i < param_count; i += 1) {
int non_void_index = 0;
for (int i = 0; i < fn_proto->params.length; i += 1) {
AstNode *param_decl = fn_proto->params.at(i);
assert(param_decl->type == NodeTypeParamDecl);
if (is_param_decl_type_void(g, param_decl))
continue;
LocalVariableTableEntry *parameter_variable = fn_def_node->codegen_node->data.fn_def_node.block_context->variable_table.get(&param_decl->data.param_decl.name);
parameter_variable->value_ref = params[i];
parameter_variable->value_ref = params[non_void_index];
non_void_index += 1;
}
build_label_blocks(g, fn_def_node->data.fn_def.body);