Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 140 Zig
Normal View History Raw
fixups * better detection for already seen packages * "root" instead of "@root"
2019-06-27 19:15:33 -04:00
// This file is included in the compilation unit when exporting an executable.
add inline assembly support
2015-12-10 15:34:38 -07:00
fixups * better detection for already seen packages * "root" instead of "@root"
2019-06-27 19:15:33 -04:00
const root = @import("root");
un-special-case startup code in the std lib Previously, the compiler had special logic to determine whether to include the startup code, which was in `std/special/start.zig`. Now, the file is moved to `std/start.zig`, and there is no special logic in the compiler. Instead, the standard library unconditionally imports the `start.zig` file, which then has a `comptime` block that does the logic of determining what, if any, start symbols to export. Instead of `start.zig` being in its own special package, it is just another normal file that is part of the standard library. `std.builtin.TestFn` is now part of the standard library rather than specially generated by the compiler.
2019-12-12 18:27:17 -05:00
const std = @import("std.zig");
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
const builtin = @import("builtin");
thread local storage working for linux x86_64
2019-02-06 13:48:04 -05:00
const assert = std.debug.assert;
initial work torwards std lib support for uefi
2019-07-28 23:51:51 +02:00
const uefi = std.os.uefi;
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
const elf = std.elf;
stage2 start.zig: slight simplification fewer required language features to allow this to work
2021-04-13 11:51:58 -07:00
const native_arch = builtin.cpu.arch;
const native_os = builtin.os.tag;
update bootstrap to work for macos too * Directives can have arbitrary expressions as parameters * Fix switch statement not generating code sometimes * Rename "main" fn in bootstrap.zig to "zig_user_main" to avoid name collisions * codegen: fix badref when unreachable is last thing in an expression * support #condition directive on exported functions
2016-02-15 23:30:05 -07:00
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
const start_sym_name = if (native_arch.isMIPS()) "__start" else "_start";
Export _start as __start for MIPS targets
2019-09-26 17:13:57 +02:00
x86_64: implement large cmp
2023-04-01 22:10:15 -04:00
// The self-hosted compiler is not fully capable of handling all of this start.zig file.
// Until then, we have simplified logic here for self-hosted. TODO remove this once
// self-hosted is capable enough to handle all of the real start.zig logic.
pub const simplified_logic =
builtin.zig_backend == .stage2_x86 or
builtin.zig_backend == .stage2_aarch64 or
builtin.zig_backend == .stage2_arm or
spirv: minimal start code For SPIR-V, only export the main function if it is actually declared. Kernel entry points will often have parameters and more than one kernel declared. In general, SPIR-V binaries should mostly be compiled as libraries and not as executables. However, this start code is required so that we can build test executables. Note that a call to isSpirV() would emit the code for that function, even though the call is at comptime. To save that function from being emitted the checks are just inlined manually.
2023-04-08 19:02:31 +02:00
builtin.zig_backend == .stage2_sparc64 or
builtin.cpu.arch == .spirv32 or
riscv: finally fix bug + `airAggregateInit` i just hadn't realized that I placed the `riscv_start` branch in the non-simplified starts
2024-04-16 22:44:55 -07:00
builtin.cpu.arch == .spirv64 or
builtin.zig_backend == .stage2_riscv64;
x86_64: implement large cmp
2023-04-01 22:10:15 -04:00
wip export rewrite
2017-12-18 09:59:57 -05:00
comptime {
start.zig: unconditionally import the root source file stage1 did this by accident by unconditionally semantically analyzing std.builtin.panic, which imports the root source file to look for a panic handler override. But stage2 is smarter; it will only semantically analyze std.builtin.panic if any panic calls are emitted. So for very simple compilations, the root source file was being ignored, even if it contained `export` functions in it.
2021-04-30 11:24:15 -07:00
// No matter what, we import the root file, so that any export, test, comptime
// decls there get run.
_ = root;
x86_64: implement large cmp
2023-04-01 22:10:15 -04:00
if (simplified_logic) {
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
if (builtin.output_mode == .Exe) {
Sema: implement `@typeInfo` for functions The goal is to get start code to be able to inspect the calling convention of `main` in order to determine whether to export a main for libc to call, or to allow the root source file to do it.
2021-05-06 22:30:44 -07:00
if ((builtin.link_libc or builtin.object_format == .c) and @hasDecl(root, "main")) {
if (@typeInfo(@TypeOf(root.main)).Fn.calling_convention != .C) {
@export(main2, .{ .name = "main" });
}
coff: re-enable default entrypoint for Windows
2022-08-31 19:55:39 +02:00
} else if (builtin.os.tag == .windows) {
if (!@hasDecl(root, "wWinMainCRTStartup") and !@hasDecl(root, "mainCRTStartup")) {
@export(wWinMainCRTStartup2, .{ .name = "wWinMainCRTStartup" });
}
spirv: minimal start code For SPIR-V, only export the main function if it is actually declared. Kernel entry points will often have parameters and more than one kernel declared. In general, SPIR-V binaries should mostly be compiled as libraries and not as executables. However, this start code is required so that we can build test executables. Note that a call to isSpirV() would emit the code for that function, even though the call is at comptime. To save that function from being emitted the checks are just inlined manually.
2023-04-08 19:02:31 +02:00
} else if (builtin.os.tag == .opencl) {
if (@hasDecl(root, "main"))
@export(spirvMain2, .{ .name = "main" });
riscv: finally fix bug + `airAggregateInit` i just hadn't realized that I placed the `riscv_start` branch in the non-simplified starts
2024-04-16 22:44:55 -07:00
} else if (native_arch.isRISCV()) {
if (!@hasDecl(root, "_start")) {
@export(riscv_start, .{ .name = "_start" });
}
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
} else {
if (!@hasDecl(root, "_start")) {
stage2: make struct field analysis lazy This commit breaks struct field analysis; will be fixed in a future commit.
2021-05-02 18:50:01 -07:00
@export(_start2, .{ .name = "_start" });
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
}
}
activate start code when pub main exists and rename LinkType->LinkMode, OutType->OutputMode
2019-12-03 12:29:55 -05:00
}
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
} else {
std.builtin: make link mode fields lowercase
2024-02-18 20:34:32 -08:00
if (builtin.output_mode == .Lib and builtin.link_mode == .dynamic) {
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
if (native_os == .windows and !@hasDecl(root, "_DllMainCRTStartup")) {
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
@export(_DllMainCRTStartup, .{ .name = "_DllMainCRTStartup" });
correct startup logic for exporting libc main
2019-12-03 13:10:26 -05:00
}
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
} else if (builtin.output_mode == .Exe or @hasDecl(root, "main")) {
if (builtin.link_libc and @hasDecl(root, "main")) {
WASI,libc: enable tests. Signed-off-by: Takeshi Yoneda <takeshi@tetrate.io>
2021-07-27 08:59:34 +09:00
if (native_arch.isWasm()) {
@export(mainWithoutEnv, .{ .name = "main" });
} else if (@typeInfo(@TypeOf(root.main)).Fn.calling_convention != .C) {
start.zig: export main with strong linkage Unmarks `_main` as weak symbol making it global (the entire linked program) in scope.
2021-05-13 18:34:52 +02:00
@export(main, .{ .name = "main" });
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
}
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
} else if (native_os == .windows) {
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
if (!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
!@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
{
@export(WinStartup, .{ .name = "wWinMainCRTStartup" });
} else if (@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup") and
!@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup"))
{
@compileError("WinMain not supported; declare wWinMain or main instead");
} else if (@hasDecl(root, "wWinMain") and !@hasDecl(root, "wWinMainCRTStartup") and
!@hasDecl(root, "WinMain") and !@hasDecl(root, "WinMainCRTStartup"))
{
@export(wWinMainCRTStartup, .{ .name = "wWinMainCRTStartup" });
}
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
} else if (native_os == .uefi) {
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
if (!@hasDecl(root, "EfiMain")) @export(EfiMain, .{ .name = "EfiMain" });
fix start code for WebAssembly
2021-06-30 18:39:04 -07:00
} else if (native_os == .wasi) {
const wasm_start_sym = switch (builtin.wasi_exec_model) {
.reactor => "_initialize",
.command => "_start",
};
wasm-linker: implement `-fno-entry` flag This adds support for the `-fno-entry` and `-fentry` flags respectively, for zig build-{exe/lib} and the build system. For `zig cc` we use the `--no-entry` flag to be compatible with clang and existing tooling. In `start.zig` we now make the main function optional when the target is WebAssembly, as to allow for the build-exe command in combination with `-fno-entry`. When the execution model is set, and is set to 'reactor', we now verify when an entry name is given it matches what is expected. When no entry point is given, we set it to `_initialize` by default. This means the user will also be met with an error when they use the reactor model, but did not provide the correct function.
2023-08-30 16:59:48 +02:00
if (!@hasDecl(root, wasm_start_sym) and @hasDecl(root, "main")) {
// Only call main when defined. For WebAssembly it's allowed to pass `-fno-entry` in which
// case it's not required to provide an entrypoint such as main.
fix start code for WebAssembly
2021-06-30 18:39:04 -07:00
@export(wasi_start, .{ .name = wasm_start_sym });
}
} else if (native_arch.isWasm() and native_os == .freestanding) {
wasm-linker: implement `-fno-entry` flag This adds support for the `-fno-entry` and `-fentry` flags respectively, for zig build-{exe/lib} and the build system. For `zig cc` we use the `--no-entry` flag to be compatible with clang and existing tooling. In `start.zig` we now make the main function optional when the target is WebAssembly, as to allow for the build-exe command in combination with `-fno-entry`. When the execution model is set, and is set to 'reactor', we now verify when an entry name is given it matches what is expected. When no entry point is given, we set it to `_initialize` by default. This means the user will also be met with an error when they use the reactor model, but did not provide the correct function.
2023-08-30 16:59:48 +02:00
// Only call main when defined. For WebAssembly it's allowed to pass `-fno-entry` in which
// case it's not required to provide an entrypoint such as main.
if (!@hasDecl(root, start_sym_name) and @hasDecl(root, "main")) @export(wasm_freestanding_start, .{ .name = start_sym_name });
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
} else if (native_os != .other and native_os != .freestanding) {
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
if (!@hasDecl(root, start_sym_name)) @export(_start, .{ .name = start_sym_name });
move more startup code to std lib
2019-11-30 15:39:11 +02:00
}
activate start code when pub main exists and rename LinkType->LinkMode, OutType->OutputMode
2019-12-03 12:29:55 -05:00
}
improvements for windows and libc integration * standard library knows if it is linking against libc and will sometimes call libc functions in that case instead of providing redundant definitions * fix infinite loop bug when resolving use declarations * allow calling the same C function from different C imports. closes #277 * push more logic from compiler to std/bootstrap.zig * standard library provides way to access errno closes #274 * fix compile error in standard library for windows * add implementation of getRandomBytes for windows
2017-03-23 02:59:58 -04:00
}
wip export rewrite
2017-12-18 09:59:57 -05:00
}
remove compiler directives * add `setFnTest`, `setFnVisible`, `setFnStaticEval`, `setFnNoInline` builtin functions to replace previous directive functionality * add `coldcc` and `nakedcc` as keywords which can be used as part of a function prototype. * `setDebugSafety` builtin can be used to set debug safety features at a per block scope level. * closes #169
2016-09-28 02:33:32 -04:00
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
// Simplified start code for stage2 until it supports more language features ///
fn main2() callconv(.C) c_int {
root.main();
return 0;
}
stage2 AArch64: get empty file compiling again
2023-12-15 18:39:53 +01:00
fn _start2() callconv(.C) noreturn {
stage2: implement `@setAlignStack` and 128-bit cmpxchg * test runner is improved to respect `error.SkipZigTest` * start code is improved to `@setAlignStack(16)` before calling main() * the newly passing behavior test has a workaround for the fact that stage2 cannot yet call `std.Target.x86.featureSetHas()` at comptime. This is blocking on comptime closures. The workaround is that there is a new decl `@import("builtin").stage2_x86_cx16` which is a `bool`. * Implement `@setAlignStack`. This language feature should be re-evaluated at some point - I'll file an issue for it. * LLVM backend: apply/remove the cold attribute and noinline attribute where appropriate. * LLVM backend: loads and stores are properly annotated with alignment and volatile attributes. * LLVM backend: allocas are properly annotated with alignment. * Type: fix integers reporting wrong alignment for 256-bit integers and beyond. Once you get to 16 byte aligned, there is no further alignment for larger integers.
2021-09-16 21:03:55 -07:00
callMain2();
}
fn callMain2() noreturn {
@setAlignStack(16);
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
root.main();
exit2(0);
}
spirv: minimal start code For SPIR-V, only export the main function if it is actually declared. Kernel entry points will often have parameters and more than one kernel declared. In general, SPIR-V binaries should mostly be compiled as libraries and not as executables. However, this start code is required so that we can build test executables. Note that a call to isSpirV() would emit the code for that function, even though the call is at comptime. To save that function from being emitted the checks are just inlined manually.
2023-04-08 19:02:31 +02:00
fn spirvMain2() callconv(.Kernel) void {
root.main();
}
Make stage2 start.zig work on Windows
2021-09-01 14:32:02 -05:00
fn wWinMainCRTStartup2() callconv(.C) noreturn {
root.main();
exit2(0);
}
Sema: implement ExportOptions support in `@export` Also fix switch blocks not emitting their AIR code.
2021-05-03 20:05:29 -07:00
fn exit2(code: usize) noreturn {
stage2: implement Value.copy for structs and unions The stage2_os hack inside `@import("builtin")` is no longer needed.
2021-09-13 20:08:44 -07:00
switch (native_os) {
remove 'builtin.stage2_arch', Sema is smart enough now
2022-07-24 19:05:20 -07:00
.linux => switch (builtin.cpu.arch) {
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
.x86_64 => {
asm volatile ("syscall"
:
: [number] "{rax}" (231),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[arg1] "{rdi}" (code),
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
: "rcx", "r11", "memory"
);
},
.arm => {
asm volatile ("svc #0"
:
: [number] "{r7}" (1),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[arg1] "{r0}" (code),
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
: "memory"
);
},
.aarch64 => {
asm volatile ("svc #0"
:
: [number] "{x8}" (93),
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
[arg1] "{x0}" (code),
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
: "memory", "cc"
);
},
target: Rename sparcv9 -> sparc64 Rename all references of sparcv9 to sparc64, to make Zig align more with other projects. Also, added new function to convert glibc arch name to Zig arch name, since it refers to the architecture as sparcv9. This is based on the suggestion by @kubkon in PR 11847. (https://github.com/ziglang/zig/pull/11487#pullrequestreview-963761757)
2022-05-13 22:59:06 +07:00
.sparc64 => {
stage2: sparcv9: Add exit2 implementation
2022-04-13 19:56:39 +07:00
asm volatile ("ta 0x6d"
:
: [number] "{g1}" (1),
stage2: zig fmt
2022-04-14 23:26:03 +07:00
[arg1] "{o0}" (code),
stage2: sparcv9: Add exit2 implementation
2022-04-13 19:56:39 +07:00
: "o0", "o1", "o2", "o3", "o4", "o5", "o6", "o7", "memory"
);
},
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
else => @compileError("TODO"),
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
},
stage2: include enough inline asm support for more plan9 syscalls Also make the exit more correct by exiting 0 rather than random stuff on the stack.
2021-06-21 13:10:31 -04:00
// exits(0)
Plan 9: add more features to std.os.plan9 * Replaces the exit assembly with the function from std. * Reads the top-of-stack struct at program startup that can get information like the pid. * Changes the read and write functions to use the Pread and Pwrite syscalls instead of the depreciated _READ and _WRITE * Changes the openat function to use flags instead of perms. Plan9 does not support perms when opening, just when creating. * Adds an errstr function to read the errstr buf created by the kernel
2023-07-16 21:34:13 -04:00
.plan9 => std.os.plan9.exits(null),
Make stage2 start.zig work on Windows
2021-09-01 14:32:02 -05:00
.windows => {
start.zig: Replace kernel32 usage with ntdll Co-authored-by: e4m2 <git@e4m2.com>
2023-10-31 02:15:16 -07:00
std.os.windows.ntdll.RtlExitUserProcess(@as(u32, @truncate(code)));
Make stage2 start.zig work on Windows
2021-09-01 14:32:02 -05:00
},
stage2: blaze the trail for std lib integration This branch adds "builtin" and "std" to the import table when using the self-hosted backend. "builtin" gains one additional item: ``` pub const zig_is_stage2 = true; // false when using stage1 backend ``` This allows the std lib to do conditional compilation based on detecting which backend is being used. This will be removed from builtin as soon as self-hosted catches up to feature parity with stage1. Keep a sharp eye out - people are going to be tempted to abuse this. The general rule of thumb is do not use `builtin.zig_is_stage2`. However this commit breaks the rule so that we can gain limited start.zig support as we incrementally improve the self-hosted compiler. This commit also implements `fullyQualifiedNameHash` and related functionality, which effectively puts all Decls in their proper namespaces. `fullyQualifiedName` is not yet implemented. Stop printing "todo" log messages for test decls unless we are in test mode. Add "previous definition here" error notes for Decl name collisions. This commit does not bring us yet to a newly passing test case. Here's what I'm working towards: ```zig const std = @import("std"); export fn main() c_int { const a = std.fs.base64_alphabet[0]; return a - 'A'; } ``` Current output: ``` $ ./zig-cache/bin/zig build-exe test.zig test.zig:3:1: error: TODO implement more analyze elemptr zig-cache/lib/zig/std/start.zig:38:46: error: TODO implement structInitExpr ty ``` So the next steps are clear: * Sema: improve elemptr * AstGen: implement structInitExpr
2021-04-08 19:05:05 -07:00
else => @compileError("TODO"),
}
unreachable;
}
////////////////////////////////////////////////////////////////////////////////
update std lib to integrate with libc for environ closes #3511
2020-02-22 15:59:13 -05:00
fn _DllMainCRTStartup(
hinstDLL: std.os.windows.HINSTANCE,
fdwReason: std.os.windows.DWORD,
lpReserved: std.os.windows.LPVOID,
Update code to not use unsupported calling conventions for target
2020-10-07 17:51:00 -06:00
) callconv(std.os.windows.WINAPI) std.os.windows.BOOL {
Windows TLS startup symbols are already provided by libcrt when linking against libc
2020-11-09 20:57:07 +02:00
if (!builtin.single_threaded and !builtin.link_libc) {
"generate .h files" feature is no longer supported in stage1
2020-03-20 18:33:36 -04:00
_ = @import("start_windows_tls.zig");
}
move more startup code to std lib
2019-11-30 15:39:11 +02:00
if (@hasDecl(root, "DllMain")) {
return root.DllMain(hinstDLL, fdwReason, lpReserved);
}
return std.os.windows.TRUE;
}
fix start code for WebAssembly
2021-06-30 18:39:04 -07:00
fn wasm_freestanding_start() callconv(.C) void {
// This is marked inline because for some reason LLVM in
// release mode fails to inline it, and we want fewer call frames in stack traces.
update usages of `@call`
2022-12-12 15:32:37 +02:00
_ = @call(.always_inline, callMain, .{});
fix start code for WebAssembly
2021-06-30 18:39:04 -07:00
}
fn wasi_start() callconv(.C) void {
// The function call is marked inline because for some reason LLVM in
// release mode fails to inline it, and we want fewer call frames in stack traces.
switch (builtin.wasi_exec_model) {
update usages of `@call`
2022-12-12 15:32:37 +02:00
.reactor => _ = @call(.always_inline, callMain, .{}),
.command => std.os.wasi.proc_exit(@call(.always_inline, callMain, .{})),
Add support for WASI reactor in pure Zig-exe. (#9178) * Add command line help for "-mexec-model" * Define WasmExecModel enum in std.builtin. * Drop the support for the old crt1.o in favor of crt1-command.o Signed-off-by: Takeshi Yoneda <takeshi@tetrate.io>
2021-07-01 09:02:48 +09:00
}
the wasm freestanding _start function is return value void
2019-05-16 14:17:00 -04:00
}
riscv: add enough components to get a test runner working
2024-03-30 05:49:16 -07:00
fn riscv_start() callconv(.C) noreturn {
riscv: finally fix bug + `airAggregateInit` i just hadn't realized that I placed the `riscv_start` branch in the non-simplified starts
2024-04-16 22:44:55 -07:00
std.process.exit(switch (@typeInfo(@typeInfo(@TypeOf(root.main)).Fn.return_type.?)) {
.NoReturn => root.main(),
.Void => ret: {
root.main();
break :ret 0;
},
.Int => |info| ret: {
if (info.bits != 8 or info.signedness == .signed) {
@compileError(bad_main_ret);
}
break :ret root.main();
},
riscv: vectors part 3
2024-07-02 02:41:14 -07:00
.ErrorUnion => ret: {
const result = root.main() catch {
const stderr = std.io.getStdErr().writer();
stderr.writeAll("failed with error\n") catch {
@panic("failed to print when main returned error");
};
break :ret 1;
};
switch (@typeInfo(@TypeOf(result))) {
.Void => break :ret 0,
.Int => |info| {
if (info.bits != 8 or info.signedness == .signed) {
@compileError(bad_main_ret);
}
return result;
},
else => @compileError(bad_main_ret),
}
},
else => @compileError(bad_main_ret),
riscv: finally fix bug + `airAggregateInit` i just hadn't realized that I placed the `riscv_start` branch in the non-simplified starts
2024-04-16 22:44:55 -07:00
});
riscv: add enough components to get a test runner working
2024-03-30 05:49:16 -07:00
}
zig fmt and update `extern fn` to `callconv(.C)`
2020-01-06 15:34:50 -05:00
fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv(.C) usize {
initial work torwards std lib support for uefi
2019-07-28 23:51:51 +02:00
uefi.handle = handle;
uefi.system_table = system_table;
Fix compile when using EFI target (Fixes #6275)
2020-09-07 17:57:45 +02:00
switch (@typeInfo(@TypeOf(root.main)).Fn.return_type.?) {
std/os/uefi: status reform
2020-03-10 00:56:47 +01:00
noreturn => {
initial work torwards std lib support for uefi
2019-07-28 23:51:51 +02:00
root.main();
},
std/os/uefi: status reform
2020-03-10 00:56:47 +01:00
void => {
initial work torwards std lib support for uefi
2019-07-28 23:51:51 +02:00
root.main();
return 0;
},
std/os/uefi: status reform
2020-03-10 00:56:47 +01:00
usize => {
initial work torwards std lib support for uefi
2019-07-28 23:51:51 +02:00
return root.main();
},
std/os/uefi: status reform
2020-03-10 00:56:47 +01:00
uefi.Status => {
all: zig fmt and rename "@XToY" to "@YFromX" Signed-off-by: Eric Joldasov <bratishkaerik@getgoogleoff.me>
2023-06-15 13:14:16 +06:00
return @intFromEnum(root.main());
std/os/uefi: status reform
2020-03-10 00:56:47 +01:00
},
else => @compileError("expected return type of main to be 'void', 'noreturn', 'usize', or 'std.os.uefi.Status'"),
initial work torwards std lib support for uefi
2019-07-28 23:51:51 +02:00
}
}
Implement the callconv() annotation
2019-12-23 21:52:06 +01:00
fn _start() callconv(.Naked) noreturn {
Plan 9: add more features to std.os.plan9 * Replaces the exit assembly with the function from std. * Reads the top-of-stack struct at program startup that can get information like the pid. * Changes the read and write functions to use the Pread and Pwrite syscalls instead of the depreciated _READ and _WRITE * Changes the openat function to use flags instead of perms. Plan9 does not support perms when opening, just when creating. * Adds an errstr function to read the errstr buf created by the kernel
2023-07-16 21:34:13 -04:00
// TODO set Top of Stack on non x86_64-plan9
if (native_os == .plan9 and native_arch == .x86_64) {
// from /sys/src/libc/amd64/main9.s
std.os.plan9.tos = asm volatile (""
: [tos] "={rax}" (-> *std.os.plan9.Tos),
);
}
start: Add a comment explaining our paranoid stance on ABI guarantees.
2024-07-24 17:38:54 +02:00
// Note that we maintain a very low level of trust with regards to ABI guarantees at this point.
// We will redundantly align the stack, clear the link register, etc. While e.g. the Linux
// kernel is usually good about upholding the ABI guarantees, the same cannot be said of dynamic
// linkers; musl's ldso, for example, opts to not align the stack when invoking the dynamic
// linker explicitly.
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
asm volatile (switch (native_arch) {
.x86_64 =>
\\ xorl %%ebp, %%ebp
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ movq %%rsp, %%rdi
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ andq $-16, %%rsp
\\ callq %[posixCallMainAndExit:P]
,
.x86 =>
\\ xorl %%ebp, %%ebp
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ movl %%esp, %%eax
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ andl $-16, %%esp
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ subl $12, %%esp
\\ pushl %%eax
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ calll %[posixCallMainAndExit:P]
,
.aarch64, .aarch64_be =>
\\ mov fp, #0
\\ mov lr, #0
\\ mov x0, sp
\\ b %[posixCallMainAndExit]
,
.arm, .armeb, .thumb, .thumbeb =>
\\ mov fp, #0
\\ mov lr, #0
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ mov a1, sp
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ and sp, #-16
\\ b %[posixCallMainAndExit]
,
start: Handle loongarch32 together with loongarch64. Nothing bitness-specific about this startup code.
2024-07-24 00:30:57 +02:00
.loongarch32, .loongarch64 =>
start: Add POSIX loongarch64 startup code.
2024-07-22 12:58:07 +02:00
\\ move $fp, $zero
\\ move $a0, $sp
\\ bstrins.d $sp, $zero, 3, 0
\\ b %[posixCallMainAndExit]
,
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
.riscv64 =>
\\ li s0, 0
\\ li ra, 0
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ mv a0, sp
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ andi sp, sp, -16
\\ tail %[posixCallMainAndExit]@plt
,
start: Add POSIX m68k startup code.
2024-07-22 12:55:08 +02:00
.m68k =>
// Note that the - 8 is needed because pc in the jsr instruction points into the middle
// of the jsr instruction. (The lea is 6 bytes, the jsr is 4 bytes.)
\\ suba.l %%fp, %%fp
\\ move.l %%sp, -(%%sp)
\\ lea %[posixCallMainAndExit] - . - 8, %%a0
\\ jsr (%%pc, %%a0)
,
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
.mips, .mipsel =>
// The lr is already zeroed on entry, as specified by the ABI.
\\ addiu $fp, $zero, 0
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ move $a0, $sp
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ .set push
\\ .set noat
\\ addiu $1, $zero, -16
\\ and $sp, $sp, $1
\\ .set pop
\\ j %[posixCallMainAndExit]
,
.mips64, .mips64el =>
// The lr is already zeroed on entry, as specified by the ABI.
\\ addiu $fp, $zero, 0
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ move $a0, $sp
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ .set push
\\ .set noat
\\ daddiu $1, $zero, -16
\\ and $sp, $sp, $1
\\ .set pop
\\ j %[posixCallMainAndExit]
,
.powerpc, .powerpcle =>
// Setup the initial stack frame and clear the back chain pointer.
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ mr 3, 1
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ li 0, 0
\\ stwu 1, -16(1)
\\ stw 0, 0(1)
\\ mtlr 0
\\ b %[posixCallMainAndExit]
,
.powerpc64, .powerpc64le =>
// Setup the initial stack frame and clear the back chain pointer.
start: Pass _start() into its own inline asm as an operand.
2024-07-22 11:55:30 +02:00
\\ addis 2, 12, .TOC. - %[_start]@ha
\\ addi 2, 2, .TOC. - %[_start]@l
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ mr 3, 1
start: Add clrrdi to align the stack pointer on powerpc64.
2024-07-22 01:23:04 +02:00
\\ clrrdi 1, 1, 4
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
\\ li 0, 0
\\ stdu 0, -32(1)
\\ mtlr 0
\\ b %[posixCallMainAndExit]
start: Add POSIX s390x startup code.
2024-07-22 13:22:42 +02:00
,
.s390x =>
// Set up the stack frame (register save area and cleared back-chain slot).
// Note: Stack pointer is guaranteed by ABI to be 8-byte aligned as required.
\\ lgr %r2, %r15
\\ aghi %r15, -160
\\ lghi %r0, 0
\\ stg %r0, 0(%r15)
\\ jg %[posixCallMainAndExit]
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
,
.sparc64 =>
// argc is stored after a register window (16 registers) plus stack bias
\\ mov %%g0, %%i6
\\ add %%o6, 2175, %%l0
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
\\ mov %%l0, %%o0
\\ ba,a %[posixCallMainAndExit]
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
,
cbe: get enough things working to support basic programs * Enable advanced start support. * Enable advanced test_runner support. * Zig Language Reference's Hello World now works.
2022-10-19 07:56:02 -04:00
else => @compileError("unsupported arch"),
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
}
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
:
start: Pass _start() into its own inline asm as an operand.
2024-07-22 11:55:30 +02:00
: [_start] "X" (_start),
[posixCallMainAndExit] "X" (&posixCallMainAndExit),
std: finish cleanup up asm This also required implementing the necessary syntax in the x86_64 backend.
2023-07-31 01:56:43 -04:00
);
progress toward windows hello world working
2017-06-14 00:04:34 -04:00
}
Update code to not use unsupported calling conventions for target
2020-10-07 17:51:00 -06:00
fn WinStartup() callconv(std.os.windows.WINAPI) noreturn {
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
@setAlignStack(16);
Avoid duplicate TLS startup symbols
2021-12-31 23:41:05 +08:00
if (!builtin.single_threaded and !builtin.link_libc) {
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
_ = @import("start_windows_tls.zig");
}
std.debug.maybeEnableSegfaultHandler();
std.start: remove event loop integration
2024-01-28 00:37:34 +02:00
std.os.windows.ntdll.RtlExitUserProcess(callMain());
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
}
Update code to not use unsupported calling conventions for target
2020-10-07 17:51:00 -06:00
fn wWinMainCRTStartup() callconv(std.os.windows.WINAPI) noreturn {
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
@setAlignStack(16);
Avoid duplicate TLS startup symbols
2021-12-31 23:41:05 +08:00
if (!builtin.single_threaded and !builtin.link_libc) {
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
_ = @import("start_windows_tls.zig");
}
std.debug.maybeEnableSegfaultHandler();
std.start: remove event loop integration
2024-01-28 00:37:34 +02:00
const result: std.os.windows.INT = call_wWinMain();
start.zig: Replace kernel32 usage with ntdll Co-authored-by: e4m2 <git@e4m2.com>
2023-10-31 02:15:16 -07:00
std.os.windows.ntdll.RtlExitUserProcess(@as(std.os.windows.UINT, @bitCast(result)));
better main symbol prototype closes #64
2016-01-16 00:07:20 -07:00
}
all types are now expressions See #22
2016-01-13 18:15:51 -07:00
start: Avoid going through the argc_argv_ptr global variable. This is problematic for PIE. There's nothing but luck preventing the accesses to this global variable from requiring relocations. I've observed this being an issue on MIPS and PowerPC personally, but others may be affected. Besides, we're really just passing the initial stack pointer value to posixCallMainAndExit(), so... just do that.
2024-07-21 22:31:59 +02:00
fn posixCallMainAndExit(argc_argv_ptr: [*]usize) callconv(.C) noreturn {
update start code to use `@disableInstrumentation` This prevents it from trying to access thread local storage before it has set up thread local storage, particularly when code coverage instrumentation is enabled.
2024-07-21 23:52:32 -07:00
// We're not ready to panic until thread local storage is initialized.
@setRuntimeSafety(false);
// Code coverage instrumentation might try to use thread local variables.
@disableInstrumentation();
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
const argc = argc_argv_ptr[0];
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const argv = @as([*][*:0]u8, @ptrCast(argc_argv_ptr + 1));
disallow single-item pointer indexing add pointer arithmetic for unknown length pointer
2018-06-04 01:09:15 -04:00
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const envp_optional: [*:null]?[*:0]u8 = @ptrCast(@alignCast(argv + argc + 1));
linux: support VDSO for clock_gettime also fix a compiler crash when using cmpxchg with nullable pointer
2018-04-22 18:11:50 -04:00
var envp_count: usize = 0;
breaking syntax change: ??x to x.? (#1095) See #1023 This also renames Nullable/Maybe to Optional
2018-06-09 23:42:14 -04:00
while (envp_optional[envp_count]) |_| : (envp_count += 1) {}
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const envp = @as([*][*:0]u8, @ptrCast(envp_optional))[0..envp_count];
std: Implement TLS support for Linux Tested on x86_64, i386, ARM, AARCH64
2019-05-04 12:02:55 +02:00
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
if (native_os == .linux) {
fix labeled break inside comptime if inside runtime if
2019-06-19 23:39:49 -04:00
// Find the beginning of the auxiliary vector
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const auxv: [*]elf.Auxv = @ptrCast(@alignCast(envp.ptr + envp_count + 1));
fix labeled break inside comptime if inside runtime if
2019-06-19 23:39:49 -04:00
std.os.linux.elf_aux_maybe = auxv;
Initial support for static PIE executables
2019-12-17 15:07:19 +01:00
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
var at_hwcap: usize = 0;
const phdrs = init: {
var i: usize = 0;
var at_phdr: usize = 0;
var at_phnum: usize = 0;
while (auxv[i].a_type != elf.AT_NULL) : (i += 1) {
switch (auxv[i].a_type) {
elf.AT_PHNUM => at_phnum = auxv[i].a_un.a_val,
elf.AT_PHDR => at_phdr = auxv[i].a_un.a_val,
elf.AT_HWCAP => at_hwcap = auxv[i].a_un.a_val,
else => continue,
}
}
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
break :init @as([*]elf.Phdr, @ptrFromInt(at_phdr))[0..at_phnum];
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
};
// Apply the initial relocations as early as possible in the startup
// process.
Initial support for static PIE executables
2019-12-17 15:07:19 +01:00
if (builtin.position_independent_executable) {
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
std.os.linux.pie.relocate(phdrs);
Initial support for static PIE executables
2019-12-17 15:07:19 +01:00
}
Don't initialize the static TLS area in single-threaded builds
2023-01-04 20:37:59 +01:00
if (!builtin.single_threaded) {
// ARMv6 targets (and earlier) have no support for TLS in hardware.
// FIXME: Elide the check for targets >= ARMv7 when the target feature API
// becomes less verbose (and more usable).
if (comptime native_arch.isARM()) {
if (at_hwcap & std.os.linux.HWCAP.TLS == 0) {
// FIXME: Make __aeabi_read_tp call the kernel helper kuser_get_tls
update start code to use `@disableInstrumentation` This prevents it from trying to access thread local storage before it has set up thread local storage, particularly when code coverage instrumentation is enabled.
2024-07-21 23:52:32 -07:00
// For the time being use a simple trap instead of a @panic call to
Don't initialize the static TLS area in single-threaded builds
2023-01-04 20:37:59 +01:00
// keep the binary bloat under control.
update start code to use `@disableInstrumentation` This prevents it from trying to access thread local storage before it has set up thread local storage, particularly when code coverage instrumentation is enabled.
2024-07-21 23:52:32 -07:00
@trap();
Don't initialize the static TLS area in single-threaded builds
2023-01-04 20:37:59 +01:00
}
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
}
improvements targeted at improving async functions * Reuse bytes of async function frames when non-async functions make `noasync` calls. This prevents explosive stack growth. * Zig now passes a stack size argument to the linker when linking ELF binaries. Linux ignores this value, but it is available as a program header called GNU_STACK. I prototyped some code that memory maps extra space to the stack using this program header, but there was still a problem when accessing stack memory very far down. Stack probing is needed or not working or something. I also prototyped using `@newStackCall` to call main and that does work around the issue but it also brings its own issues. That code is commented out for now in std/special/start.zig. I'm on a plane with no Internet, but I plan to consult with the musl community for advice when I get a chance. * Added `noasync` to a bunch of function calls in std.debug. It's very messy but it's a workaround that makes stack traces functional with evented I/O enabled. Eventually these will be cleaned up as the root bugs are found and fixed. Programs built in blocking mode are unaffected. * Lowered the default stack size of std.io.InStream (for the async version) to 1 MiB instead of 4. Until we figure out how to get choosing a stack size working (see 2nd bullet point above), 4 MiB tends to cause segfaults due to stack size running out, or usage of stack memory too far apart, or something like that. * Default thread stack size is bumped from 8 MiB to 16 to match the size we give for the main thread. It's planned to eventually remove this hard coded value and have Zig able to determine this value during semantic analysis, with call graph analysis and function pointer annotations and extern function annotations.
2019-09-11 20:22:49 -04:00
Don't initialize the static TLS area in single-threaded builds
2023-01-04 20:37:59 +01:00
// Initialize the TLS area.
std.os.linux.tls.initStaticTLS(phdrs);
}
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
start.zig: intentional silent failure when cannot increase stack size
2021-05-28 13:17:04 -07:00
// The way Linux executables represent stack size is via the PT_GNU_STACK
// program header. However the kernel does not recognize it; it always gives 8 MiB.
// Here we look for the stack size in our program headers and use setrlimit
// to ask for more stack space.
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
expandStackSize(phdrs);
fix labeled break inside comptime if inside runtime if
2019-06-19 23:39:49 -04:00
}
linux: support VDSO for clock_gettime also fix a compiler crash when using cmpxchg with nullable pointer
2018-04-22 18:11:50 -04:00
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
std.posix.exit(callMainWithArgs(argc, argv, envp));
delete alloca builtin function See #225 introduce os.EnvMap
2017-04-03 18:11:57 -04:00
}
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
fn expandStackSize(phdrs: []elf.Phdr) void {
std: start code on linux when -lc also expands stack size See #8708
2021-05-07 21:34:53 -07:00
for (phdrs) |*phdr| {
switch (phdr.p_type) {
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
elf.PT_GNU_STACK => {
linux: do not set stack size hard limit At main startup, if the ELF auxiliary vector contains a stacksize value, use it as a hint for the minimum stacksize required by the executable. 1. Never lower the hard-limit. Once a hard-limit is lowered, then it can never be increased (including child processes). 2. If hint exceeds hard-limit then clamp hint to hard-limit. 3. If soft-limit exceeds hint then do nothing.
2023-07-25 21:44:11 -04:00
assert(phdr.p_memsz % std.mem.page_size == 0);
// Silently fail if we are unable to get limits.
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
const limits = std.posix.getrlimit(.STACK) catch break;
linux: do not set stack size hard limit At main startup, if the ELF auxiliary vector contains a stacksize value, use it as a hint for the minimum stacksize required by the executable. 1. Never lower the hard-limit. Once a hard-limit is lowered, then it can never be increased (including child processes). 2. If hint exceeds hard-limit then clamp hint to hard-limit. 3. If soft-limit exceeds hint then do nothing.
2023-07-25 21:44:11 -04:00
// Clamp to limits.max .
const wanted_stack_size = @min(phdr.p_memsz, limits.max);
if (wanted_stack_size > limits.cur) {
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
std.posix.setrlimit(.STACK, .{
linux: do not set stack size hard limit At main startup, if the ELF auxiliary vector contains a stacksize value, use it as a hint for the minimum stacksize required by the executable. 1. Never lower the hard-limit. Once a hard-limit is lowered, then it can never be increased (including child processes). 2. If hint exceeds hard-limit then clamp hint to hard-limit. 3. If soft-limit exceeds hint then do nothing.
2023-07-25 21:44:11 -04:00
.cur = wanted_stack_size,
.max = limits.max,
}) catch {
// Because we could not increase the stack size to the upper bound,
// depending on what happens at runtime, a stack overflow may occur.
// However it would cause a segmentation fault, thanks to stack probing,
// so we do not have a memory safety issue here.
// This is intentional silent failure.
// This logic should be revisited when the following issues are addressed:
// https://github.com/ziglang/zig/issues/157
// https://github.com/ziglang/zig/issues/1006
};
}
std: start code on linux when -lc also expands stack size See #8708
2021-05-07 21:34:53 -07:00
break;
},
else => {},
}
}
}
std.start: remove event loop integration
2024-01-28 00:37:34 +02:00
inline fn callMainWithArgs(argc: usize, argv: [*][*:0]u8, envp: [][*:0]u8) u8 {
clean up references to os
2019-05-26 13:17:34 -04:00
std.os.argv = argv[0..argc];
clean up references to posix
2019-05-25 13:07:44 -04:00
std.os.environ = envp;
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
disable segfault handler when panicking this prevents a segfault in stack trace printing to activate the segfault handler.
2019-07-22 12:15:16 -04:00
std.debug.maybeEnableSegfaultHandler();
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
maybeIgnoreSigpipe();
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
std.start: remove event loop integration
2024-01-28 00:37:34 +02:00
return callMain();
rewrite how importing works * Introduce the concept of packages. Closes #3 * Add support for error notes. * Introduce `@import` and `@c_import` builtin functions and remove the `import` and `c_import` top level declarations. * Introduce the `use` top level declaration. * Add `--check-unused` parameter to perform semantic analysis and codegen on all top level declarations, not just exported ones and ones referenced by exported ones. * Delete the root export node and add `--library` argument.
2016-02-27 22:06:46 -07:00
}
add c_char type closes #875
2023-04-12 21:03:36 -07:00
fn main(c_argc: c_int, c_argv: [*][*:0]c_char, c_envp: [*:null]?[*:0]c_char) callconv(.C) c_int {
linux: support VDSO for clock_gettime also fix a compiler crash when using cmpxchg with nullable pointer
2018-04-22 18:11:50 -04:00
var env_count: usize = 0;
while (c_envp[env_count] != null) : (env_count += 1) {}
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const envp = @as([*][*:0]u8, @ptrCast(c_envp))[0..env_count];
std: start code on linux when -lc also expands stack size See #8708
2021-05-07 21:34:53 -07:00
if (builtin.os.tag == .linux) {
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
const at_phdr = std.c.getauxval(elf.AT_PHDR);
const at_phnum = std.c.getauxval(elf.AT_PHNUM);
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
const phdrs = (@as([*]elf.Phdr, @ptrFromInt(at_phdr)))[0..at_phnum];
std: Fix PIE startup sequence * Don't skip the TLS initialization (Fixes #9083) * Add a test case where a PIE program is built and run * Refactor the common initialization code in the Linux startup sequence.
2021-06-19 18:02:51 +02:00
expandStackSize(phdrs);
std: start code on linux when -lc also expands stack size See #8708
2021-05-07 21:34:53 -07:00
}
std.start: remove event loop integration
2024-01-28 00:37:34 +02:00
return callMainWithArgs(@as(usize, @intCast(c_argc)), @as([*][*:0]u8, @ptrCast(c_argv)), envp);
clean up error return tracing * error return tracing is disabled in release-fast mode * add @errorReturnTrace * zig build API changes build return type from `void` to `%void` * allow `void`, `noreturn`, and `u8` from main. closes #535
2018-01-15 00:01:02 -05:00
}
add c_char type closes #875
2023-04-12 21:03:36 -07:00
fn mainWithoutEnv(c_argc: c_int, c_argv: [*][*:0]c_char) callconv(.C) c_int {
all: migrate code to new cast builtin syntax Most of this migration was performed automatically with `zig fmt`. There were a few exceptions which I had to manually fix: * `@alignCast` and `@addrSpaceCast` cannot be automatically rewritten * `@truncate`'s fixup is incorrect for vectors * Test cases are not formatted, and their error locations change
2023-06-22 18:46:56 +01:00
std.os.argv = @as([*][*:0]u8, @ptrCast(c_argv))[0..@as(usize, @intCast(c_argc))];
std.start: remove event loop integration
2024-01-28 00:37:34 +02:00
return callMain();
WASI,libc: enable tests. Signed-off-by: Takeshi Yoneda <takeshi@tetrate.io>
2021-07-27 08:59:34 +09:00
}
cleanups
2019-07-16 11:50:00 -04:00
// General error message for a malformed return type
const bad_main_ret = "expected return type of main to be 'void', '!void', 'noreturn', 'u8', or '!u8'";
std.start: remove event loop integration
2024-01-28 00:37:34 +02:00
pub inline fn callMain() u8 {
start: refactor callMain return type checking
2024-07-15 09:29:07 +00:00
const ReturnType = @typeInfo(@TypeOf(root.main)).Fn.return_type.?;
switch (ReturnType) {
void => {
clean up error return tracing * error return tracing is disabled in release-fast mode * add @errorReturnTrace * zig build API changes build return type from `void` to `%void` * allow `void`, `noreturn`, and `u8` from main. closes #535
2018-01-15 00:01:02 -05:00
root.main();
return 0;
},
start: refactor callMain return type checking
2024-07-15 09:29:07 +00:00
noreturn, u8 => {
clean up error return tracing * error return tracing is disabled in release-fast mode * add @errorReturnTrace * zig build API changes build return type from `void` to `%void` * allow `void`, `noreturn`, and `u8` from main. closes #535
2018-01-15 00:01:02 -05:00
return root.main();
},
start: refactor callMain return type checking
2024-07-15 09:29:07 +00:00
else => {
if (@typeInfo(ReturnType) != .ErrorUnion) @compileError(bad_main_ret);
cleanups
2019-07-16 11:50:00 -04:00
const result = root.main() catch |err| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
std.log.err("{s}", .{@errorName(err)});
cleanups
2019-07-16 11:50:00 -04:00
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
return 1;
};
start: refactor callMain return type checking
2024-07-15 09:29:07 +00:00
return switch (@TypeOf(result)) {
void => 0,
u8 => result,
cleanups
2019-07-16 11:50:00 -04:00
else => @compileError(bad_main_ret),
start: refactor callMain return type checking
2024-07-15 09:29:07 +00:00
};
clean up error return tracing * error return tracing is disabled in release-fast mode * add @errorReturnTrace * zig build API changes build return type from `void` to `%void` * allow `void`, `noreturn`, and `u8` from main. closes #535
2018-01-15 00:01:02 -05:00
},
}
update bootstrap to work for macos too * Directives can have arbitrary expressions as parameters * Fix switch statement not generating code sometimes * Rename "main" fn in bootstrap.zig to "zig_user_main" to avoid name collisions * codegen: fix badref when unreachable is last thing in an expression * support #condition directive on exported functions
2016-02-15 23:30:05 -07:00
}
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
fixups regarding windows wide strings * remove GetModuleHandleA from kernel32.zig. use of A functions considered harmful. * make it a compile error to expose WinMain instead of wWinMain. same thing. * start code declares wWinMainCRTStartup instead of WinMainCRTStartup when it has the choice.
2020-10-15 19:37:55 -07:00
pub fn call_wWinMain() std.os.windows.INT {
start: Make wWinMain nCmdShow setting match Windows better It won't match perfectly; see https://github.com/ziglang/zig/issues/17808
2023-10-31 01:26:50 -07:00
const peb = std.os.windows.peb();
std.builtin: rename Type.Fn's args to params This was a poor naming choice; these are parameters, not arguments. Parameters specify what kind of arguments are expected, whereas the arguments are the actual values passed.
2022-12-13 21:54:04 +01:00
const MAIN_HINSTANCE = @typeInfo(@TypeOf(root.wWinMain)).Fn.params[0].type.?;
start.zig: Replace kernel32 usage with ntdll Co-authored-by: e4m2 <git@e4m2.com>
2023-10-31 02:15:16 -07:00
const hInstance = @as(MAIN_HINSTANCE, @ptrCast(peb.ImageBaseAddress));
const lpCmdLine: [*:0]u16 = @ptrCast(peb.ProcessParameters.CommandLine.Buffer);
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
start: Make wWinMain nCmdShow setting match Windows better It won't match perfectly; see https://github.com/ziglang/zig/issues/17808
2023-10-31 01:26:50 -07:00
// There are various types used for the 'show window' variable through the Win32 APIs:
// - u16 in STARTUPINFOA.wShowWindow / STARTUPINFOW.wShowWindow
// - c_int in ShowWindow
// - u32 in PEB.ProcessParameters.dwShowWindow
// Since STARTUPINFO is the bottleneck for the allowed values, we use `u16` as the
// type which can coerce into i32/c_int/u32 depending on how the user defines their wWinMain
// (the Win32 docs show wWinMain with `int` as the type for nCmdShow).
const nCmdShow: u16 = nCmdShow: {
// This makes Zig match the nCmdShow behavior of a C program with a WinMain symbol:
// - With STARTF_USESHOWWINDOW set in STARTUPINFO.dwFlags of the CreateProcess call:
// - Compiled with subsystem:console -> nCmdShow is always SW_SHOWDEFAULT
// - Compiled with subsystem:windows -> nCmdShow is STARTUPINFO.wShowWindow from
// the parent CreateProcess call
// - With STARTF_USESHOWWINDOW unset:
// - nCmdShow is always SW_SHOWDEFAULT
const SW_SHOWDEFAULT = 10;
const STARTF_USESHOWWINDOW = 1;
// root having a wWinMain means that std.builtin.subsystem will always have a non-null value.
if (std.builtin.subsystem.? == .Windows and peb.ProcessParameters.dwFlags & STARTF_USESHOWWINDOW != 0) {
break :nCmdShow @truncate(peb.ProcessParameters.dwShowWindow);
}
break :nCmdShow SW_SHOWDEFAULT;
};
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
start.zig: call wWinMain with root's type I have an alternative set of windows bindings I'm working on: https://github.com/marler8997/zig-os-windows. So I'm declaring my wWinMain function with my own HINSTANCE type rather than the one from std.os.windows. This change allows start to call wWinMain using any pointer type.
2020-11-07 10:44:05 -07:00
// second parameter hPrevInstance, MSDN: "This parameter is always NULL"
return root.wWinMain(hInstance, null, lpCmdLine, nCmdShow);
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
}
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
fn maybeIgnoreSigpipe() void {
const have_sigpipe_support = switch (builtin.os.tag) {
.linux,
.plan9,
.solaris,
.netbsd,
.openbsd,
.haiku,
.macos,
.ios,
.watchos,
.tvos,
handle visionos target OS tag in the compiler * rename .xros to .visionos as agreed in the tracking issue * add support for VisionOS platform in the MachO linker
2024-05-09 15:04:13 +02:00
.visionos,
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
.dragonfly,
.freebsd,
=> true,
else => false,
};
if (have_sigpipe_support and !std.options.keep_sigpipe) {
const posix = std.posix;
const act: posix.Sigaction = .{
// Set handler to a noop function instead of `SIG.IGN` to prevent
// leaking signal disposition to a child process.
.handler = .{ .handler = noopSigHandler },
.mask = posix.empty_sigset,
.flags = 0,
};
std.posix: Consider invalid signal numbers to sigaction() to be programmer error. The set of signals that cannot have their action changed is documented in POSIX, and any additional, non-standard signals are documented by the specific OS. I see no valid reason why EINVAL should be considered an unpredictable error here.
2024-07-21 13:31:06 +02:00
posix.sigaction(posix.SIG.PIPE, &act, null);
extract std.posix from std.os closes #5019
2024-03-18 22:39:59 -07:00
}
}
cbe: rewrite `CType` Closes #14904
2024-03-28 20:41:58 -04:00
fn noopSigHandler(_: i32) callconv(.C) void {}
Reference in New Issue Copy Permalink