authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-07-22 12:15:16-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-07-22 12:41:59-04:00
logbc31c1280e012377c3a2b00356a5876919a72775
tree67fedc2512a3471c8c2b57954ef3424636d0ddc4
parenta3327f0fbde0f7eebd6260bb5f47897599434bb4
signaturelock-open Commit is signed but in an unrecognized format.

disable segfault handler when panicking

this prevents a segfault in stack trace printing to activate the segfault handler.

6 files changed, 192 insertions(+), 172 deletions(-)

src/codegen.cpp+141-136
......@@ -89,126 +89,6 @@ static const char *symbols_that_llvm_depends_on[] = {
8989 // TODO probably all of compiler-rt needs to go here
9090};
9191
92CodeGen *codegen_create(Buf *main_pkg_path, Buf *root_src_path, const ZigTarget *target,
93 OutType out_type, BuildMode build_mode, Buf *override_lib_dir, Buf *override_std_dir,
94 ZigLibCInstallation *libc, Buf *cache_dir)
95{
96 CodeGen *g = allocate<CodeGen>(1);
97
98 codegen_add_time_event(g, "Initialize");
99
100 g->subsystem = TargetSubsystemAuto;
101 g->libc = libc;
102 g->zig_target = target;
103 g->cache_dir = cache_dir;
104
105 if (override_lib_dir == nullptr) {
106 g->zig_lib_dir = get_zig_lib_dir();
107 } else {
108 g->zig_lib_dir = override_lib_dir;
109 }
110
111 if (override_std_dir == nullptr) {
112 g->zig_std_dir = buf_alloc();
113 os_path_join(g->zig_lib_dir, buf_create_from_str("std"), g->zig_std_dir);
114 } else {
115 g->zig_std_dir = override_std_dir;
116 }
117
118 g->zig_c_headers_dir = buf_alloc();
119 os_path_join(g->zig_lib_dir, buf_create_from_str("include"), g->zig_c_headers_dir);
120
121 g->build_mode = build_mode;
122 g->out_type = out_type;
123 g->import_table.init(32);
124 g->builtin_fn_table.init(32);
125 g->primitive_type_table.init(32);
126 g->type_table.init(32);
127 g->fn_type_table.init(32);
128 g->error_table.init(16);
129 g->generic_table.init(16);
130 g->llvm_fn_table.init(16);
131 g->memoized_fn_eval_table.init(16);
132 g->exported_symbol_names.init(8);
133 g->external_prototypes.init(8);
134 g->string_literals_table.init(16);
135 g->type_info_cache.init(32);
136 g->is_test_build = false;
137 g->is_single_threaded = false;
138 buf_resize(&g->global_asm, 0);
139
140 for (size_t i = 0; i < array_length(symbols_that_llvm_depends_on); i += 1) {
141 g->external_prototypes.put(buf_create_from_str(symbols_that_llvm_depends_on[i]), nullptr);
142 }
143
144 if (root_src_path) {
145 Buf *root_pkg_path;
146 Buf *rel_root_src_path;
147 if (main_pkg_path == nullptr) {
148 Buf *src_basename = buf_alloc();
149 Buf *src_dir = buf_alloc();
150 os_path_split(root_src_path, src_dir, src_basename);
151
152 if (buf_len(src_basename) == 0) {
153 fprintf(stderr, "Invalid root source path: %s\n", buf_ptr(root_src_path));
154 exit(1);
155 }
156 root_pkg_path = src_dir;
157 rel_root_src_path = src_basename;
158 } else {
159 Buf resolved_root_src_path = os_path_resolve(&root_src_path, 1);
160 Buf resolved_main_pkg_path = os_path_resolve(&main_pkg_path, 1);
161
162 if (!buf_starts_with_buf(&resolved_root_src_path, &resolved_main_pkg_path)) {
163 fprintf(stderr, "Root source path '%s' outside main package path '%s'",
164 buf_ptr(root_src_path), buf_ptr(main_pkg_path));
165 exit(1);
166 }
167 root_pkg_path = main_pkg_path;
168 rel_root_src_path = buf_create_from_mem(
169 buf_ptr(&resolved_root_src_path) + buf_len(&resolved_main_pkg_path) + 1,
170 buf_len(&resolved_root_src_path) - buf_len(&resolved_main_pkg_path) - 1);
171 }
172
173 g->root_package = new_package(buf_ptr(root_pkg_path), buf_ptr(rel_root_src_path), "");
174 g->std_package = new_package(buf_ptr(g->zig_std_dir), "std.zig", "std");
175 g->root_package->package_table.put(buf_create_from_str("std"), g->std_package);
176 } else {
177 g->root_package = new_package(".", "", "");
178 }
179
180 g->root_package->package_table.put(buf_create_from_str("root"), g->root_package);
181
182 g->zig_std_special_dir = buf_alloc();
183 os_path_join(g->zig_std_dir, buf_sprintf("special"), g->zig_std_special_dir);
184
185 assert(target != nullptr);
186 if (!target->is_native) {
187 g->each_lib_rpath = false;
188 } else {
189 g->each_lib_rpath = true;
190
191 if (target_os_is_darwin(g->zig_target->os)) {
192 init_darwin_native(g);
193 }
194
195 }
196
197 if (target_os_requires_libc(g->zig_target->os)) {
198 g->libc_link_lib = create_link_lib(buf_create_from_str("c"));
199 g->link_libs_list.append(g->libc_link_lib);
200 }
201
202 target_triple_llvm(&g->llvm_triple_str, g->zig_target);
203 g->pointer_size_bytes = target_arch_pointer_bit_width(g->zig_target->arch) / 8;
204
205 if (!target_has_debug_info(g->zig_target)) {
206 g->strip_debug_symbols = true;
207 }
208
209 return g;
210}
211
21292void codegen_set_clang_argv(CodeGen *g, const char **args, size_t len) {
21393 g->clang_argv = args;
21494 g->clang_argv_len = len;
......@@ -233,10 +113,6 @@ void codegen_set_lib_version(CodeGen *g, size_t major, size_t minor, size_t patc
233113 g->version_patch = patch;
234114}
235115
236void codegen_set_is_test(CodeGen *g, bool is_test_build) {
237 g->is_test_build = is_test_build;
238}
239
240116void codegen_set_emit_file_type(CodeGen *g, EmitFileType emit_file_type) {
241117 g->emit_file_type = emit_file_type;
242118}
......@@ -7994,6 +7870,14 @@ Buf *codegen_generate_builtin_source(CodeGen *g) {
79947870 return contents;
79957871}
79967872
7873static ZigPackage *create_test_runner_pkg(CodeGen *g) {
7874 return codegen_create_package(g, buf_ptr(g->zig_std_special_dir), "test_runner.zig", "std.special");
7875}
7876
7877static ZigPackage *create_panic_pkg(CodeGen *g) {
7878 return codegen_create_package(g, buf_ptr(g->zig_std_special_dir), "panic.zig", "std.special");
7879}
7880
79977881static Error define_builtin_compile_vars(CodeGen *g) {
79987882 if (g->std_package == nullptr)
79997883 return ErrorNone;
......@@ -8078,8 +7962,16 @@ static Error define_builtin_compile_vars(CodeGen *g) {
80787962 g->root_package->package_table.put(buf_create_from_str("builtin"), g->compile_var_package);
80797963 g->std_package->package_table.put(buf_create_from_str("builtin"), g->compile_var_package);
80807964 g->std_package->package_table.put(buf_create_from_str("std"), g->std_package);
8081 g->std_package->package_table.put(buf_create_from_str("root"),
8082 g->is_test_build ? g->test_runner_package : g->root_package);
7965 ZigPackage *root_pkg;
7966 if (g->is_test_build) {
7967 if (g->test_runner_package == nullptr) {
7968 g->test_runner_package = create_test_runner_pkg(g);
7969 }
7970 root_pkg = g->test_runner_package;
7971 } else {
7972 root_pkg = g->root_package;
7973 }
7974 g->std_package->package_table.put(buf_create_from_str("root"), root_pkg);
80837975 g->compile_var_import = add_source_file(g, g->compile_var_package, builtin_zig_path, contents,
80847976 SourceKindPkgMain);
80857977
......@@ -8571,14 +8463,6 @@ static ZigPackage *create_start_pkg(CodeGen *g, ZigPackage *pkg_with_main) {
85718463 return package;
85728464}
85738465
8574static ZigPackage *create_test_runner_pkg(CodeGen *g) {
8575 return codegen_create_package(g, buf_ptr(g->zig_std_special_dir), "test_runner.zig", "std.special");
8576}
8577
8578static ZigPackage *create_panic_pkg(CodeGen *g) {
8579 return codegen_create_package(g, buf_ptr(g->zig_std_special_dir), "panic.zig", "std.special");
8580}
8581
85828466static void create_test_compile_var_and_add_test_runner(CodeGen *g) {
85838467 Error err;
85848468
......@@ -8628,7 +8512,7 @@ static void create_test_compile_var_and_add_test_runner(CodeGen *g) {
86288512 ConstExprValue *test_fn_slice = create_const_slice(g, test_fn_array, 0, g->test_fns.length, true);
86298513
86308514 update_compile_var(g, buf_create_from_str("test_functions"), test_fn_slice);
8631 g->test_runner_package = create_test_runner_pkg(g);
8515 assert(g->test_runner_package != nullptr);
86328516 g->test_runner_import = add_special_code(g, g->test_runner_package, "test_runner.zig");
86338517}
86348518
......@@ -9742,7 +9626,8 @@ CodeGen *create_child_codegen(CodeGen *parent_gen, Buf *root_src_path, OutType o
97429626 ZigLibCInstallation *libc)
97439627{
97449628 CodeGen *child_gen = codegen_create(nullptr, root_src_path, parent_gen->zig_target, out_type,
9745 parent_gen->build_mode, parent_gen->zig_lib_dir, parent_gen->zig_std_dir, libc, get_stage1_cache_path());
9629 parent_gen->build_mode, parent_gen->zig_lib_dir, parent_gen->zig_std_dir, libc, get_stage1_cache_path(),
9630 false);
97469631 child_gen->disable_gen_h = true;
97479632 child_gen->want_stack_check = WantStackCheckDisabled;
97489633 child_gen->verbose_tokenize = parent_gen->verbose_tokenize;
......@@ -9769,3 +9654,123 @@ CodeGen *create_child_codegen(CodeGen *parent_gen, Buf *root_src_path, OutType o
97699654 return child_gen;
97709655}
97719656
9657CodeGen *codegen_create(Buf *main_pkg_path, Buf *root_src_path, const ZigTarget *target,
9658 OutType out_type, BuildMode build_mode, Buf *override_lib_dir, Buf *override_std_dir,
9659 ZigLibCInstallation *libc, Buf *cache_dir, bool is_test_build)
9660{
9661 CodeGen *g = allocate<CodeGen>(1);
9662
9663 codegen_add_time_event(g, "Initialize");
9664
9665 g->subsystem = TargetSubsystemAuto;
9666 g->libc = libc;
9667 g->zig_target = target;
9668 g->cache_dir = cache_dir;
9669
9670 if (override_lib_dir == nullptr) {
9671 g->zig_lib_dir = get_zig_lib_dir();
9672 } else {
9673 g->zig_lib_dir = override_lib_dir;
9674 }
9675
9676 if (override_std_dir == nullptr) {
9677 g->zig_std_dir = buf_alloc();
9678 os_path_join(g->zig_lib_dir, buf_create_from_str("std"), g->zig_std_dir);
9679 } else {
9680 g->zig_std_dir = override_std_dir;
9681 }
9682
9683 g->zig_c_headers_dir = buf_alloc();
9684 os_path_join(g->zig_lib_dir, buf_create_from_str("include"), g->zig_c_headers_dir);
9685
9686 g->build_mode = build_mode;
9687 g->out_type = out_type;
9688 g->import_table.init(32);
9689 g->builtin_fn_table.init(32);
9690 g->primitive_type_table.init(32);
9691 g->type_table.init(32);
9692 g->fn_type_table.init(32);
9693 g->error_table.init(16);
9694 g->generic_table.init(16);
9695 g->llvm_fn_table.init(16);
9696 g->memoized_fn_eval_table.init(16);
9697 g->exported_symbol_names.init(8);
9698 g->external_prototypes.init(8);
9699 g->string_literals_table.init(16);
9700 g->type_info_cache.init(32);
9701 g->is_test_build = is_test_build;
9702 g->is_single_threaded = false;
9703 buf_resize(&g->global_asm, 0);
9704
9705 for (size_t i = 0; i < array_length(symbols_that_llvm_depends_on); i += 1) {
9706 g->external_prototypes.put(buf_create_from_str(symbols_that_llvm_depends_on[i]), nullptr);
9707 }
9708
9709 if (root_src_path) {
9710 Buf *root_pkg_path;
9711 Buf *rel_root_src_path;
9712 if (main_pkg_path == nullptr) {
9713 Buf *src_basename = buf_alloc();
9714 Buf *src_dir = buf_alloc();
9715 os_path_split(root_src_path, src_dir, src_basename);
9716
9717 if (buf_len(src_basename) == 0) {
9718 fprintf(stderr, "Invalid root source path: %s\n", buf_ptr(root_src_path));
9719 exit(1);
9720 }
9721 root_pkg_path = src_dir;
9722 rel_root_src_path = src_basename;
9723 } else {
9724 Buf resolved_root_src_path = os_path_resolve(&root_src_path, 1);
9725 Buf resolved_main_pkg_path = os_path_resolve(&main_pkg_path, 1);
9726
9727 if (!buf_starts_with_buf(&resolved_root_src_path, &resolved_main_pkg_path)) {
9728 fprintf(stderr, "Root source path '%s' outside main package path '%s'",
9729 buf_ptr(root_src_path), buf_ptr(main_pkg_path));
9730 exit(1);
9731 }
9732 root_pkg_path = main_pkg_path;
9733 rel_root_src_path = buf_create_from_mem(
9734 buf_ptr(&resolved_root_src_path) + buf_len(&resolved_main_pkg_path) + 1,
9735 buf_len(&resolved_root_src_path) - buf_len(&resolved_main_pkg_path) - 1);
9736 }
9737
9738 g->root_package = new_package(buf_ptr(root_pkg_path), buf_ptr(rel_root_src_path), "");
9739 g->std_package = new_package(buf_ptr(g->zig_std_dir), "std.zig", "std");
9740 g->root_package->package_table.put(buf_create_from_str("std"), g->std_package);
9741 } else {
9742 g->root_package = new_package(".", "", "");
9743 }
9744
9745 g->root_package->package_table.put(buf_create_from_str("root"), g->root_package);
9746
9747 g->zig_std_special_dir = buf_alloc();
9748 os_path_join(g->zig_std_dir, buf_sprintf("special"), g->zig_std_special_dir);
9749
9750 assert(target != nullptr);
9751 if (!target->is_native) {
9752 g->each_lib_rpath = false;
9753 } else {
9754 g->each_lib_rpath = true;
9755
9756 if (target_os_is_darwin(g->zig_target->os)) {
9757 init_darwin_native(g);
9758 }
9759
9760 }
9761
9762 if (target_os_requires_libc(g->zig_target->os)) {
9763 g->libc_link_lib = create_link_lib(buf_create_from_str("c"));
9764 g->link_libs_list.append(g->libc_link_lib);
9765 }
9766
9767 target_triple_llvm(&g->llvm_triple_str, g->zig_target);
9768 g->pointer_size_bytes = target_arch_pointer_bit_width(g->zig_target->arch) / 8;
9769
9770 if (!target_has_debug_info(g->zig_target)) {
9771 g->strip_debug_symbols = true;
9772 }
9773
9774 return g;
9775}
9776
src/codegen.hpp+1-2
......@@ -18,14 +18,13 @@
1818
1919CodeGen *codegen_create(Buf *main_pkg_path, Buf *root_src_path, const ZigTarget *target,
2020 OutType out_type, BuildMode build_mode, Buf *zig_lib_dir, Buf *override_std_dir,
21 ZigLibCInstallation *libc, Buf *cache_dir);
21 ZigLibCInstallation *libc, Buf *cache_dir, bool is_test_build);
2222
2323CodeGen *create_child_codegen(CodeGen *parent_gen, Buf *root_src_path, OutType out_type,
2424 ZigLibCInstallation *libc);
2525
2626void codegen_set_clang_argv(CodeGen *codegen, const char **args, size_t len);
2727void codegen_set_llvm_argv(CodeGen *codegen, const char **args, size_t len);
28void codegen_set_is_test(CodeGen *codegen, bool is_test);
2928void codegen_set_each_lib_rpath(CodeGen *codegen, bool each_lib_rpath);
3029
3130void codegen_set_emit_file_type(CodeGen *g, EmitFileType emit_file_type);
src/main.cpp+3-4
......@@ -583,7 +583,7 @@ int main(int argc, char **argv) {
583583 }
584584
585585 CodeGen *g = codegen_create(main_pkg_path, build_runner_path, &target, OutTypeExe,
586 BuildModeDebug, override_lib_dir, override_std_dir, nullptr, &full_cache_dir);
586 BuildModeDebug, override_lib_dir, override_std_dir, nullptr, &full_cache_dir, false);
587587 g->valgrind_support = valgrind_support;
588588 g->enable_time_report = timing_info;
589589 codegen_set_out_name(g, buf_create_from_str("build"));
......@@ -1011,7 +1011,7 @@ int main(int argc, char **argv) {
10111011 }
10121012 case CmdBuiltin: {
10131013 CodeGen *g = codegen_create(main_pkg_path, nullptr, &target,
1014 out_type, build_mode, override_lib_dir, override_std_dir, nullptr, nullptr);
1014 out_type, build_mode, override_lib_dir, override_std_dir, nullptr, nullptr, false);
10151015 codegen_set_strip(g, strip);
10161016 for (size_t i = 0; i < link_libs.length; i += 1) {
10171017 LinkLib *link_lib = codegen_add_link_lib(g, buf_create_from_str(link_libs.at(i)));
......@@ -1115,7 +1115,7 @@ int main(int argc, char **argv) {
11151115 cache_dir_buf = buf_create_from_str(cache_dir);
11161116 }
11171117 CodeGen *g = codegen_create(main_pkg_path, zig_root_source_file, &target, out_type, build_mode,
1118 override_lib_dir, override_std_dir, libc, cache_dir_buf);
1118 override_lib_dir, override_std_dir, libc, cache_dir_buf, cmd == CmdTest);
11191119 if (llvm_argv.length >= 2) codegen_set_llvm_argv(g, llvm_argv.items + 1, llvm_argv.length - 2);
11201120 g->valgrind_support = valgrind_support;
11211121 g->want_pic = want_pic;
......@@ -1125,7 +1125,6 @@ int main(int argc, char **argv) {
11251125 g->enable_time_report = timing_info;
11261126 codegen_set_out_name(g, buf_out_name);
11271127 codegen_set_lib_version(g, ver_major, ver_minor, ver_patch);
1128 codegen_set_is_test(g, cmd == CmdTest);
11291128 g->want_single_threaded = want_single_threaded;
11301129 codegen_set_linker_script(g, linker_script);
11311130 g->version_script_path = version_script;
std/debug.zig+44-18
......@@ -12,6 +12,7 @@ const coff = std.coff;
1212const pdb = std.pdb;
1313const ArrayList = std.ArrayList;
1414const builtin = @import("builtin");
15const root = @import("root");
1516const maxInt = std.math.maxInt;
1617const File = std.fs.File;
1718const windows = std.os.windows;
......@@ -217,6 +218,12 @@ var panicking: u8 = 0; // TODO make this a bool
217218pub fn panicExtra(trace: ?*const builtin.StackTrace, first_trace_addr: ?usize, comptime format: []const u8, args: ...) noreturn {
218219 @setCold(true);
219220
221 if (enable_segfault_handler) {
222 // If a segfault happens while panicking, we want it to actually segfault, not trigger
223 // the handler.
224 resetSegfaultHandler();
225 }
226
220227 if (@atomicRmw(u8, &panicking, builtin.AtomicRmwOp.Xchg, 1, builtin.AtomicOrder.SeqCst) == 1) {
221228 // Panicked during a panic.
222229
......@@ -2312,39 +2319,58 @@ fn getDebugInfoAllocator() *mem.Allocator {
23122319
23132320/// Whether or not the current target can print useful debug information when a segfault occurs.
23142321pub const have_segfault_handling_support = (builtin.arch == builtin.Arch.x86_64 and builtin.os == .linux) or builtin.os == .windows;
2322pub const enable_segfault_handler: bool = if (@hasDecl(root, "enable_segfault_handler"))
2323 root.enable_segfault_handler
2324else
2325 runtime_safety and have_segfault_handling_support;
2326
2327pub fn maybeEnableSegfaultHandler() void {
2328 if (enable_segfault_handler) {
2329 std.debug.attachSegfaultHandler();
2330 }
2331}
2332
2333var windows_segfault_handle: ?windows.HANDLE = null;
23152334
23162335/// Attaches a global SIGSEGV handler which calls @panic("segmentation fault");
23172336pub fn attachSegfaultHandler() void {
23182337 if (!have_segfault_handling_support) {
23192338 @compileError("segfault handler not supported for this target");
23202339 }
2321 switch (builtin.os) {
2322 .linux => {
2323 var act = os.Sigaction{
2324 .sigaction = handleSegfaultLinux,
2325 .mask = os.empty_sigset,
2326 .flags = (os.SA_SIGINFO | os.SA_RESTART | os.SA_RESETHAND),
2327 };
2328
2329 os.sigaction(os.SIGSEGV, &act, null);
2330 },
2331 .windows => {
2332 _ = windows.kernel32.AddVectoredExceptionHandler(0, handleSegfaultWindows);
2333 },
2334 else => unreachable,
2340 if (windows.is_the_target) {
2341 windows_segfault_handle = windows.kernel32.AddVectoredExceptionHandler(0, handleSegfaultWindows);
2342 return;
23352343 }
2344 var act = os.Sigaction{
2345 .sigaction = handleSegfaultLinux,
2346 .mask = os.empty_sigset,
2347 .flags = (os.SA_SIGINFO | os.SA_RESTART | os.SA_RESETHAND),
2348 };
2349
2350 os.sigaction(os.SIGSEGV, &act, null);
23362351}
23372352
2338extern fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: *const c_void) noreturn {
2339 // Reset to the default handler so that if a segfault happens in this handler it will crash
2340 // the process. Also when this handler returns, the original instruction will be repeated
2341 // and the resulting segfault will crash the process rather than continually dump stack traces.
2353fn resetSegfaultHandler() void {
2354 if (windows.is_the_target) {
2355 if (windows_segfault_handle) |handle| {
2356 assert(windows.kernel32.RemoveVectoredExceptionHandler(handle) != 0);
2357 windows_segfault_handle = null;
2358 }
2359 return;
2360 }
23422361 var act = os.Sigaction{
23432362 .sigaction = os.SIG_DFL,
23442363 .mask = os.empty_sigset,
23452364 .flags = 0,
23462365 };
23472366 os.sigaction(os.SIGSEGV, &act, null);
2367}
2368
2369extern fn handleSegfaultLinux(sig: i32, info: *const os.siginfo_t, ctx_ptr: *const c_void) noreturn {
2370 // Reset to the default handler so that if a segfault happens in this handler it will crash
2371 // the process. Also when this handler returns, the original instruction will be repeated
2372 // and the resulting segfault will crash the process rather than continually dump stack traces.
2373 resetSegfaultHandler();
23482374
23492375 const ctx = @ptrCast(*const os.ucontext_t, @alignCast(@alignOf(os.ucontext_t), ctx_ptr));
23502376 const ip = @intCast(usize, ctx.mcontext.gregs[os.REG_RIP]);
std/os/windows/kernel32.zig+1
......@@ -1,6 +1,7 @@
11usingnamespace @import("bits.zig");
22
33pub extern "kernel32" stdcallcc fn AddVectoredExceptionHandler(First: c_ulong, Handler: ?VECTORED_EXCEPTION_HANDLER) ?*c_void;
4pub extern "kernel32" stdcallcc fn RemoveVectoredExceptionHandler(Handle: HANDLE) c_ulong;
45
56pub extern "kernel32" stdcallcc fn CancelIoEx(hFile: HANDLE, lpOverlapped: LPOVERLAPPED) BOOL;
67
std/special/start.zig+2-12
......@@ -24,16 +24,6 @@ comptime {
2424 }
2525}
2626
27fn enableSegfaultHandler() void {
28 const enable_segfault_handler: bool = if (@hasDecl(root, "enable_segfault_handler"))
29 root.enable_segfault_handler
30 else
31 std.debug.runtime_safety and std.debug.have_segfault_handling_support;
32 if (enable_segfault_handler) {
33 std.debug.attachSegfaultHandler();
34 }
35}
36
3727extern fn wasm_freestanding_start() void {
3828 _ = callMain();
3929}
......@@ -72,7 +62,7 @@ extern fn WinMainCRTStartup() noreturn {
7262 _ = @import("start_windows_tls.zig");
7363 }
7464
75 enableSegfaultHandler();
65 std.debug.maybeEnableSegfaultHandler();
7666
7767 std.os.windows.kernel32.ExitProcess(callMain());
7868}
......@@ -113,7 +103,7 @@ inline fn callMainWithArgs(argc: usize, argv: [*][*]u8, envp: [][*]u8) u8 {
113103 std.os.argv = argv[0..argc];
114104 std.os.environ = envp;
115105
116 enableSegfaultHandler();
106 std.debug.maybeEnableSegfaultHandler();
117107
118108 return callMain();
119109}