Morph MORPH
SIGN IN SIGN UP
ziglang / zig UNCLAIMED

Moved to Codeberg

0 0 0 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;
std: introduce a thread-local CSPRNG for general use std.crypto.random * cross platform, even freestanding * can't fail. on initialization for some systems requires calling os.getrandom(), in which case there are rare but theoretically possible errors. The code panics in these cases, however the application may choose to override the default seed function and then handle the failure another way. * thread-safe * supports the full Random interface * cryptographically secure * no syscall required to initialize on Linux (AT_RANDOM) * calls arc4random on systems that support it `std.crypto.randomBytes` is removed in favor of `std.crypto.random.bytes`. I moved some of the Random implementations into their own files in the interest of organization. stage2 no longer requires passing a RNG; instead it uses this API. Closes #6704
2020-12-17 20:03:41 -07:00
const tlcsprng = @import("crypto/tlcsprng.zig");
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
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
var argc_argv_ptr: [*]usize = undefined;
all types are now expressions See #22
2016-01-13 18:15:51 -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
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;
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
// 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.
remove `zig_is_stage2` from `@import("builtin")` Instead use the standarized option for communicating the zig compiler backend at comptime, which is `zig_backend`. This was introduced in commit 1c24ef0d0b09a12a1fe98056f2fc04de78a82df3.
2022-01-17 21:55:49 -07:00
if (builtin.zig_backend != .stage1) {
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" });
}
Remove reference to stage2_os
2021-09-22 14:14:03 -05:00
} else if (builtin.os.tag == .windows) {
Make stage2 start.zig work on Windows
2021-09-01 14:32:02 -05:00
@export(wWinMainCRTStartup2, .{ .name = "wWinMainCRTStartup" });
wasm: Update wasm stage2 test backend to use 'main'
2021-11-28 20:31:12 +01:00
} else if (builtin.os.tag == .wasi and @hasDecl(root, "main")) {
wasm: Add temporary stage2 entrypoint for wasm
2021-11-22 21:16:55 +01:00
@export(wasmMain2, .{ .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 {
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",
};
if (!@hasDecl(root, wasm_start_sym)) {
@export(wasi_start, .{ .name = wasm_start_sym });
}
} else if (native_arch.isWasm() and native_os == .freestanding) {
if (!@hasDecl(root, start_sym_name)) @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;
}
fn _start2() callconv(.Naked) 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);
}
wasm: Add temporary stage2 entrypoint for wasm
2021-11-22 21:16:55 +01:00
fn wasmMain2() u8 {
wasm: Implement 'zig test' - This implements the required codegen for decl types such as pointers, arrays, structs and more. - Wasm's start function can now use both a 'u8' and 'void' as return type. This will help us with writing tests using the stage2 testing backend. (Until all tests of behavioural tests pass). - Now correctly generates relocations for function pointers. - Also implements unwrapping error union error, as well as return pointers.
2021-11-28 20:25:33 +01:00
switch (@typeInfo(@typeInfo(@TypeOf(root.main)).Fn.return_type.?)) {
.Void => {
root.main();
return 0;
},
.Int => |info| {
if (info.bits != 8 or info.signedness == .signed) {
@compileError(bad_main_ret);
}
return root.main();
},
else => @compileError("Bad return type main"),
}
wasm: Add temporary stage2 entrypoint for wasm
2021-11-22 21:16:55 +01:00
}
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) {
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
.linux => switch (builtin.stage2_arch) {
.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"
);
},
stage2 RISCV64: implement basic function prologue and epilogue
2021-11-20 15:30:53 +01:00
.riscv64 => {
asm volatile ("ecall"
:
: [number] "{a7}" (94),
[arg1] "{a0}" (0),
: "rcx", "r11", "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)
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
.plan9 => switch (builtin.stage2_arch) {
.x86_64 => {
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
asm volatile (
\\push $0
\\push $0
\\syscall
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
:
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [syscall_number] "{rbp}" (8),
plan9 linker: produce an object file that can actually work!!!
2021-06-12 16:51:51 -04:00
: "rcx", "r11", "memory"
);
},
stage2 plan9: add aarch64 support
2021-07-10 20:56:30 -04:00
// TODO once we get stack setting with assembly on
// arm, exit with 0 instead of stack garbage
.aarch64 => {
asm volatile ("svc #0"
:
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [exit] "{x0}" (0x08),
stage2 plan9: add aarch64 support
2021-07-10 20:56:30 -04:00
: "memory", "cc"
);
},
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
},
Make stage2 start.zig work on Windows
2021-09-01 14:32:02 -05:00
.windows => {
ExitProcess(@truncate(u32, code));
},
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;
}
Make stage2 start.zig work on Windows
2021-09-01 14:32:02 -05:00
extern "kernel32" fn ExitProcess(exit_code: u32) callconv(.C) noreturn;
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
////////////////////////////////////////////////////////////////////////////////
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.
_ = @call(.{ .modifier = .always_inline }, callMain, .{});
}
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) {
.reactor => _ = @call(.{ .modifier = .always_inline }, callMain, .{}),
.command => std.os.wasi.proc_exit(@call(.{ .modifier = .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
}
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 => {
return @enumToInt(root.main());
},
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 {
std: change `@import("builtin")` to `std.builtin`
2021-04-12 16:43:50 -07:00
switch (native_arch) {
improvements to build-lib use case of WebAssembly * build-exe does include the startup code that supplies _start for the wasm32-freestanding target. Previously this did not occur because of logic excluding "freestanding". * build-lib for wasm32-freestanding target gets linked by LLD. To avoid infinite recursion, compiler_rt and zig libc are built as objects rather than libraries. - no "lib" prefix and ".wasm" extension instead of ".a". Rather than build-lib foo.zig producing "libfoo.a", now it produces "foo.wasm". * go back to using `.o` extension for webassembly objects * zig libc only provides _start symbol for wasm when linking libc.
2019-05-16 13:56:56 -04:00
.x86_64 => {
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
argc_argv_ptr = asm volatile (
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
\\ xor %%rbp, %%rbp
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={rsp}" (-> [*]usize),
introduce std.debug.captureStackTrace and fix the implementation of writeStackTrace it was printing the first frame in the wrong place
2019-02-23 13:19:06 -05:00
);
i386 support closes #115 Thanks to Seo Sanghyeon for the port code.
2016-02-12 02:04:46 -07:00
},
improvements to build-lib use case of WebAssembly * build-exe does include the startup code that supplies _start for the wasm32-freestanding target. Previously this did not occur because of logic excluding "freestanding". * build-lib for wasm32-freestanding target gets linked by LLD. To avoid infinite recursion, compiler_rt and zig libc are built as objects rather than libraries. - no "lib" prefix and ".wasm" extension instead of ".a". Rather than build-lib foo.zig producing "libfoo.a", now it produces "foo.wasm". * go back to using `.o` extension for webassembly objects * zig libc only provides _start symbol for wasm when linking libc.
2019-05-16 13:56:56 -04:00
.i386 => {
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
argc_argv_ptr = asm volatile (
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
\\ xor %%ebp, %%ebp
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={esp}" (-> [*]usize),
run zig fmt on the codebase See #1003
2018-05-28 20:23:55 -04:00
);
i386 support closes #115 Thanks to Seo Sanghyeon for the port code.
2016-02-12 02:04:46 -07:00
},
std: Initial bringup for Linux on Thumb2 There are some small problems here and there, mostly due to the pointers having the lsb set and disrupting the fn alignment tests and the `@FrameSize` implementation.
2021-05-04 18:52:53 +02:00
.aarch64, .aarch64_be, .arm, .armeb, .thumb => {
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
argc_argv_ptr = asm volatile (
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
\\ mov fp, #0
\\ mov lr, #0
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={sp}" (-> [*]usize),
initial arm64 support
2018-08-29 17:37:58 -07:00
);
},
basic riscv support llvm is giving me `error: couldn't allocate output register for constraint '{a0}'` which is a bug that needs to be fixed upstream.
2019-07-18 15:03:21 -04:00
.riscv64 => {
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
argc_argv_ptr = asm volatile (
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
\\ li s0, 0
\\ li ra, 0
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={sp}" (-> [*]usize),
basic riscv support llvm is giving me `error: couldn't allocate output register for constraint '{a0}'` which is a bug that needs to be fixed upstream.
2019-07-18 15:03:21 -04:00
);
},
Add mips support to standard library
2020-04-21 18:42:21 +02:00
.mips, .mipsel => {
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// The lr is already zeroed on entry, as specified by the ABI.
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
argc_argv_ptr = asm volatile (
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
\\ move $fp, $0
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={sp}" (-> [*]usize),
Initial support for mipsel architecture¬
2019-09-21 23:00:36 +02:00
);
},
_start assembly for ppc
2021-04-09 19:17:03 -05:00
.powerpc => {
Initialize the ppc stack frame correctly
2021-04-10 12:58:21 -05:00
// Setup the initial stack frame and clear the back chain pointer.
_start assembly for ppc
2021-04-09 19:17:03 -05:00
argc_argv_ptr = asm volatile (
Initialize the ppc stack frame correctly
2021-04-10 12:58:21 -05:00
\\ mr 4, 1
_start assembly for ppc
2021-04-09 19:17:03 -05:00
\\ li 0, 0
Initialize the ppc stack frame correctly
2021-04-10 12:58:21 -05:00
\\ stwu 1,-16(1)
\\ stw 0, 0(1)
_start assembly for ppc
2021-04-09 19:17:03 -05:00
\\ mtlr 0
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={r4}" (-> [*]usize),
_start assembly for ppc
2021-04-09 19:17:03 -05:00
:
Initialize the ppc stack frame correctly
2021-04-10 12:58:21 -05:00
: "r0"
_start assembly for ppc
2021-04-09 19:17:03 -05:00
);
},
Implement std.start for powerpc64le This is a bit hacky since we end up doing more than just grabbing the stack pointer in the inline assembly block. Ideally _start would be implemented in pure asm for powerpc64le, but this will do for now. Still to be implemented is powerpc, powerpc64, and powerpc64 (ELFv2) support. The latter will just require correctly determing target ABI for powerpc64 and enabling the existing powerpc64le implementation for it.
2020-07-01 16:13:14 -05:00
.powerpc64le => {
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
// Setup the initial stack frame and clear the back chain pointer.
Implement std.start for powerpc64le This is a bit hacky since we end up doing more than just grabbing the stack pointer in the inline assembly block. Ideally _start would be implemented in pure asm for powerpc64le, but this will do for now. Still to be implemented is powerpc, powerpc64, and powerpc64 (ELFv2) support. The latter will just require correctly determing target ABI for powerpc64 and enabling the existing powerpc64le implementation for it.
2020-07-01 16:13:14 -05:00
// TODO: Support powerpc64 (big endian) on ELFv2.
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
argc_argv_ptr = asm volatile (
Implement std.start for powerpc64le This is a bit hacky since we end up doing more than just grabbing the stack pointer in the inline assembly block. Ideally _start would be implemented in pure asm for powerpc64le, but this will do for now. Still to be implemented is powerpc, powerpc64, and powerpc64 (ELFv2) support. The latter will just require correctly determing target ABI for powerpc64 and enabling the existing powerpc64le implementation for it.
2020-07-01 16:13:14 -05:00
\\ mr 4, 1
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
\\ li 0, 0
\\ stdu 0, -32(1)
\\ mtlr 0
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "={r4}" (-> [*]usize),
Implement std.start for powerpc64le This is a bit hacky since we end up doing more than just grabbing the stack pointer in the inline assembly block. Ideally _start would be implemented in pure asm for powerpc64le, but this will do for now. Still to be implemented is powerpc, powerpc64, and powerpc64 (ELFv2) support. The latter will just require correctly determing target ABI for powerpc64 and enabling the existing powerpc64le implementation for it.
2020-07-01 16:13:14 -05:00
:
std: Minor changes to startup code * Smaller startup sequence for ppc64 * Terminate the frame-pointer chain when executing _start * Make the stack traces work on ppc64 * Make the stack traces coloured on ppc64, some ioctls numbers are different and the whole set of constants should be audited.
2020-10-19 11:40:46 +02:00
: "r0"
Implement std.start for powerpc64le This is a bit hacky since we end up doing more than just grabbing the stack pointer in the inline assembly block. Ideally _start would be implemented in pure asm for powerpc64le, but this will do for now. Still to be implemented is powerpc, powerpc64, and powerpc64 (ELFv2) support. The latter will just require correctly determing target ABI for powerpc64 and enabling the existing powerpc64le implementation for it.
2020-07-01 16:13:14 -05:00
);
},
Add sp loading
2020-08-22 16:30:17 +07:00
.sparcv9 => {
Zero %i6 to terminate backchain
2020-10-25 21:51:01 +07:00
// argc is stored after a register window (16 registers) plus stack bias
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
argc_argv_ptr = asm (
Zero %i6 to terminate backchain
2020-10-25 21:51:01 +07:00
\\ mov %%g0, %%i6
\\ add %%o6, 2175, %[argc]
zig fmt: respect trailing commas in inline assembly
2021-08-29 11:57:32 +02:00
: [argc] "=r" (-> [*]usize),
Add sp loading
2020-08-22 16:30:17 +07:00
);
},
rename compileErr builtin to compileError
2016-09-05 17:01:54 -04:00
else => @compileError("unsupported arch"),
i386 support closes #115 Thanks to Seo Sanghyeon for the port code.
2016-02-12 02:04:46 -07:00
}
add higher level arg-parsing API + misc. changes * add @noInlineCall - see #640 This fixes a crash in --release-safe and --release-fast modes where the optimizer inlines everything into _start and clobbers the command line argument data. If we were able to verify that the user's code never reads command line args, we could leave off this "no inline" attribute. * add i29 and u29 primitive types. u29 is the type of alignment, so it makes sense to be a primitive. probably in the future we'll make any `i` or `u` followed by digits into a primitive. * add `aligned` functions to Allocator interface * add `os.argsAlloc` and `os.argsFree` so that you can get a `[]const []u8`, do whatever arg parsing you want, and then free it. For now this uses the other API under the hood, but it could be reimplemented to do a single allocation. * add tests to make sure command line argument parsing works.
2017-12-06 18:12:05 -05:00
// If LLVM inlines stack variables into _start, they will overwrite
// the command line argument data.
remove `@noInlineCall` from zig
2019-12-05 17:37:29 -05:00
@call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
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();
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
std.os.windows.kernel32.ExitProcess(initEventLoopAndCallMain());
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();
Fix Compiler Error When Using wWinMain Entry-Point The fix for #6715 introduced a new compiler error when attempting to use wWinMain as the application entry-point. The Windows API often relies on implicit casts between signed and unsigned variables. In this case, wWinMain returns an INT despite the fact this value is intended to feed into ExitProcess, which expects a UINT, so I've restored the bitcast from #5613.
2020-10-23 00:34:32 +01:00
const result: std.os.windows.INT = initEventLoopAndCallWinMain();
std.os.windows.kernel32.ExitProcess(@bitCast(std.os.windows.UINT, 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
disallow single-item pointer indexing add pointer arithmetic for unknown length pointer
2018-06-04 01:09:15 -04:00
// TODO https://github.com/ziglang/zig/issues/265
syntax: functions require return type. remove `->` The purpose of this is: * Only one way to do things * Changing a function with void return type to return a possible error becomes a 1 character change, subtly encouraging people to use errors. See #632 Here are some imperfect sed commands for performing this update: remove arrow: ``` sed -i 's/\(\bfn\b.*\)-> /\1/g' $(find . -name "*.zig") ``` add void: ``` sed -i 's/\(\bfn\b.*\))\s*{/\1) void {/g' $(find ../ -name "*.zig") ``` Some cleanup may be necessary, but this should do the bulk of the work.
2018-01-25 04:10:11 -05:00
fn posixCallMainAndExit() noreturn {
make start code more versatile * always align the stack to 16. I saw an instance on x86_64 linux where it was needed. * detect at runtime if being interpreted by a dynamic loader and if so avoid clobbering the fs register.
2020-11-24 19:51:24 -07:00
@setAlignStack(16);
starting_stack_ptr -> argc_argv_ptr to reflect actual use
2020-10-27 22:46:18 +07:00
const argc = argc_argv_ptr[0];
const argv = @ptrCast([*][*:0]u8, argc_argv_ptr + 1);
disallow single-item pointer indexing add pointer arithmetic for unknown length pointer
2018-06-04 01:09:15 -04:00
Pointer arithmetic affects the alignment factor Closes #1528
2019-12-20 10:48:03 +01:00
const envp_optional = @ptrCast([*:null]?[*:0]u8, @alignCast(@alignOf(usize), 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) {}
make std.mem.toSlice use null terminated pointers and fix the fallout
2019-11-24 21:12:01 -05:00
const envp = @ptrCast([*][*:0]u8, 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
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 auxv = @ptrCast([*]elf.Auxv, @alignCast(@alignOf(usize), 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,
}
}
break :init @intToPtr([*]elf.Phdr, at_phdr)[0..at_phnum];
};
// 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
}
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
// 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()) {
std: fix regressions from this branch Also move some usingnamespace test cases from compare_output to behavior.
2021-08-30 22:02:34 -07:00
if (at_hwcap & std.os.linux.HWCAP.TLS == 0) {
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
// FIXME: Make __aeabi_read_tp call the kernel helper kuser_get_tls
// For the time being use a simple abort instead of a @panic call to
// keep the binary bloat under control.
std.os.abort();
}
make start code more versatile * always align the stack to 16. I saw an instance on x86_64 linux where it was needed. * detect at runtime if being interpreted by a dynamic loader and if so avoid clobbering the fs register.
2020-11-24 19:51:24 -07: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
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
// Initialize the TLS area.
std.os.linux.tls.initStaticTLS(phdrs);
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
remove `@inlineCall` from zig
2019-12-06 14:12:01 -05:00
std.os.exit(@call(.{ .modifier = .always_inline }, 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 => {
std: start code on linux when -lc also expands stack size See #8708
2021-05-07 21:34:53 -07:00
const wanted_stack_size = phdr.p_memsz;
assert(wanted_stack_size % std.mem.page_size == 0);
std.os.setrlimit(.STACK, .{
.cur = wanted_stack_size,
.max = wanted_stack_size,
}) catch {
start.zig: intentional silent failure when cannot increase stack size
2021-05-28 13:17:04 -07:00
// 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 => {},
}
}
}
make std.mem.toSlice use null terminated pointers and fix the fallout
2019-11-24 21:12:01 -05:00
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();
stack traces on segfault by default for linux-x86_64 closes #2355
2019-07-02 13:27:40 -04:00
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
return initEventLoopAndCallMain();
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
}
zig fmt and update `extern fn` to `callconv(.C)`
2020-01-06 15:34:50 -05:00
fn main(c_argc: i32, c_argv: [*][*:0]u8, c_envp: [*:null]?[*:0]u8) callconv(.C) i32 {
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) {}
make std.mem.toSlice use null terminated pointers and fix the fallout
2019-11-24 21:12:01 -05:00
const envp = @ptrCast([*][*:0]u8, 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);
const phdrs = (@intToPtr([*]elf.Phdr, at_phdr))[0..at_phnum];
expandStackSize(phdrs);
std: start code on linux when -lc also expands stack size See #8708
2021-05-07 21:34:53 -07:00
}
remove `@inlineCall` from zig
2019-12-06 14:12:01 -05:00
return @call(.{ .modifier = .always_inline }, callMainWithArgs, .{ @intCast(usize, c_argc), 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
}
WASI,libc: enable tests. Signed-off-by: Takeshi Yoneda <takeshi@tetrate.io>
2021-07-27 08:59:34 +09:00
fn mainWithoutEnv(c_argc: i32, c_argv: [*][*:0]u8) callconv(.C) usize {
std.os.argv = c_argv[0..@intCast(usize, c_argc)];
return @call(.{ .modifier = .always_inline }, callMain, .{});
}
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/special/bootstrap: inline some functions to improve stack traces
2018-10-09 12:33:48 -04:00
// 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.
Run `zig fmt` on src/ and lib/std/ This replaces callconv(.Inline) with the more idiomatic inline keyword.
2021-05-20 17:07:06 +02:00
inline fn initEventLoopAndCallMain() u8 {
startup code sets up event loop if I/O mode is declared evented
2019-10-31 11:41:39 -04:00
if (std.event.Loop.instance) |loop| {
startup code respects root source file's event_loop if present
2019-10-31 14:21:04 -04:00
if (!@hasDecl(root, "event_loop")) {
loop.init() catch |err| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
std.log.err("{s}", .{@errorName(err)});
startup code respects root source file's event_loop if present
2019-10-31 14:21:04 -04:00
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
return 1;
};
defer loop.deinit();
var result: u8 = undefined;
improve the start code for evented I/O When evented I/O is being used, prevent event loop from terminating at least until main() has returned.
2019-11-06 15:08:29 -05:00
var frame: @Frame(callMainAsync) = undefined;
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
_ = @asyncCall(&frame, &result, callMainAsync, .{loop});
startup code respects root source file's event_loop if present
2019-10-31 14:21:04 -04:00
loop.run();
return result;
}
startup code sets up event loop if I/O mode is declared evented
2019-10-31 11:41:39 -04:00
}
startup code respects root source file's event_loop if present
2019-10-31 14:21:04 -04:00
// 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.
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
return @call(.{ .modifier = .always_inline }, callMain, .{});
startup code sets up event loop if I/O mode is declared evented
2019-10-31 11:41:39 -04:00
}
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
// 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.
// TODO This function is duplicated from initEventLoopAndCallMain instead of using generics
// because it is working around stage1 compiler bugs.
Run `zig fmt` on src/ and lib/std/ This replaces callconv(.Inline) with the more idiomatic inline keyword.
2021-05-20 17:07:06 +02:00
inline fn initEventLoopAndCallWinMain() std.os.windows.INT {
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
if (std.event.Loop.instance) |loop| {
if (!@hasDecl(root, "event_loop")) {
loop.init() catch |err| {
std: Use {s} instead of {} when printing strings
2020-11-26 09:48:12 +01:00
std.log.err("{s}", .{@errorName(err)});
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
if (@errorReturnTrace()) |trace| {
std.debug.dumpStackTrace(trace.*);
}
return 1;
};
defer loop.deinit();
fix startup procedure for async WinMain
2021-10-09 14:04:16 +02:00
var result: std.os.windows.INT = undefined;
var frame: @Frame(callWinMainAsync) = undefined;
_ = @asyncCall(&frame, &result, callWinMainAsync, .{loop});
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
loop.run();
return result;
}
}
// 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.
return @call(.{ .modifier = .always_inline }, call_wWinMain, .{});
}
fn callMainAsync(loop: *std.event.Loop) callconv(.Async) u8 {
improve the start code for evented I/O When evented I/O is being used, prevent event loop from terminating at least until main() has returned.
2019-11-06 15:08:29 -05:00
// This prevents the event loop from terminating at least until main() has returned.
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
// TODO This shouldn't be needed here; it should be in the event loop code.
improve the start code for evented I/O When evented I/O is being used, prevent event loop from terminating at least until main() has returned.
2019-11-06 15:08:29 -05:00
loop.beginOneEvent();
defer loop.finishOneEvent();
fix compilation error when building with io_mode evented The merge of #5613 introduced a regression when building with io_mode evented, fixed in this commit. closes #6715
2020-10-17 15:46:36 -07:00
return callMain();
improve the start code for evented I/O When evented I/O is being used, prevent event loop from terminating at least until main() has returned.
2019-11-06 15:08:29 -05:00
}
fix startup procedure for async WinMain
2021-10-09 14:04:16 +02:00
fn callWinMainAsync(loop: *std.event.Loop) callconv(.Async) std.os.windows.INT {
// This prevents the event loop from terminating at least until main() has returned.
// TODO This shouldn't be needed here; it should be in the event loop code.
loop.beginOneEvent();
defer loop.finishOneEvent();
return call_wWinMain();
}
startup code sets up event loop if I/O mode is declared evented
2019-10-31 11:41:39 -04:00
// This is not marked inline because it is called with @asyncCall when
// there is an event loop.
allow custom OS entrypoint Also: * Expose `std.start.callMain`. * Other fixes added to fix issues found in development.
2019-12-12 01:31:32 +00:00
pub fn callMain() u8 {
update uses of deprecated type field access
2020-09-03 18:09:55 +03:00
switch (@typeInfo(@typeInfo(@TypeOf(root.main)).Fn.return_type.?)) {
fix runtime if nested inside comptime if
2019-06-11 18:26:01 -04:00
.NoReturn => {
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();
},
fix runtime if nested inside comptime if
2019-06-11 18:26:01 -04:00
.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;
},
cleanups
2019-07-16 11:50:00 -04:00
.Int => |info| {
Add builtin.Signedness, use it instead of is_signed
2020-10-17 18:04:53 -06:00
if (info.bits != 8 or info.signedness == .signed) {
cleanups
2019-07-16 11:50:00 -04:00
@compileError(bad_main_ret);
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();
},
cleanups
2019-07-16 11:50:00 -04:00
.ErrorUnion => {
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;
};
Replace @typeOf with @TypeOf in all zig source This change was mostly made with `zig fmt` and this also modified some whitespace. Note that in some files, `zig fmt` produced incorrect code, so the change was made manually.
2019-12-09 21:56:19 +01:00
switch (@typeInfo(@TypeOf(result))) {
cleanups
2019-07-16 11:50:00 -04:00
.Void => return 0,
.Int => |info| {
Add builtin.Signedness, use it instead of is_signed
2020-10-17 18:04:53 -06:00
if (info.bits != 8 or info.signedness == .signed) {
cleanups
2019-07-16 11:50:00 -04:00
@compileError(bad_main_ret);
Zen specific hacks
2018-03-20 16:09:30 -04:00
}
cleanups
2019-07-16 11:50:00 -04:00
return result;
},
else => @compileError(bad_main_ret),
}
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
},
cleanups
2019-07-16 11:50:00 -04:00
else => @compileError(bad_main_ret),
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.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
const MAIN_HINSTANCE = @typeInfo(@TypeOf(root.wWinMain)).Fn.args[0].arg_type.?;
const hInstance = @ptrCast(MAIN_HINSTANCE, std.os.windows.kernel32.GetModuleHandleW(null).?);
Implement WinMain Callers that Pass Valid Params
2020-06-15 14:24:25 +01:00
const lpCmdLine = std.os.windows.kernel32.GetCommandLineW();
// There's no (documented) way to get the nCmdShow parameter, so we're
// using this fairly standard default.
const nCmdShow = std.os.windows.user32.SW_SHOW;
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
}
Reference in New Issue Copy Permalink