authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-11-10 16:32:37-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2017-11-10 16:32:37-05:00
log019f18058bb74816f8754de63a219347597e06da
tree18fc61285f726018d1a54dc079767bb074259cf5
parent403a46abccbc03e70e7975d00a5134867a1d4fc7

fix test failures

put all the codegen for fn prototypes to the same place

5 files changed, 45 insertions(+), 63 deletions(-)

example/cat/main.zig+1-1
......@@ -3,9 +3,9 @@ const io = std.io;
33const mem = std.mem;
44const os = std.os;
55const warn = std.debug.warn;
6const allocator = std.debug.global_allocator;
67
78pub fn main() -> %void {
8 const allocator = &std.debug.global_allocator;
99 var args_it = os.args();
1010 const exe = %return unwrapArg(??args_it.next(allocator));
1111 var catted_anything = false;
src/all_types.hpp+1-5
......@@ -1508,13 +1508,9 @@ struct CodeGen {
15081508 bool linker_rdynamic;
15091509 const char *linker_script;
15101510
1511 // The function definitions this module includes. There must be a corresponding
1512 // fn_protos entry.
1511 // The function definitions this module includes.
15131512 ZigList<FnTableEntry *> fn_defs;
15141513 size_t fn_defs_index;
1515 // The function prototypes this module includes. In the case of external declarations,
1516 // there will not be a corresponding fn_defs entry.
1517 ZigList<FnTableEntry *> fn_protos;
15181514 ZigList<TldVar *> global_vars;
15191515
15201516 OutType out_type;
src/analyze.cpp-3
......@@ -2121,8 +2121,6 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
21212121 }
21222122
21232123 if (!fn_table_entry->type_entry->data.fn.is_generic) {
2124 g->fn_protos.append(fn_table_entry);
2125
21262124 if (fn_def_node)
21272125 g->fn_defs.append(fn_table_entry);
21282126
......@@ -2162,7 +2160,6 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
21622160 fn_table_entry->body_node = source_node->data.test_decl.body;
21632161 fn_table_entry->is_test = true;
21642162
2165 g->fn_protos.append(fn_table_entry);
21662163 g->fn_defs.append(fn_table_entry);
21672164 g->test_fns.append(fn_table_entry);
21682165
src/codegen.cpp+43-53
......@@ -494,6 +494,49 @@ static LLVMValueRef fn_llvm_value(CodeGen *g, FnTableEntry *fn_table_entry) {
494494 // use the ABI alignment, which is fine.
495495 }
496496
497 if (!type_has_bits(fn_type->data.fn.fn_type_id.return_type)) {
498 // nothing to do
499 } else if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdPointer ||
500 fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdFn)
501 {
502 addLLVMAttr(fn_table_entry->llvm_value, 0, "nonnull");
503 } else if (handle_is_ptr(fn_type->data.fn.fn_type_id.return_type) &&
504 calling_convention_does_first_arg_return(fn_type->data.fn.fn_type_id.cc))
505 {
506 addLLVMArgAttr(fn_table_entry->llvm_value, 0, "sret");
507 addLLVMArgAttr(fn_table_entry->llvm_value, 0, "nonnull");
508 }
509
510
511 // set parameter attributes
512 for (size_t param_i = 0; param_i < fn_type->data.fn.fn_type_id.param_count; param_i += 1) {
513 FnGenParamInfo *gen_info = &fn_type->data.fn.gen_param_info[param_i];
514 size_t gen_index = gen_info->gen_index;
515 bool is_byval = gen_info->is_byval;
516
517 if (gen_index == SIZE_MAX) {
518 continue;
519 }
520
521 FnTypeParamInfo *param_info = &fn_type->data.fn.fn_type_id.param_info[param_i];
522
523 TypeTableEntry *param_type = gen_info->type;
524 if (param_info->is_noalias) {
525 addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "noalias");
526 }
527 if ((param_type->id == TypeTableEntryIdPointer && param_type->data.pointer.is_const) || is_byval) {
528 addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "readonly");
529 }
530 if (param_type->id == TypeTableEntryIdPointer) {
531 addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "nonnull");
532 }
533 // Note: byval is disabled on windows due to an LLVM bug:
534 // https://github.com/zig-lang/zig/issues/536
535 if (is_byval && g->zig_target.os != ZigLLVM_Win32) {
536 addLLVMArgAttr(fn_table_entry->llvm_value, (unsigned)gen_index, "byval");
537 }
538 }
539
497540 return fn_table_entry->llvm_value;
498541}
499542
......@@ -4298,59 +4341,6 @@ static void do_code_gen(CodeGen *g) {
42984341 var->value_ref = global_value;
42994342 }
43004343
4301 // Generate function prototypes
4302 for (size_t fn_proto_i = 0; fn_proto_i < g->fn_protos.length; fn_proto_i += 1) {
4303 FnTableEntry *fn_table_entry = g->fn_protos.at(fn_proto_i);
4304
4305 TypeTableEntry *fn_type = fn_table_entry->type_entry;
4306 FnTypeId *fn_type_id = &fn_type->data.fn.fn_type_id;
4307
4308 LLVMValueRef fn_val = fn_llvm_value(g, fn_table_entry);
4309
4310 if (!type_has_bits(fn_type->data.fn.fn_type_id.return_type)) {
4311 // nothing to do
4312 } else if (fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdPointer ||
4313 fn_type->data.fn.fn_type_id.return_type->id == TypeTableEntryIdFn)
4314 {
4315 addLLVMAttr(fn_val, 0, "nonnull");
4316 } else if (handle_is_ptr(fn_type->data.fn.fn_type_id.return_type) &&
4317 calling_convention_does_first_arg_return(fn_type->data.fn.fn_type_id.cc))
4318 {
4319 addLLVMArgAttr(fn_val, 0, "sret");
4320 addLLVMArgAttr(fn_val, 0, "nonnull");
4321 }
4322
4323
4324 // set parameter attributes
4325 for (size_t param_i = 0; param_i < fn_type_id->param_count; param_i += 1) {
4326 FnGenParamInfo *gen_info = &fn_type->data.fn.gen_param_info[param_i];
4327 size_t gen_index = gen_info->gen_index;
4328 bool is_byval = gen_info->is_byval;
4329
4330 if (gen_index == SIZE_MAX) {
4331 continue;
4332 }
4333
4334 FnTypeParamInfo *param_info = &fn_type_id->param_info[param_i];
4335
4336 TypeTableEntry *param_type = gen_info->type;
4337 if (param_info->is_noalias) {
4338 addLLVMArgAttr(fn_val, (unsigned)gen_index, "noalias");
4339 }
4340 if ((param_type->id == TypeTableEntryIdPointer && param_type->data.pointer.is_const) || is_byval) {
4341 addLLVMArgAttr(fn_val, (unsigned)gen_index, "readonly");
4342 }
4343 if (param_type->id == TypeTableEntryIdPointer) {
4344 addLLVMArgAttr(fn_val, (unsigned)gen_index, "nonnull");
4345 }
4346 // Note: byval is disabled on windows due to an LLVM bug:
4347 // https://github.com/zig-lang/zig/issues/536
4348 if (is_byval && g->zig_target.os != ZigLLVM_Win32) {
4349 addLLVMArgAttr(fn_val, (unsigned)gen_index, "byval");
4350 }
4351 }
4352 }
4353
43544344 // Generate function definitions.
43554345 for (size_t fn_i = 0; fn_i < g->fn_defs.length; fn_i += 1) {
43564346 FnTableEntry *fn_table_entry = g->fn_defs.at(fn_i);
src/ir.cpp-1
......@@ -10584,7 +10584,6 @@ static TypeTableEntry *ir_analyze_fn_call(IrAnalyze *ira, IrInstructionCall *cal
1058410584 impl_fn->analyzed_executable.source_node = call_instruction->base.source_node;
1058510585 impl_fn->analyzed_executable.parent_exec = ira->new_irb.exec;
1058610586
10587 ira->codegen->fn_protos.append(impl_fn);
1058810587 ira->codegen->fn_defs.append(impl_fn);
1058910588 }
1059010589