authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-09-09 15:54:03-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-09-09 15:59:16-04:00
logf50bfb94b52424f2145b9a18b731a47b3faf9648
tree9fdc8bc0d1c8d4cfbdcc1a80dbc04a3c52a11d68
parente4c3067617f4be4563a293d58b173742e5b5d0fd
signaturelock-open Commit is signed but in an unrecognized format.

fix bad LLVM IR when for target expr needs to be spilled

Also reduce the size of ZigVar in memory by making the name a `const char *` rather than a `Buf`.

8 files changed, 122 insertions(+), 73 deletions(-)

src/all_types.hpp+2-2
......@@ -2070,7 +2070,7 @@ struct CodeGen {
20702070};
20712071
20722072struct ZigVar {
2073 Buf name;
2073 const char *name;
20742074 ConstExprValue *const_value;
20752075 ZigType *var_type;
20762076 LLVMValueRef value_ref;
......@@ -2085,7 +2085,6 @@ struct ZigVar {
20852085 LLVMValueRef param_value_ref;
20862086 size_t mem_slot_index;
20872087 IrExecutable *owner_exec;
2088 size_t ref_count;
20892088
20902089 // In an inline loop, multiple variables may be created,
20912090 // In this case, a reference to a variable should follow
......@@ -2095,6 +2094,7 @@ struct ZigVar {
20952094 ZigList<GlobalExport> export_list;
20962095
20972096 uint32_t align_bytes;
2097 uint32_t ref_count;
20982098
20992099 bool shadowable;
21002100 bool src_is_const;
src/analyze.cpp+12-12
......@@ -3148,26 +3148,26 @@ ZigType *get_test_fn_type(CodeGen *g) {
31483148 return g->test_fn_type;
31493149}
31503150
3151void add_var_export(CodeGen *g, ZigVar *var, Buf *symbol_name, GlobalLinkageId linkage) {
3151void add_var_export(CodeGen *g, ZigVar *var, const char *symbol_name, GlobalLinkageId linkage) {
31523152 GlobalExport *global_export = var->export_list.add_one();
31533153 memset(global_export, 0, sizeof(GlobalExport));
3154 buf_init_from_buf(&global_export->name, symbol_name);
3154 buf_init_from_str(&global_export->name, symbol_name);
31553155 global_export->linkage = linkage;
31563156}
31573157
3158void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, Buf *symbol_name, GlobalLinkageId linkage, bool ccc) {
3158void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, const char *symbol_name, GlobalLinkageId linkage, bool ccc) {
31593159 if (ccc) {
3160 if (buf_eql_str(symbol_name, "main") && g->libc_link_lib != nullptr) {
3160 if (strcmp(symbol_name, "main") == 0 && g->libc_link_lib != nullptr) {
31613161 g->have_c_main = true;
3162 } else if (buf_eql_str(symbol_name, "WinMain") &&
3162 } else if (strcmp(symbol_name, "WinMain") == 0 &&
31633163 g->zig_target->os == OsWindows)
31643164 {
31653165 g->have_winmain = true;
3166 } else if (buf_eql_str(symbol_name, "WinMainCRTStartup") &&
3166 } else if (strcmp(symbol_name, "WinMainCRTStartup") == 0 &&
31673167 g->zig_target->os == OsWindows)
31683168 {
31693169 g->have_winmain_crt_startup = true;
3170 } else if (buf_eql_str(symbol_name, "DllMainCRTStartup") &&
3170 } else if (strcmp(symbol_name, "DllMainCRTStartup") == 0 &&
31713171 g->zig_target->os == OsWindows)
31723172 {
31733173 g->have_dllmain_crt_startup = true;
......@@ -3176,7 +3176,7 @@ void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, Buf *symbol_name, GlobalLi
31763176
31773177 GlobalExport *fn_export = fn_table_entry->export_list.add_one();
31783178 memset(fn_export, 0, sizeof(GlobalExport));
3179 buf_init_from_buf(&fn_export->name, symbol_name);
3179 buf_init_from_str(&fn_export->name, symbol_name);
31803180 fn_export->linkage = linkage;
31813181}
31823182
......@@ -3200,7 +3200,7 @@ static void resolve_decl_fn(CodeGen *g, TldFn *tld_fn) {
32003200
32013201 if (fn_proto->is_export) {
32023202 bool ccc = (fn_proto->cc == CallingConventionUnspecified || fn_proto->cc == CallingConventionC);
3203 add_fn_export(g, fn_table_entry, &fn_table_entry->symbol_name, GlobalLinkageIdStrong, ccc);
3203 add_fn_export(g, fn_table_entry, buf_ptr(&fn_table_entry->symbol_name), GlobalLinkageIdStrong, ccc);
32043204 }
32053205
32063206 if (!is_extern) {
......@@ -3559,7 +3559,7 @@ ZigVar *add_variable(CodeGen *g, AstNode *source_node, Scope *parent_scope, Buf
35593559 variable_entry->src_arg_index = SIZE_MAX;
35603560
35613561 assert(name);
3562 buf_init_from_buf(&variable_entry->name, name);
3562 variable_entry->name = strdup(buf_ptr(name));
35633563
35643564 if ((err = type_resolve(g, var_type, ResolveStatusAlignmentKnown))) {
35653565 variable_entry->var_type = g->builtin_types.entry_invalid;
......@@ -3707,7 +3707,7 @@ static void resolve_decl_var(CodeGen *g, TldVar *tld_var, bool allow_lazy) {
37073707 }
37083708
37093709 if (is_export) {
3710 add_var_export(g, tld_var->var, &tld_var->var->name, GlobalLinkageIdStrong);
3710 add_var_export(g, tld_var->var, tld_var->var->name, GlobalLinkageIdStrong);
37113711 }
37123712
37133713 g->global_vars.append(tld_var);
......@@ -3916,7 +3916,7 @@ ZigVar *find_variable(CodeGen *g, Scope *scope, Buf *name, ScopeFnDef **crossed_
39163916 while (scope) {
39173917 if (scope->id == ScopeIdVarDecl) {
39183918 ScopeVarDecl *var_scope = (ScopeVarDecl *)scope;
3919 if (buf_eql_buf(name, &var_scope->var->name)) {
3919 if (buf_eql_str(name, var_scope->var->name)) {
39203920 if (crossed_fndef_scope != nullptr)
39213921 *crossed_fndef_scope = my_crossed_fndef_scope;
39223922 return var_scope->var;
src/analyze.hpp+2-2
......@@ -189,8 +189,8 @@ ZigType *get_align_amt_type(CodeGen *g);
189189ZigPackage *new_anonymous_package(void);
190190
191191Buf *const_value_to_buffer(ConstExprValue *const_val);
192void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, Buf *symbol_name, GlobalLinkageId linkage, bool ccc);
193void add_var_export(CodeGen *g, ZigVar *fn_table_entry, Buf *symbol_name, GlobalLinkageId linkage);
192void add_fn_export(CodeGen *g, ZigFn *fn_table_entry, const char *symbol_name, GlobalLinkageId linkage, bool ccc);
193void add_var_export(CodeGen *g, ZigVar *fn_table_entry, const char *symbol_name, GlobalLinkageId linkage);
194194
195195
196196ConstExprValue *get_builtin_value(CodeGen *codegen, const char *name);
src/buffer.hpp+5
......@@ -57,6 +57,11 @@ static inline void buf_deinit(Buf *buf) {
5757 buf->list.deinit();
5858}
5959
60static inline void buf_destroy(Buf *buf) {
61 buf_deinit(buf);
62 free(buf);
63}
64
6065static inline void buf_init_from_mem(Buf *buf, const char *ptr, size_t len) {
6166 assert(len != SIZE_MAX);
6267 buf->list.resize(len + 1);
src/codegen.cpp+50-42
......@@ -234,18 +234,23 @@ static void addLLVMArgAttrInt(LLVMValueRef fn_val, unsigned param_index, const c
234234 return addLLVMAttrInt(fn_val, param_index + 1, attr_name, attr_val);
235235}
236236
237static bool is_symbol_available(CodeGen *g, Buf *name) {
238 return g->exported_symbol_names.maybe_get(name) == nullptr && g->external_prototypes.maybe_get(name) == nullptr;
237static bool is_symbol_available(CodeGen *g, const char *name) {
238 Buf *buf_name = buf_create_from_str(name);
239 bool result =
240 g->exported_symbol_names.maybe_get(buf_name) == nullptr &&
241 g->external_prototypes.maybe_get(buf_name) == nullptr;
242 buf_destroy(buf_name);
243 return result;
239244}
240245
241static Buf *get_mangled_name(CodeGen *g, Buf *original_name, bool external_linkage) {
246static const char *get_mangled_name(CodeGen *g, const char *original_name, bool external_linkage) {
242247 if (external_linkage || is_symbol_available(g, original_name)) {
243248 return original_name;
244249 }
245250
246251 int n = 0;
247252 for (;; n += 1) {
248 Buf *new_name = buf_sprintf("%s.%d", buf_ptr(original_name), n);
253 const char *new_name = buf_ptr(buf_sprintf("%s.%d", original_name, n));
249254 if (is_symbol_available(g, new_name)) {
250255 return new_name;
251256 }
......@@ -387,8 +392,8 @@ static bool codegen_have_frame_pointer(CodeGen *g) {
387392}
388393
389394static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
390 Buf *unmangled_name = &fn->symbol_name;
391 Buf *symbol_name;
395 const char *unmangled_name = buf_ptr(&fn->symbol_name);
396 const char *symbol_name;
392397 GlobalLinkageId linkage;
393398 if (fn->body_node == nullptr) {
394399 symbol_name = unmangled_name;
......@@ -398,7 +403,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
398403 linkage = GlobalLinkageIdInternal;
399404 } else {
400405 GlobalExport *fn_export = &fn->export_list.items[0];
401 symbol_name = &fn_export->name;
406 symbol_name = buf_ptr(&fn_export->name);
402407 linkage = fn_export->linkage;
403408 }
404409
......@@ -408,7 +413,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
408413 g->zig_target->arch == ZigLLVM_x86)
409414 {
410415 // prevent llvm name mangling
411 symbol_name = buf_sprintf("\x01_%s", buf_ptr(symbol_name));
416 symbol_name = buf_ptr(buf_sprintf("\x01_%s", symbol_name));
412417 }
413418
414419 bool is_async = fn_is_async(fn);
......@@ -420,13 +425,16 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
420425 LLVMTypeRef fn_llvm_type = fn->raw_type_ref;
421426 LLVMValueRef llvm_fn = nullptr;
422427 if (fn->body_node == nullptr) {
423 LLVMValueRef existing_llvm_fn = LLVMGetNamedFunction(g->module, buf_ptr(symbol_name));
428 LLVMValueRef existing_llvm_fn = LLVMGetNamedFunction(g->module, symbol_name);
424429 if (existing_llvm_fn) {
425430 return LLVMConstBitCast(existing_llvm_fn, LLVMPointerType(fn_llvm_type, 0));
426431 } else {
427 auto entry = g->exported_symbol_names.maybe_get(symbol_name);
432 Buf *buf_symbol_name = buf_create_from_str(symbol_name);
433 auto entry = g->exported_symbol_names.maybe_get(buf_symbol_name);
434 buf_destroy(buf_symbol_name);
435
428436 if (entry == nullptr) {
429 llvm_fn = LLVMAddFunction(g->module, buf_ptr(symbol_name), fn_llvm_type);
437 llvm_fn = LLVMAddFunction(g->module, symbol_name, fn_llvm_type);
430438
431439 if (target_is_wasm(g->zig_target)) {
432440 assert(fn->proto_node->type == NodeTypeFnProto);
......@@ -440,7 +448,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
440448 TldFn *tld_fn = reinterpret_cast<TldFn *>(entry->value);
441449 // Make the raw_type_ref populated
442450 resolve_llvm_types_fn(g, tld_fn->fn_entry);
443 tld_fn->fn_entry->llvm_value = LLVMAddFunction(g->module, buf_ptr(symbol_name),
451 tld_fn->fn_entry->llvm_value = LLVMAddFunction(g->module, symbol_name,
444452 tld_fn->fn_entry->raw_type_ref);
445453 llvm_fn = LLVMConstBitCast(tld_fn->fn_entry->llvm_value, LLVMPointerType(fn_llvm_type, 0));
446454 return llvm_fn;
......@@ -448,7 +456,7 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
448456 }
449457 } else {
450458 if (llvm_fn == nullptr) {
451 llvm_fn = LLVMAddFunction(g->module, buf_ptr(symbol_name), fn_llvm_type);
459 llvm_fn = LLVMAddFunction(g->module, symbol_name, fn_llvm_type);
452460 }
453461
454462 for (size_t i = 1; i < fn->export_list.length; i += 1) {
......@@ -1058,8 +1066,8 @@ static LLVMValueRef get_add_error_return_trace_addr_fn(CodeGen *g) {
10581066 };
10591067 LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 2, false);
10601068
1061 Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_add_err_ret_trace_addr"), false);
1062 LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
1069 const char *fn_name = get_mangled_name(g, "__zig_add_err_ret_trace_addr", false);
1070 LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
10631071 addLLVMFnAttr(fn_val, "alwaysinline");
10641072 LLVMSetLinkage(fn_val, LLVMInternalLinkage);
10651073 LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
......@@ -1138,8 +1146,8 @@ static LLVMValueRef get_return_err_fn(CodeGen *g) {
11381146 };
11391147 LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 1, false);
11401148
1141 Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_return_error"), false);
1142 LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
1149 const char *fn_name = get_mangled_name(g, "__zig_return_error", false);
1150 LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
11431151 addLLVMFnAttr(fn_val, "noinline"); // so that we can look at return address
11441152 addLLVMFnAttr(fn_val, "cold");
11451153 LLVMSetLinkage(fn_val, LLVMInternalLinkage);
......@@ -1208,7 +1216,7 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
12081216 LLVMSetLinkage(msg_prefix, LLVMInternalLinkage);
12091217 LLVMSetGlobalConstant(msg_prefix, true);
12101218
1211 Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_fail_unwrap"), false);
1219 const char *fn_name = get_mangled_name(g, "__zig_fail_unwrap", false);
12121220 LLVMTypeRef fn_type_ref;
12131221 if (g->have_err_ret_tracing) {
12141222 LLVMTypeRef arg_types[] = {
......@@ -1222,7 +1230,7 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
12221230 };
12231231 fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 1, false);
12241232 }
1225 LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
1233 LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
12261234 addLLVMFnAttr(fn_val, "noreturn");
12271235 addLLVMFnAttr(fn_val, "cold");
12281236 LLVMSetLinkage(fn_val, LLVMInternalLinkage);
......@@ -1805,7 +1813,7 @@ static bool iter_function_params_c_abi(CodeGen *g, ZigType *fn_type, FnWalk *fn_
18051813 fn_walk->data.types.param_di_types->append(get_llvm_di_type(g, ty));
18061814 break;
18071815 case FnWalkIdVars: {
1808 var->value_ref = build_alloca(g, ty, buf_ptr(&var->name), var->align_bytes);
1816 var->value_ref = build_alloca(g, ty, var->name, var->align_bytes);
18091817 di_arg_index = fn_walk->data.vars.gen_i;
18101818 fn_walk->data.vars.gen_i += 1;
18111819 dest_ty = ty;
......@@ -1916,7 +1924,7 @@ static bool iter_function_params_c_abi(CodeGen *g, ZigType *fn_type, FnWalk *fn_
19161924 }
19171925 case FnWalkIdVars: {
19181926 di_arg_index = fn_walk->data.vars.gen_i;
1919 var->value_ref = build_alloca(g, ty, buf_ptr(&var->name), var->align_bytes);
1927 var->value_ref = build_alloca(g, ty, var->name, var->align_bytes);
19201928 fn_walk->data.vars.gen_i += 1;
19211929 dest_ty = ty;
19221930 goto var_ok;
......@@ -1949,7 +1957,7 @@ var_ok:
19491957 if (dest_ty != nullptr && var->decl_node) {
19501958 // arg index + 1 because the 0 index is return value
19511959 var->di_loc_var = ZigLLVMCreateParameterVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
1952 buf_ptr(&var->name), fn_walk->data.vars.import->data.structure.root_struct->di_file,
1960 var->name, fn_walk->data.vars.import->data.structure.root_struct->di_file,
19531961 (unsigned)(var->decl_node->line + 1),
19541962 get_llvm_di_type(g, dest_ty), !g->strip_debug_symbols, 0, di_arg_index + 1);
19551963 }
......@@ -2060,8 +2068,8 @@ static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
20602068 };
20612069 LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), param_types, 2, false);
20622070
2063 Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_merge_error_return_traces"), false);
2064 LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
2071 const char *fn_name = get_mangled_name(g, "__zig_merge_error_return_traces", false);
2072 LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
20652073 LLVMSetLinkage(fn_val, LLVMInternalLinkage);
20662074 LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
20672075 addLLVMFnAttr(fn_val, "nounwind");
......@@ -3743,12 +3751,11 @@ static void render_async_spills(CodeGen *g) {
37433751 continue;
37443752 }
37453753
3746 var->value_ref = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, async_var_index,
3747 buf_ptr(&var->name));
3754 var->value_ref = LLVMBuildStructGEP(g->builder, g->cur_frame_ptr, async_var_index, var->name);
37483755 async_var_index += 1;
37493756 if (var->decl_node) {
37503757 var->di_loc_var = ZigLLVMCreateAutoVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
3751 buf_ptr(&var->name), import->data.structure.root_struct->di_file,
3758 var->name, import->data.structure.root_struct->di_file,
37523759 (unsigned)(var->decl_node->line + 1),
37533760 get_llvm_di_type(g, var->var_type), !g->strip_debug_symbols, 0);
37543761 gen_var_debug_decl(g, var);
......@@ -4653,8 +4660,9 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen *g, ZigType *enum_type) {
46534660 LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMPointerType(get_llvm_type(g, u8_slice_type), 0),
46544661 &tag_int_llvm_type, 1, false);
46554662
4656 Buf *fn_name = get_mangled_name(g, buf_sprintf("__zig_tag_name_%s", buf_ptr(&enum_type->name)), false);
4657 LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
4663 const char *fn_name = get_mangled_name(g,
4664 buf_ptr(buf_sprintf("__zig_tag_name_%s", buf_ptr(&enum_type->name))), false);
4665 LLVMValueRef fn_val = LLVMAddFunction(g->module, fn_name, fn_type_ref);
46584666 LLVMSetLinkage(fn_val, LLVMInternalLinkage);
46594667 LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
46604668 addLLVMFnAttr(fn_val, "nounwind");
......@@ -6919,7 +6927,7 @@ static void generate_error_name_table(CodeGen *g) {
69196927 LLVMValueRef err_name_table_init = LLVMConstArray(get_llvm_type(g, str_type), values, (unsigned)g->errors_by_index.length);
69206928
69216929 g->err_name_table = LLVMAddGlobal(g->module, LLVMTypeOf(err_name_table_init),
6922 buf_ptr(get_mangled_name(g, buf_create_from_str("__zig_err_name_table"), false)));
6930 get_mangled_name(g, buf_ptr(buf_create_from_str("__zig_err_name_table")), false));
69236931 LLVMSetInitializer(g->err_name_table, err_name_table_init);
69246932 LLVMSetLinkage(g->err_name_table, LLVMPrivateLinkage);
69256933 LLVMSetGlobalConstant(g->err_name_table, true);
......@@ -6960,8 +6968,8 @@ static void gen_global_var(CodeGen *g, ZigVar *var, LLVMValueRef init_val,
69606968 assert(import);
69616969
69626970 bool is_local_to_unit = true;
6963 ZigLLVMCreateGlobalVariable(g->dbuilder, get_di_scope(g, var->parent_scope), buf_ptr(&var->name),
6964 buf_ptr(&var->name), import->data.structure.root_struct->di_file,
6971 ZigLLVMCreateGlobalVariable(g->dbuilder, get_di_scope(g, var->parent_scope), var->name,
6972 var->name, import->data.structure.root_struct->di_file,
69656973 (unsigned)(var->decl_node->line + 1),
69666974 get_llvm_di_type(g, type_entry), is_local_to_unit);
69676975
......@@ -7043,8 +7051,8 @@ static void do_code_gen(CodeGen *g) {
70437051 assert(var->decl_node);
70447052
70457053 GlobalLinkageId linkage;
7046 Buf *unmangled_name = &var->name;
7047 Buf *symbol_name;
7054 const char *unmangled_name = var->name;
7055 const char *symbol_name;
70487056 if (var->export_list.length == 0) {
70497057 if (var->decl_node->data.variable_declaration.is_extern) {
70507058 symbol_name = unmangled_name;
......@@ -7055,19 +7063,19 @@ static void do_code_gen(CodeGen *g) {
70557063 }
70567064 } else {
70577065 GlobalExport *global_export = &var->export_list.items[0];
7058 symbol_name = &global_export->name;
7066 symbol_name = buf_ptr(&global_export->name);
70597067 linkage = global_export->linkage;
70607068 }
70617069
70627070 LLVMValueRef global_value;
70637071 bool externally_initialized = var->decl_node->data.variable_declaration.expr == nullptr;
70647072 if (externally_initialized) {
7065 LLVMValueRef existing_llvm_var = LLVMGetNamedGlobal(g->module, buf_ptr(symbol_name));
7073 LLVMValueRef existing_llvm_var = LLVMGetNamedGlobal(g->module, symbol_name);
70667074 if (existing_llvm_var) {
70677075 global_value = LLVMConstBitCast(existing_llvm_var,
70687076 LLVMPointerType(get_llvm_type(g, var->var_type), 0));
70697077 } else {
7070 global_value = LLVMAddGlobal(g->module, get_llvm_type(g, var->var_type), buf_ptr(symbol_name));
7078 global_value = LLVMAddGlobal(g->module, get_llvm_type(g, var->var_type), symbol_name);
70717079 // TODO debug info for the extern variable
70727080
70737081 LLVMSetLinkage(global_value, to_llvm_linkage(linkage));
......@@ -7078,8 +7086,8 @@ static void do_code_gen(CodeGen *g) {
70787086 }
70797087 } else {
70807088 bool exported = (linkage != GlobalLinkageIdInternal);
7081 render_const_val(g, var->const_value, buf_ptr(symbol_name));
7082 render_const_val_global(g, var->const_value, buf_ptr(symbol_name));
7089 render_const_val(g, var->const_value, symbol_name);
7090 render_const_val_global(g, var->const_value, symbol_name);
70837091 global_value = var->const_value->global_refs->llvm_global;
70847092
70857093 if (exported) {
......@@ -7234,7 +7242,7 @@ static void do_code_gen(CodeGen *g) {
72347242
72357243 if (var->src_arg_index == SIZE_MAX) {
72367244 var->di_loc_var = ZigLLVMCreateAutoVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
7237 buf_ptr(&var->name), import->data.structure.root_struct->di_file, (unsigned)(var->decl_node->line + 1),
7245 var->name, import->data.structure.root_struct->di_file, (unsigned)(var->decl_node->line + 1),
72387246 get_llvm_di_type(g, var->var_type), !g->strip_debug_symbols, 0);
72397247
72407248 } else if (is_c_abi) {
......@@ -7254,11 +7262,11 @@ static void do_code_gen(CodeGen *g) {
72547262 var->value_ref = LLVMGetParam(fn, gen_info->gen_index);
72557263 } else {
72567264 gen_type = var->var_type;
7257 var->value_ref = build_alloca(g, var->var_type, buf_ptr(&var->name), var->align_bytes);
7265 var->value_ref = build_alloca(g, var->var_type, var->name, var->align_bytes);
72587266 }
72597267 if (var->decl_node) {
72607268 var->di_loc_var = ZigLLVMCreateParameterVariable(g->dbuilder, get_di_scope(g, var->parent_scope),
7261 buf_ptr(&var->name), import->data.structure.root_struct->di_file,
7269 var->name, import->data.structure.root_struct->di_file,
72627270 (unsigned)(var->decl_node->line + 1),
72637271 get_llvm_di_type(g, gen_type), !g->strip_debug_symbols, 0, (unsigned)(gen_info->gen_index+1));
72647272 }
src/ir.cpp+16-12
......@@ -3628,7 +3628,7 @@ static ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_s
36283628 }
36293629
36303630 if (name) {
3631 buf_init_from_buf(&variable_entry->name, name);
3631 variable_entry->name = strdup(buf_ptr(name));
36323632
36333633 if (!skip_name_check) {
36343634 ZigVar *existing_var = find_variable(codegen, parent_scope, name, nullptr);
......@@ -3661,7 +3661,7 @@ static ZigVar *create_local_var(CodeGen *codegen, AstNode *node, Scope *parent_s
36613661 // TODO make this name not actually be in scope. user should be able to make a variable called "_anon"
36623662 // might already be solved, let's just make sure it has test coverage
36633663 // maybe we put a prefix on this so the debug info doesn't clobber user debug info for same named variables
3664 buf_init_from_str(&variable_entry->name, "_anon");
3664 variable_entry->name = "_anon";
36653665 }
36663666
36673667 variable_entry->src_is_const = src_is_const;
......@@ -6467,15 +6467,15 @@ static IrInstruction *ir_gen_for_expr(IrBuilder *irb, Scope *parent_scope, AstNo
64676467 }
64686468 assert(elem_node->type == NodeTypeSymbol);
64696469
6470 IrInstruction *array_val_ptr = ir_gen_node_extra(irb, array_node, parent_scope, LValPtr, nullptr);
6470 ScopeExpr *spill_scope = create_expr_scope(irb->codegen, node, parent_scope);
6471
6472 IrInstruction *array_val_ptr = ir_gen_node_extra(irb, array_node, &spill_scope->base, LValPtr, nullptr);
64716473 if (array_val_ptr == irb->codegen->invalid_instruction)
64726474 return array_val_ptr;
64736475
64746476 IrInstruction *is_comptime = ir_build_const_bool(irb, parent_scope, node,
64756477 ir_should_inline(irb->exec, parent_scope) || node->data.for_expr.is_inline);
64766478
6477 ScopeExpr *spill_scope = create_expr_scope(irb->codegen, node, parent_scope);
6478
64796479 AstNode *index_var_source_node;
64806480 ZigVar *index_var;
64816481 const char *index_var_name;
......@@ -14559,7 +14559,8 @@ static IrInstruction *ir_analyze_instruction_decl_var(IrAnalyze *ira,
1455914559 // We make a new variable so that it can hold a different type, and so the debug info can
1456014560 // be distinct.
1456114561 ZigVar *new_var = create_local_var(ira->codegen, var->decl_node, var->child_scope,
14562 &var->name, var->src_is_const, var->gen_is_const, var->shadowable, var->is_comptime, true);
14562 buf_create_from_str(var->name), var->src_is_const, var->gen_is_const,
14563 var->shadowable, var->is_comptime, true);
1456314564 new_var->owner_exec = var->owner_exec;
1456414565 new_var->align_bytes = var->align_bytes;
1456514566 if (var->mem_slot_index != SIZE_MAX) {
......@@ -14702,7 +14703,8 @@ static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructio
1470214703 case CallingConventionNaked:
1470314704 case CallingConventionCold:
1470414705 case CallingConventionStdcall:
14705 add_fn_export(ira->codegen, fn_entry, symbol_name, global_linkage_id, cc == CallingConventionC);
14706 add_fn_export(ira->codegen, fn_entry, buf_ptr(symbol_name), global_linkage_id,
14707 cc == CallingConventionC);
1470614708 break;
1470714709 }
1470814710 } break;
......@@ -14840,7 +14842,7 @@ static IrInstruction *ir_analyze_instruction_export(IrAnalyze *ira, IrInstructio
1484014842 if (load_ptr->ptr->id == IrInstructionIdVarPtr) {
1484114843 IrInstructionVarPtr *var_ptr = reinterpret_cast<IrInstructionVarPtr *>(load_ptr->ptr);
1484214844 ZigVar *var = var_ptr->var;
14843 add_var_export(ira->codegen, var, symbol_name, global_linkage_id);
14845 add_var_export(ira->codegen, var, buf_ptr(symbol_name), global_linkage_id);
1484414846 }
1484514847 }
1484614848
......@@ -17023,7 +17025,7 @@ static IrInstruction *ir_analyze_instruction_var_ptr(IrAnalyze *ira, IrInstructi
1702317025 IrInstruction *result = ir_get_var_ptr(ira, &instruction->base, var);
1702417026 if (instruction->crossed_fndef_scope != nullptr && !instr_is_comptime(result)) {
1702517027 ErrorMsg *msg = ir_add_error(ira, &instruction->base,
17026 buf_sprintf("'%s' not accessible from inner function", buf_ptr(&var->name)));
17028 buf_sprintf("'%s' not accessible from inner function", var->name));
1702717029 add_error_note(ira->codegen, msg, instruction->crossed_fndef_scope->base.source_node,
1702817030 buf_sprintf("crossed function definition here"));
1702917031 add_error_note(ira->codegen, msg, var->decl_node,
......@@ -17735,7 +17737,8 @@ static IrInstruction *ir_analyze_decl_ref(IrAnalyze *ira, IrInstruction *source_
1773517737 return ir_error_dependency_loop(ira, source_instruction);
1773617738 }
1773717739 if (tld_var->extern_lib_name != nullptr) {
17738 add_link_lib_symbol(ira, tld_var->extern_lib_name, &var->name, source_instruction->source_node);
17740 add_link_lib_symbol(ira, tld_var->extern_lib_name, buf_create_from_str(var->name),
17741 source_instruction->source_node);
1773917742 }
1774017743
1774117744 return ir_get_var_ptr(ira, source_instruction, var);
......@@ -20189,8 +20192,9 @@ static Error ir_make_type_info_decls(IrAnalyze *ira, IrInstruction *source_instr
2018920192 for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++) {
2019020193 ZigVar *arg_var = fn_entry->variable_list.at(fn_arg_index);
2019120194 ConstExprValue *fn_arg_name_val = &fn_arg_name_array->data.x_array.data.s_none.elements[fn_arg_index];
20192 ConstExprValue *arg_name = create_const_str_lit(ira->codegen, &arg_var->name);
20193 init_const_slice(ira->codegen, fn_arg_name_val, arg_name, 0, buf_len(&arg_var->name), true);
20195 ConstExprValue *arg_name = create_const_str_lit(ira->codegen,
20196 buf_create_from_str(arg_var->name));
20197 init_const_slice(ira->codegen, fn_arg_name_val, arg_name, 0, strlen(arg_var->name), true);
2019420198 fn_arg_name_val->parent.id = ConstParentIdArray;
2019520199 fn_arg_name_val->parent.data.p_array.array_val = fn_arg_name_array;
2019620200 fn_arg_name_val->parent.data.p_array.elem_index = fn_arg_index;
src/ir_print.cpp+3-3
......@@ -531,7 +531,7 @@ static void ir_print_bin_op(IrPrint *irp, IrInstructionBinOp *bin_op_instruction
531531
532532static void ir_print_decl_var_src(IrPrint *irp, IrInstructionDeclVarSrc *decl_var_instruction) {
533533 const char *var_or_const = decl_var_instruction->var->gen_is_const ? "const" : "var";
534 const char *name = buf_ptr(&decl_var_instruction->var->name);
534 const char *name = decl_var_instruction->var->name;
535535 if (decl_var_instruction->var_type) {
536536 fprintf(irp->f, "%s %s: ", var_or_const, name);
537537 ir_print_other_instruction(irp, decl_var_instruction->var_type);
......@@ -747,7 +747,7 @@ static void ir_print_elem_ptr(IrPrint *irp, IrInstructionElemPtr *instruction) {
747747}
748748
749749static void ir_print_var_ptr(IrPrint *irp, IrInstructionVarPtr *instruction) {
750 fprintf(irp->f, "&%s", buf_ptr(&instruction->var->name));
750 fprintf(irp->f, "&%s", instruction->var->name);
751751}
752752
753753static void ir_print_return_ptr(IrPrint *irp, IrInstructionReturnPtr *instruction) {
......@@ -1852,7 +1852,7 @@ static void ir_print_mul_add(IrPrint *irp, IrInstructionMulAdd *instruction) {
18521852static void ir_print_decl_var_gen(IrPrint *irp, IrInstructionDeclVarGen *decl_var_instruction) {
18531853 ZigVar *var = decl_var_instruction->var;
18541854 const char *var_or_const = decl_var_instruction->var->gen_is_const ? "const" : "var";
1855 const char *name = buf_ptr(&decl_var_instruction->var->name);
1855 const char *name = decl_var_instruction->var->name;
18561856 fprintf(irp->f, "%s %s: %s align(%u) = ", var_or_const, name, buf_ptr(&var->var_type->name),
18571857 var->align_bytes);
18581858
test/stage1/behavior/async_fn.zig+32
......@@ -1201,3 +1201,35 @@ test "correctly spill when returning the error union result of another async fn"
12011201 resume S.global_frame;
12021202}
12031203
1204
1205test "spill target expr in a for loop" {
1206 const S = struct {
1207 var global_frame: anyframe = undefined;
1208
1209 fn doTheTest() void {
1210 var foo = Foo{
1211 .slice = [_]i32{1, 2},
1212 };
1213 expect(atest(&foo) == 3);
1214 }
1215
1216 const Foo = struct {
1217 slice: []i32,
1218 };
1219
1220 fn atest(foo: *Foo) i32 {
1221 var sum: i32 = 0;
1222 for (foo.slice) |x| {
1223 suspend {
1224 global_frame = @frame();
1225 }
1226 sum += x;
1227 }
1228 return sum;
1229 }
1230 };
1231 _ = async S.doTheTest();
1232 resume S.global_frame;
1233 resume S.global_frame;
1234}
1235