mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2025-12-16 03:03:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into llvm9

Browse Source
This commit is contained in:
Andrew Kelley 2019-09-15 20:59:53 -04:00
commit c4416b224d
No known key found for this signature in database
GPG Key ID: 7C5F548F728501A9
35 changed files with 1224 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
src/analyze.cpp
View File

@ -2406,8 +2406,6 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
ZigType *tag_int_type;
if (enum_type->data.enumeration.layout == ContainerLayoutExtern) {
tag_int_type = get_c_int_type(g, CIntTypeInt);
} else if (enum_type->data.enumeration.layout == ContainerLayoutAuto && field_count == 1) {
tag_int_type = g->builtin_types.entry_num_lit_int;
} else {
tag_int_type = get_smallest_unsigned_int_type(g, field_count - 1);
}
@ -2420,7 +2418,8 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
ZigType *wanted_tag_int_type = analyze_type_expr(g, scope, decl_node->data.container_decl.init_arg_expr);
if (type_is_invalid(wanted_tag_int_type)) {
enum_type->data.enumeration.resolve_status = ResolveStatusInvalid;
} else if (wanted_tag_int_type->id != ZigTypeIdInt) {
} else if (wanted_tag_int_type->id != ZigTypeIdInt &&
wanted_tag_int_type->id != ZigTypeIdComptimeInt) {
enum_type->data.enumeration.resolve_status = ResolveStatusInvalid;
add_node_error(g, decl_node->data.container_decl.init_arg_expr,
buf_sprintf("expected integer, found '%s'", buf_ptr(&wanted_tag_int_type->name)));
@ -2538,6 +2537,8 @@ static Error resolve_enum_zero_bits(CodeGen *g, ZigType *enum_type) {
enum_type->data.enumeration.resolve_loop_flag = false;
enum_type->data.enumeration.resolve_status = ResolveStatusSizeKnown;
occupied_tag_values.deinit();
return ErrorNone;
}
@ -2804,14 +2805,12 @@ static Error resolve_union_zero_bits(CodeGen *g, ZigType *union_type) {
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
return ErrorSemanticAnalyzeFail;
}
if (tag_int_type->id != ZigTypeIdInt) {
if (tag_int_type->id != ZigTypeIdInt && tag_int_type->id != ZigTypeIdComptimeInt) {
add_node_error(g, enum_type_node,
buf_sprintf("expected integer tag type, found '%s'", buf_ptr(&tag_int_type->name)));
union_type->data.unionation.resolve_status = ResolveStatusInvalid;
return ErrorSemanticAnalyzeFail;
}
} else if (auto_layout && field_count == 1) {
tag_int_type = g->builtin_types.entry_num_lit_int;
} else {
tag_int_type = get_smallest_unsigned_int_type(g, field_count - 1);
}
@ -5878,6 +5877,11 @@ static Error resolve_async_frame(CodeGen *g, ZigType *frame_type) {
fn->err_code_spill = &alloca_gen->base;
}
ZigType *largest_call_frame_type = nullptr;
// Later we'll change this to be largest_call_frame_type instead of void.
IrInstruction *all_calls_alloca = ir_create_alloca(g, &fn->fndef_scope->base, fn->body_node,
fn, g->builtin_types.entry_void, "@async_call_frame");
for (size_t i = 0; i < fn->call_list.length; i += 1) {
IrInstructionCallGen *call = fn->call_list.at(i);
if (call->new_stack != nullptr) {
@ -5921,9 +5925,21 @@ static Error resolve_async_frame(CodeGen *g, ZigType *frame_type) {
mark_suspension_point(call->base.scope);
call->frame_result_loc = ir_create_alloca(g, call->base.scope, call->base.source_node, fn,
callee_frame_type, "");
if ((err = type_resolve(g, callee_frame_type, ResolveStatusSizeKnown))) {
return err;
}
if (largest_call_frame_type == nullptr ||
callee_frame_type->abi_size > largest_call_frame_type->abi_size)
{
largest_call_frame_type = callee_frame_type;
}
call->frame_result_loc = all_calls_alloca;
}
if (largest_call_frame_type != nullptr) {
all_calls_alloca->value.type = get_pointer_to_type(g, largest_call_frame_type, false);
}
// Since this frame is async, an await might represent a suspend point, and
// therefore need to spill. It also needs to mark expr scopes as having to spill.
// For example: foo() + await z

39
src/codegen.cpp
View File

@ -517,6 +517,8 @@ static LLVMValueRef make_fn_llvm_value(CodeGen *g, ZigFn *fn) {
}
if (g->have_stack_probing && !fn->def_scope->safety_off) {
addLLVMFnAttrStr(llvm_fn, "probe-stack", "__zig_probe_stack");
} else if (g->zig_target->os == OsUefi) {
addLLVMFnAttrStr(llvm_fn, "no-stack-arg-probe", "");
}
} else {
maybe_import_dll(g, llvm_fn, linkage);
@ -3863,6 +3865,7 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
ZigList<ZigType *> gen_param_types = {};
LLVMValueRef result_loc = instruction->result_loc ? ir_llvm_value(g, instruction->result_loc) : nullptr;
LLVMValueRef zero = LLVMConstNull(usize_type_ref);
LLVMValueRef frame_result_loc_uncasted = nullptr;
LLVMValueRef frame_result_loc;
LLVMValueRef awaiter_init_val;
LLVMValueRef ret_ptr;
@ -3871,7 +3874,10 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
if (instruction->modifier == CallModifierAsync) {
frame_result_loc = result_loc;
} else {
frame_result_loc = ir_llvm_value(g, instruction->frame_result_loc);
frame_result_loc_uncasted = ir_llvm_value(g, instruction->frame_result_loc);
src_assert(instruction->fn_entry != nullptr, instruction->base.source_node);
frame_result_loc = LLVMBuildBitCast(g->builder, frame_result_loc_uncasted,
LLVMPointerType(get_llvm_type(g, instruction->fn_entry->frame_type), 0), "");
}
} else {
if (instruction->new_stack->value.type->id == ZigTypeIdPointer &&
@ -4138,6 +4144,13 @@ static LLVMValueRef ir_render_call(CodeGen *g, IrExecutable *executable, IrInstr
}
}
if (frame_result_loc_uncasted != nullptr && instruction->fn_entry != nullptr) {
// Instead of a spill, we do the bitcast again. The uncasted LLVM IR instruction will
// be an Alloca from the entry block, so it does not need to be spilled.
frame_result_loc = LLVMBuildBitCast(g->builder, frame_result_loc_uncasted,
LLVMPointerType(get_llvm_type(g, instruction->fn_entry->frame_type), 0), "");
}
LLVMValueRef result_ptr = LLVMBuildStructGEP(g->builder, frame_result_loc, frame_ret_start + 2, "");
return LLVMBuildLoad(g->builder, result_ptr, "");
}
@ -7173,6 +7186,9 @@ static void do_code_gen(CodeGen *g) {
if (!is_async) {
// allocate async frames for noasync calls & awaits to async functions
ZigType *largest_call_frame_type = nullptr;
IrInstruction *all_calls_alloca = ir_create_alloca(g, &fn_table_entry->fndef_scope->base,
fn_table_entry->body_node, fn_table_entry, g->builtin_types.entry_void, "@async_call_frame");
for (size_t i = 0; i < fn_table_entry->call_list.length; i += 1) {
IrInstructionCallGen *call = fn_table_entry->call_list.at(i);
if (call->fn_entry == nullptr)
@ -7184,8 +7200,15 @@ static void do_code_gen(CodeGen *g) {
if (call->frame_result_loc != nullptr)
continue;
ZigType *callee_frame_type = get_fn_frame_type(g, call->fn_entry);
call->frame_result_loc = ir_create_alloca(g, call->base.scope, call->base.source_node,
fn_table_entry, callee_frame_type, "");
if (largest_call_frame_type == nullptr ||
callee_frame_type->abi_size > largest_call_frame_type->abi_size)
{
largest_call_frame_type = callee_frame_type;
}
call->frame_result_loc = all_calls_alloca;
}
if (largest_call_frame_type != nullptr) {
all_calls_alloca->value.type = get_pointer_to_type(g, largest_call_frame_type, false);
}
// allocate temporary stack data
for (size_t alloca_i = 0; alloca_i < fn_table_entry->alloca_gen_list.length; alloca_i += 1) {
@ -9074,10 +9097,6 @@ static bool want_startup_code(CodeGen *g) {
if (g->is_test_build)
return false;
// start code does not handle UEFI target
if (g->zig_target->os == OsUefi)
return false;
// WASM freestanding can still have an entry point but other freestanding targets do not.
if (g->zig_target->os == OsFreestanding && !target_is_wasm(g->zig_target))
return false;
@ -9087,8 +9106,12 @@ static bool want_startup_code(CodeGen *g) {
return false;
// If there is a pub main in the root source file, that means we need start code.
if (g->have_pub_main)
if (g->have_pub_main) {
return true;
} else {
if (g->zig_target->os == OsUefi)
return false;
}
if (g->out_type == OutTypeExe) {
// For build-exe, we might add start code even though there is no pub main, so that the

5
src/link.cpp
View File

@ -1615,6 +1615,11 @@ static void construct_linker_job_elf(LinkJob *lj) {
lj->args.append("-error-limit=0");
if (g->out_type == OutTypeExe) {
lj->args.append("-z");
lj->args.append("stack-size=16777216"); // default to 16 MiB
}
if (g->linker_script) {
lj->args.append("-T");
lj->args.append(g->linker_script);

6
src/target.cpp
View File

@ -1129,7 +1129,7 @@ uint32_t target_c_type_size_in_bits(const ZigTarget *target, CIntType id) {
}
bool target_allows_addr_zero(const ZigTarget *target) {
return target->os == OsFreestanding;
return target->os == OsFreestanding || target->os == OsUefi;
}
const char *target_o_file_ext(const ZigTarget *target) {
@ -1585,12 +1585,12 @@ bool target_supports_fpic(const ZigTarget *target) {
}
bool target_supports_stack_probing(const ZigTarget *target) {
return target->os != OsWindows && (target->arch == ZigLLVM_x86 || target->arch == ZigLLVM_x86_64);
return target->os != OsWindows && target->os != OsUefi && (target->arch == ZigLLVM_x86 || target->arch == ZigLLVM_x86_64);
}
bool target_requires_pic(const ZigTarget *target, bool linking_libc) {
// This function returns whether non-pic code is completely invalid on the given target.
return target->os == OsWindows || target_os_requires_libc(target->os) ||
return target->os == OsWindows || target->os == OsUefi || target_os_requires_libc(target->os) ||
(linking_libc && target_is_glibc(target));
}

9
src/tokenizer.cpp
View File

@ -407,9 +407,14 @@ void tokenize(Buf *buf, Tokenization *out) {
t.buf = buf;
out->line_offsets = allocate<ZigList<size_t>>(1);
out->line_offsets->append(0);
for (t.pos = 0; t.pos < buf_len(t.buf); t.pos += 1) {
// Skip the UTF-8 BOM if present
if (buf_starts_with_mem(buf, "\xEF\xBB\xBF", 3)) {
t.pos += 3;
}
for (; t.pos < buf_len(t.buf); t.pos += 1) {
uint8_t c = buf_ptr(t.buf)[t.pos];
switch (t.state) {
case TokenizeStateError:

11
std/build.zig
View File

@ -1175,6 +1175,13 @@ pub const Target = union(enum) {
};
}
pub fn isUefi(self: Target) bool {
return switch (self.getOs()) {
.uefi => true,
else => false,
};
}
pub fn isWasm(self: Target) bool {
return switch (self.getArch()) {
.wasm32, .wasm64 => true,
@ -1490,7 +1497,7 @@ pub const LibExeObjStep = struct {
}
pub fn producesPdbFile(self: *LibExeObjStep) bool {
if (!self.target.isWindows()) return false;
if (!self.target.isWindows() and !self.target.isUefi()) return false;
if (self.strip) return false;
return self.isDynamicLibrary() or self.kind == .Exe;
}
@ -1587,7 +1594,7 @@ pub const LibExeObjStep = struct {
/// Unless setOutputDir was called, this function must be called only in
/// the make step, from a step that has declared a dependency on this one.
pub fn getOutputPdbPath(self: *LibExeObjStep) []const u8 {
assert(self.target.isWindows());
assert(self.target.isWindows() or self.target.isUefi());
return fs.path.join(
self.builder.allocator,
[_][]const u8{ self.output_dir.?, self.out_pdb_filename },

3
std/c/freebsd.zig
View File

@ -7,3 +7,6 @@ pub const _errno = __error;
pub extern "c" fn getdents(fd: c_int, buf_ptr: [*]u8, nbytes: usize) usize;
pub extern "c" fn sigaltstack(ss: ?*stack_t, old_ss: ?*stack_t) c_int;
pub extern "c" fn getrandom(buf_ptr: [*]u8, buf_len: usize, flags: c_uint) isize;
pub const dl_iterate_phdr_callback = extern fn (info: *dl_phdr_info, size: usize, data: ?*c_void) c_int;
pub extern "c" fn dl_iterate_phdr(callback: dl_iterate_phdr_callback, data: ?*c_void) c_int;

78
std/debug.zig
View File

@ -1478,10 +1478,11 @@ const LineNumberProgram = struct {
}
};
// TODO the noasyncs here are workarounds
fn readStringRaw(allocator: *mem.Allocator, in_stream: var) ![]u8 {
var buf = ArrayList(u8).init(allocator);
while (true) {
const byte = try in_stream.readByte();
const byte = try noasync in_stream.readByte();
if (byte == 0) break;
try buf.append(byte);
}
@ -1494,10 +1495,11 @@ fn getString(di: *DwarfInfo, offset: u64) ![]u8 {
return di.readString();
}
// TODO the noasyncs here are workarounds
fn readAllocBytes(allocator: *mem.Allocator, in_stream: var, size: usize) ![]u8 {
const buf = try allocator.alloc(u8, size);
errdefer allocator.free(buf);
if ((try in_stream.read(buf)) < size) return error.EndOfFile;
if ((try noasync in_stream.read(buf)) < size) return error.EndOfFile;
return buf;
}
@ -1506,8 +1508,9 @@ fn parseFormValueBlockLen(allocator: *mem.Allocator, in_stream: var, size: usize
return FormValue{ .Block = buf };
}
// TODO the noasyncs here are workarounds
fn parseFormValueBlock(allocator: *mem.Allocator, in_stream: var, size: usize) !FormValue {
const block_len = try in_stream.readVarInt(usize, builtin.Endian.Little, size);
const block_len = try noasync in_stream.readVarInt(usize, builtin.Endian.Little, size);
return parseFormValueBlockLen(allocator, in_stream, block_len);
}
@ -1537,27 +1540,37 @@ fn parseFormValueConstant(allocator: *mem.Allocator, in_stream: var, signed: boo
};
}
// TODO the noasyncs here are workarounds
fn parseFormValueDwarfOffsetSize(in_stream: var, is_64: bool) !u64 {
return if (is_64) try in_stream.readIntLittle(u64) else u64(try in_stream.readIntLittle(u32));
return if (is_64) try noasync in_stream.readIntLittle(u64) else u64(try noasync in_stream.readIntLittle(u32));
}
// TODO the noasyncs here are workarounds
fn parseFormValueTargetAddrSize(in_stream: var) !u64 {
return if (@sizeOf(usize) == 4) u64(try in_stream.readIntLittle(u32)) else if (@sizeOf(usize) == 8) try in_stream.readIntLittle(u64) else unreachable;
if (@sizeOf(usize) == 4) {
return u64(try noasync in_stream.readIntLittle(u32));
} else if (@sizeOf(usize) == 8) {
return noasync in_stream.readIntLittle(u64);
} else {
unreachable;
}
}
// TODO the noasyncs here are workarounds
fn parseFormValueRef(allocator: *mem.Allocator, in_stream: var, size: i32) !FormValue {
return FormValue{
.Ref = switch (size) {
1 => try in_stream.readIntLittle(u8),
2 => try in_stream.readIntLittle(u16),
4 => try in_stream.readIntLittle(u32),
8 => try in_stream.readIntLittle(u64),
-1 => try leb.readULEB128(u64, in_stream),
1 => try noasync in_stream.readIntLittle(u8),
2 => try noasync in_stream.readIntLittle(u16),
4 => try noasync in_stream.readIntLittle(u32),
8 => try noasync in_stream.readIntLittle(u64),
-1 => try noasync leb.readULEB128(u64, in_stream),
else => unreachable,
},
};
}
// TODO the noasyncs here are workarounds
fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64: bool) anyerror!FormValue {
return switch (form_id) {
DW.FORM_addr => FormValue{ .Address = try parseFormValueTargetAddrSize(in_stream) },
@ -1565,7 +1578,7 @@ fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64
DW.FORM_block2 => parseFormValueBlock(allocator, in_stream, 2),
DW.FORM_block4 => parseFormValueBlock(allocator, in_stream, 4),
DW.FORM_block => x: {
const block_len = try leb.readULEB128(usize, in_stream);
const block_len = try noasync leb.readULEB128(usize, in_stream);
return parseFormValueBlockLen(allocator, in_stream, block_len);
},
DW.FORM_data1 => parseFormValueConstant(allocator, in_stream, false, 1),
@ -1577,11 +1590,11 @@ fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64
return parseFormValueConstant(allocator, in_stream, signed, -1);
},
DW.FORM_exprloc => {
const size = try leb.readULEB128(usize, in_stream);
const size = try noasync leb.readULEB128(usize, in_stream);
const buf = try readAllocBytes(allocator, in_stream, size);
return FormValue{ .ExprLoc = buf };
},
DW.FORM_flag => FormValue{ .Flag = (try in_stream.readByte()) != 0 },
DW.FORM_flag => FormValue{ .Flag = (try noasync in_stream.readByte()) != 0 },
DW.FORM_flag_present => FormValue{ .Flag = true },
DW.FORM_sec_offset => FormValue{ .SecOffset = try parseFormValueDwarfOffsetSize(in_stream, is_64) },
@ -1592,12 +1605,12 @@ fn parseFormValue(allocator: *mem.Allocator, in_stream: var, form_id: u64, is_64
DW.FORM_ref_udata => parseFormValueRef(allocator, in_stream, -1),
DW.FORM_ref_addr => FormValue{ .RefAddr = try parseFormValueDwarfOffsetSize(in_stream, is_64) },
DW.FORM_ref_sig8 => FormValue{ .Ref = try in_stream.readIntLittle(u64) },
DW.FORM_ref_sig8 => FormValue{ .Ref = try noasync in_stream.readIntLittle(u64) },
DW.FORM_string => FormValue{ .String = try readStringRaw(allocator, in_stream) },
DW.FORM_strp => FormValue{ .StrPtr = try parseFormValueDwarfOffsetSize(in_stream, is_64) },
DW.FORM_indirect => {
const child_form_id = try leb.readULEB128(u64, in_stream);
const child_form_id = try noasync leb.readULEB128(u64, in_stream);
const F = @typeOf(async parseFormValue(allocator, in_stream, child_form_id, is_64));
var frame = try allocator.create(F);
defer allocator.destroy(frame);
@ -1655,7 +1668,7 @@ fn getAbbrevTableEntry(abbrev_table: *const AbbrevTable, abbrev_code: u64) ?*con
return null;
}
fn parseDie1(di: *DwarfInfo, abbrev_table: *const AbbrevTable, is_64: bool) !?Die {
fn parseDie(di: *DwarfInfo, abbrev_table: *const AbbrevTable, is_64: bool) !?Die {
const abbrev_code = try leb.readULEB128(u64, di.dwarf_in_stream);
if (abbrev_code == 0) return null;
const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) orelse return error.InvalidDebugInfo;
@ -1675,25 +1688,6 @@ fn parseDie1(di: *DwarfInfo, abbrev_table: *const AbbrevTable, is_64: bool) !?Di
return result;
}
fn parseDie(di: *DwarfInfo, abbrev_table: *const AbbrevTable, is_64: bool) !Die {
const abbrev_code = try leb.readULEB128(u64, di.dwarf_in_stream);
const table_entry = getAbbrevTableEntry(abbrev_table, abbrev_code) orelse return error.InvalidDebugInfo;
var result = Die{
.tag_id = table_entry.tag_id,
.has_children = table_entry.has_children,
.attrs = ArrayList(Die.Attr).init(di.allocator()),
};
try result.attrs.resize(table_entry.attrs.len);
for (table_entry.attrs.toSliceConst()) |attr, i| {
result.attrs.items[i] = Die.Attr{
.id = attr.attr_id,
.value = try parseFormValue(di.allocator(), di.dwarf_in_stream, attr.form_id, is_64),
};
}
return result;
}
fn getLineNumberInfoMacOs(di: *DebugInfo, symbol: MachoSymbol, target_address: usize) !LineInfo {
const ofile = symbol.ofile orelse return error.MissingDebugInfo;
const gop = try di.ofiles.getOrPut(ofile);
@ -2103,7 +2097,7 @@ fn scanAllFunctions(di: *DwarfInfo) !void {
const next_unit_pos = this_unit_offset + next_offset;
while ((try di.dwarf_seekable_stream.getPos()) < next_unit_pos) {
const die_obj = (try parseDie1(di, abbrev_table, is_64)) orelse continue;
const die_obj = (try parseDie(di, abbrev_table, is_64)) orelse continue;
const after_die_offset = try di.dwarf_seekable_stream.getPos();
switch (die_obj.tag_id) {
@ -2121,13 +2115,13 @@ fn scanAllFunctions(di: *DwarfInfo) !void {
const ref_offset = try this_die_obj.getAttrRef(DW.AT_abstract_origin);
if (ref_offset > next_offset) return error.InvalidDebugInfo;
try di.dwarf_seekable_stream.seekTo(this_unit_offset + ref_offset);
this_die_obj = (try parseDie1(di, abbrev_table, is_64)) orelse return error.InvalidDebugInfo;
this_die_obj = (try parseDie(di, abbrev_table, is_64)) orelse return error.InvalidDebugInfo;
} else if (this_die_obj.getAttr(DW.AT_specification)) |ref| {
// Follow the DIE it points to and repeat
const ref_offset = try this_die_obj.getAttrRef(DW.AT_specification);
if (ref_offset > next_offset) return error.InvalidDebugInfo;
try di.dwarf_seekable_stream.seekTo(this_unit_offset + ref_offset);
this_die_obj = (try parseDie1(di, abbrev_table, is_64)) orelse return error.InvalidDebugInfo;
this_die_obj = (try parseDie(di, abbrev_table, is_64)) orelse return error.InvalidDebugInfo;
} else {
break :x null;
}
@ -2203,7 +2197,7 @@ fn scanAllCompileUnits(di: *DwarfInfo) !void {
try di.dwarf_seekable_stream.seekTo(compile_unit_pos);
const compile_unit_die = try di.allocator().create(Die);
compile_unit_die.* = try parseDie(di, abbrev_table, is_64);
compile_unit_die.* = (try parseDie(di, abbrev_table, is_64)) orelse return error.InvalidDebugInfo;
if (compile_unit_die.tag_id != DW.TAG_compile_unit) return error.InvalidDebugInfo;
@ -2419,3 +2413,9 @@ stdcallcc fn handleSegfaultWindows(info: *windows.EXCEPTION_POINTERS) c_long {
else => return windows.EXCEPTION_CONTINUE_SEARCH,
}
}
pub fn dumpStackPointerAddr(prefix: []const u8) void {
const sp = asm ("" : [argc] "={rsp}" (-> usize));
std.debug.warn("{} sp = 0x{x}\n", prefix, sp);
}

8
std/io/in_stream.zig
View File

@ -6,7 +6,7 @@ const assert = std.debug.assert;
const mem = std.mem;
const Buffer = std.Buffer;
pub const default_stack_size = 4 * 1024 * 1024;
pub const default_stack_size = 1 * 1024 * 1024;
pub const stack_size: usize = if (@hasDecl(root, "stack_size_std_io_InStream"))
root.stack_size_std_io_InStream
else
@ -32,10 +32,10 @@ pub fn InStream(comptime ReadError: type) type {
/// End of stream is not an error condition.
pub fn read(self: *Self, buffer: []u8) Error!usize {
if (std.io.is_async) {
// Let's not be writing 0xaa in safe modes for upwards of 4 MiB for every stream read.
@setRuntimeSafety(false);
var stack_frame: [stack_size]u8 align(stack_align) = undefined;
// TODO https://github.com/ziglang/zig/issues/3068
var result: Error!usize = undefined;
return await @asyncCall(&stack_frame, &result, self.readFn, self, buffer);
return await @asyncCall(&stack_frame, {}, self.readFn, self, buffer);
} else {
return self.readFn(self, buffer);
}

12
std/os.zig
View File

@ -172,8 +172,7 @@ pub fn abort() noreturn {
system.abort();
}
if (builtin.os == .uefi) {
// TODO there must be a better thing to do here than loop forever
while (true) {}
exit(0); // TODO choose appropriate exit code
}
raise(SIGABRT) catch {};
@ -245,6 +244,15 @@ pub fn exit(status: u8) noreturn {
if (linux.is_the_target and !builtin.single_threaded) {
linux.exit_group(status);
}
if (uefi.is_the_target) {
// exit() is only avaliable if exitBootServices() has not been called yet.
// This call to exit should not fail, so we don't care about its return value.
if (uefi.system_table.boot_services) |bs| {
_ = bs.exit(uefi.handle, status, 0, null);
}
// If we can't exit, reboot the system instead.
uefi.system_table.runtime_services.resetSystem(uefi.tables.ResetType.ResetCold, status, 0, null);
}
system.exit(status);
}

2
std/os/bits/linux.zig
View File

@ -25,7 +25,7 @@ pub const STDOUT_FILENO = 1;
pub const STDERR_FILENO = 2;
/// Special value used to indicate openat should use the current working directory
pub const AT_FDCWD = 100;
pub const AT_FDCWD = -100;
/// Do not follow symbolic links
pub const AT_SYMLINK_NOFOLLOW = 0x100;

7
std/os/linux/tls.zig
View File

@ -132,7 +132,7 @@ pub fn setThreadPointer(addr: usize) void {
}
}
pub fn initTLS() void {
pub fn initTLS() ?*elf.Phdr {
var tls_phdr: ?*elf.Phdr = null;
var img_base: usize = 0;
@ -159,10 +159,13 @@ pub fn initTLS() void {
// Search the TLS section
const phdrs = (@intToPtr([*]elf.Phdr, at_phdr))[0..at_phnum];
var gnu_stack: ?*elf.Phdr = null;
for (phdrs) |*phdr| {
switch (phdr.p_type) {
elf.PT_PHDR => img_base = at_phdr - phdr.p_vaddr,
elf.PT_TLS => tls_phdr = phdr,
elf.PT_GNU_STACK => gnu_stack = phdr,
else => continue,
}
}
@ -224,6 +227,8 @@ pub fn initTLS() void {
.data_offset = data_offset,
};
}
return gnu_stack;
}
pub fn copyTLS(addr: usize) usize {

45
std/os/uefi.zig
View File

@ -1,6 +1,45 @@
// TODO this is where the extern declarations go. For example, see
// inc/efilib.h in gnu-efi-code
pub const protocols = @import("uefi/protocols.zig");
pub const status = @import("uefi/status.zig");
pub const tables = @import("uefi/tables.zig");
const builtin = @import("builtin");
pub const is_the_target = builtin.os == .uefi;
pub var handle: Handle = undefined;
pub var system_table: *tables.SystemTable = undefined;
pub const Event = *@OpaqueType();
// GUIDs must be align(8)
pub const Guid = extern struct {
time_low: u32,
time_mid: u16,
time_high_and_version: u16,
clock_seq_high_and_reserved: u8,
clock_seq_low: u8,
node: [6]u8,
};
pub const Handle = *@OpaqueType();
pub const Time = extern struct {
year: u16,
month: u8,
day: u8,
hour: u8,
minute: u8,
second: u8,
_pad1: u8,
nanosecond: u32,
timezone: i16,
daylight: packed struct {
_pad1: u6,
in_daylight: bool,
adjust_daylight: bool,
},
_pad2: u8,
pub const unspecified_timezone: i16 = 0x7ff;
};
pub const TimeCapabilities = extern struct {
resolution: u32,
accuracy: u32,
sets_to_zero: bool,
};

32
std/os/uefi/protocols.zig Normal file
View File

@ -0,0 +1,32 @@
pub const InputKey = @import("protocols/simple_text_input_ex_protocol.zig").InputKey;
pub const KeyData = @import("protocols/simple_text_input_ex_protocol.zig").KeyData;
pub const KeyState = @import("protocols/simple_text_input_ex_protocol.zig").KeyState;
pub const SimpleTextInputExProtocol = @import("protocols/simple_text_input_ex_protocol.zig").SimpleTextInputExProtocol;
pub const SimpleTextOutputMode = @import("protocols/simple_text_output_protocol.zig").SimpleTextOutputMode;
pub const SimpleTextOutputProtocol = @import("protocols/simple_text_output_protocol.zig").SimpleTextOutputProtocol;
pub const SimplePointerMode = @import("protocols/simple_pointer_protocol.zig").SimplePointerMode;
pub const SimplePointerProtocol = @import("protocols/simple_pointer_protocol.zig").SimplePointerProtocol;
pub const SimplePointerState = @import("protocols/simple_pointer_protocol.zig").SimplePointerState;
pub const AbsolutePointerMode = @import("protocols/absolute_pointer_protocol.zig").AbsolutePointerMode;
pub const AbsolutePointerProtocol = @import("protocols/absolute_pointer_protocol.zig").AbsolutePointerProtocol;
pub const AbsolutePointerState = @import("protocols/absolute_pointer_protocol.zig").AbsolutePointerState;
pub const GraphicsOutputBltPixel = @import("protocols/graphics_output_protocol.zig").GraphicsOutputBltPixel;
pub const GraphicsOutputBltOperation = @import("protocols/graphics_output_protocol.zig").GraphicsOutputBltOperation;
pub const GraphicsOutputModeInformation = @import("protocols/graphics_output_protocol.zig").GraphicsOutputModeInformation;
pub const GraphicsOutputProtocol = @import("protocols/graphics_output_protocol.zig").GraphicsOutputProtocol;
pub const GraphicsOutputProtocolMode = @import("protocols/graphics_output_protocol.zig").GraphicsOutputProtocolMode;
pub const GraphicsPixelFormat = @import("protocols/graphics_output_protocol.zig").GraphicsPixelFormat;
pub const PixelBitmask = @import("protocols/graphics_output_protocol.zig").PixelBitmask;
pub const EdidDiscoveredProtocol = @import("protocols/edid_discovered_protocol.zig").EdidDiscoveredProtocol;
pub const EdidActiveProtocol = @import("protocols/edid_active_protocol.zig").EdidActiveProtocol;
pub const EdidOverrideProtocol = @import("protocols/edid_override_protocol.zig").EdidOverrideProtocol;
pub const EdidOverrideProtocolAttributes = @import("protocols/edid_override_protocol.zig").EdidOverrideProtocolAttributes;
pub const RNGProtocol = @import("protocols/rng_protocol.zig").RNGProtocol;

53
std/os/uefi/protocols/absolute_pointer_protocol.zig Normal file
View File

@ -0,0 +1,53 @@
const uefi = @import("std").os.uefi;
const Event = uefi.Event;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 12.7
pub const AbsolutePointerProtocol = extern struct {
_reset: extern fn (*const AbsolutePointerProtocol, bool) usize,
_get_state: extern fn (*const AbsolutePointerProtocol, *AbsolutePointerState) usize,
wait_for_input: Event,
mode: *AbsolutePointerMode,
pub fn reset(self: *const AbsolutePointerProtocol, verify: bool) usize {
return self._reset(self, verify);
}
pub fn getState(self: *const AbsolutePointerProtocol, state: *AbsolutePointerState) usize {
return self._get_state(self, state);
}
pub const guid align(8) = Guid{
.time_low = 0x8d59d32b,
.time_mid = 0xc655,
.time_high_and_version = 0x4ae9,
.clock_seq_high_and_reserved = 0x9b,
.clock_seq_low = 0x15,
.node = [_]u8{ 0xf2, 0x59, 0x04, 0x99, 0x2a, 0x43 },
};
};
pub const AbsolutePointerMode = extern struct {
absolute_min_x: u64,
absolute_min_y: u64,
absolute_min_z: u64,
absolute_max_x: u64,
absolute_max_y: u64,
absolute_max_z: u64,
attributes: packed struct {
supports_alt_active: bool,
supports_pressure_as_z: bool,
_pad1: u30,
},
};
pub const AbsolutePointerState = extern struct {
current_x: u64 = undefined,
current_y: u64 = undefined,
current_z: u64 = undefined,
active_buttons: packed struct {
touch_active: bool,
alt_active: bool,
_pad1: u30,
} = undefined,
};

17
std/os/uefi/protocols/edid_active_protocol.zig Normal file
View File

@ -0,0 +1,17 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 12.9
pub const EdidActiveProtocol = extern struct {
size_of_edid: u32,
edid: ?[*]u8,
pub const guid align(8) = Guid{
.time_low = 0xbd8c1056,
.time_mid = 0x9f36,
.time_high_and_version = 0x44ec,
.clock_seq_high_and_reserved = 0x92,
.clock_seq_low = 0xa8,
.node = [_]u8{ 0xa6, 0x33, 0x7f, 0x81, 0x79, 0x86 },
};
};

17
std/os/uefi/protocols/edid_discovered_protocol.zig Normal file
View File

@ -0,0 +1,17 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 12.9
pub const EdidDiscoveredProtocol = extern struct {
size_of_edid: u32,
edid: ?[*]u8,
pub const guid align(8) = Guid{
.time_low = 0x1c0c34f6,
.time_mid = 0xd380,
.time_high_and_version = 0x41fa,
.clock_seq_high_and_reserved = 0xa0,
.clock_seq_low = 0x49,
.node = [_]u8{ 0x8a, 0xd0, 0x6c, 0x1a, 0x66, 0xaa },
};
};

28
std/os/uefi/protocols/edid_override_protocol.zig Normal file
View File

@ -0,0 +1,28 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
const Handle = uefi.Handle;
/// UEFI Specification, Version 2.8, 12.9
pub const EdidOverrideProtocol = extern struct {
_get_edid: extern fn (*const EdidOverrideProtocol, Handle, *u32, *usize, *?[*]u8) usize,
/// attributes must be align(4)
pub fn getEdid(self: *const EdidOverrideProtocol, handle: Handle, attributes: *EdidOverrideProtocolAttributes, edid_size: *usize, edid: *?[*]u8) usize {
return self._get_edid(self, handle, attributes, edid_size, edid);
}
pub const guid align(8) = Guid{
.time_low = 0x48ecb431,
.time_mid = 0xfb72,
.time_high_and_version = 0x45c0,
.clock_seq_high_and_reserved = 0xa9,
.clock_seq_low = 0x22,
.node = [_]u8{ 0xf4, 0x58, 0xfe, 0x04, 0x0b, 0xd5 },
};
};
pub const EdidOverrideProtocolAttributes = packed struct {
dont_override: bool,
enable_hot_plug: bool,
_pad1: u30,
};

79
std/os/uefi/protocols/graphics_output_protocol.zig Normal file
View File

@ -0,0 +1,79 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 12.9
pub const GraphicsOutputProtocol = extern struct {
_query_mode: extern fn (*const GraphicsOutputProtocol, u32, *usize, **GraphicsOutputModeInformation) usize,
_set_mode: extern fn (*const GraphicsOutputProtocol, u32) usize,
_blt: extern fn (*const GraphicsOutputProtocol, ?[*]GraphicsOutputBltPixel, GraphicsOutputBltOperation, usize, usize, usize, usize, usize, usize, usize) usize,
mode: *GraphicsOutputProtocolMode,
pub fn queryMode(self: *const GraphicsOutputProtocol, mode: u32, size_of_info: *usize, info: **GraphicsOutputModeInformation) usize {
return self._query_mode(self, mode, size_of_info, info);
}
pub fn setMode(self: *const GraphicsOutputProtocol, mode: u32) usize {
return self._set_mode(self, mode);
}
pub fn blt(self: *const GraphicsOutputProtocol, blt_buffer: ?[*]GraphicsOutputBltPixel, blt_operation: GraphicsOutputBltOperation, source_x: usize, source_y: usize, destination_x: usize, destination_y: usize, width: usize, height: usize, delta: usize) usize {
return self._blt(self, blt_buffer, blt_operation, source_x, source_y, destination_x, destination_y, width, height, delta);
}
pub const guid align(8) = Guid{
.time_low = 0x9042a9de,
.time_mid = 0x23dc,
.time_high_and_version = 0x4a38,
.clock_seq_high_and_reserved = 0x96,
.clock_seq_low = 0xfb,
.node = [_]u8{ 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a },
};
};
pub const GraphicsOutputProtocolMode = extern struct {
max_mode: u32,
mode: u32,
info: *GraphicsOutputModeInformation,
size_of_info: usize,
frame_buffer_base: u64,
frame_buffer_size: usize,
};
pub const GraphicsOutputModeInformation = extern struct {
version: u32 = undefined,
horizontal_resolution: u32 = undefined,
vertical_resolution: u32 = undefined,
pixel_format: GraphicsPixelFormat = undefined,
pixel_information: PixelBitmask = undefined,
pixels_per_scan_line: u32 = undefined,
};
pub const GraphicsPixelFormat = extern enum(u32) {
PixelRedGreenBlueReserved8BitPerColor,
PixelBlueGreenRedReserved8BitPerColor,
PixelBitMask,
PixelBltOnly,
PixelFormatMax,
};
pub const PixelBitmask = extern struct {
red_mask: u32,
green_mask: u32,
blue_mask: u32,
reserved_mask: u32,
};
pub const GraphicsOutputBltPixel = extern struct {
blue: u8,
green: u8,
red: u8,
reserved: u8 = undefined,
};
pub const GraphicsOutputBltOperation = extern enum(u32) {
BltVideoFill,
BltVideoToBltBuffer,
BltBufferToVideo,
BltVideoToVideo,
GraphicsOutputBltOperationMax,
};

73
std/os/uefi/protocols/rng_protocol.zig Normal file
View File

@ -0,0 +1,73 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 37.5
pub const RNGProtocol = extern struct {
_get_info: extern fn (*const RNGProtocol, *usize, [*]align(8) Guid) usize,
_get_rng: extern fn (*const RNGProtocol, ?*align(8) const Guid, usize, [*]u8) usize,
pub fn getInfo(self: *const RNGProtocol, list_size: *usize, list: [*]align(8) Guid) usize {
return self._get_info(self, list_size, list);
}
pub fn getRNG(self: *const RNGProtocol, algo: ?*const Guid, value_length: usize, value: [*]u8) usize {
return self._get_rng(self, algo, value_length, value);
}
pub const guid align(8) = Guid{
.time_low = 0x3152bca5,
.time_mid = 0xeade,
.time_high_and_version = 0x433d,
.clock_seq_high_and_reserved = 0x86,
.clock_seq_low = 0x2e,
.node = [_]u8{ 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44 },
};
pub const algorithm_sp800_90_hash_256 align(8) = Guid{
.time_low = 0xa7af67cb,
.time_mid = 0x603b,
.time_high_and_version = 0x4d42,
.clock_seq_high_and_reserved = 0xba,
.clock_seq_low = 0x21,
.node = [_]u8{ 0x70, 0xbf, 0xb6, 0x29, 0x3f, 0x96 },
};
pub const algorithm_sp800_90_hmac_256 align(8) = Guid{
.time_low = 0xc5149b43,
.time_mid = 0xae85,
.time_high_and_version = 0x4f53,
.clock_seq_high_and_reserved = 0x99,
.clock_seq_low = 0x82,
.node = [_]u8{ 0xb9, 0x43, 0x35, 0xd3, 0xa9, 0xe7 },
};
pub const algorithm_sp800_90_ctr_256 align(8) = Guid{
.time_low = 0x44f0de6e,
.time_mid = 0x4d8c,
.time_high_and_version = 0x4045,
.clock_seq_high_and_reserved = 0xa8,
.clock_seq_low = 0xc7,
.node = [_]u8{ 0x4d, 0xd1, 0x68, 0x85, 0x6b, 0x9e },
};
pub const algorithm_x9_31_3des align(8) = Guid{
.time_low = 0x63c4785a,
.time_mid = 0xca34,
.time_high_and_version = 0x4012,
.clock_seq_high_and_reserved = 0xa3,
.clock_seq_low = 0xc8,
.node = [_]u8{ 0x0b, 0x6a, 0x32, 0x4f, 0x55, 0x46 },
};
pub const algorithm_x9_31_aes align(8) = Guid{
.time_low = 0xacd03321,
.time_mid = 0x777e,
.time_high_and_version = 0x4d3d,
.clock_seq_high_and_reserved = 0xb1,
.clock_seq_low = 0xc8,
.node = [_]u8{ 0x20, 0xcf, 0xd8, 0x88, 0x20, 0xc9 },
};
pub const algorithm_raw align(8) = Guid{
.time_low = 0xe43176d7,
.time_mid = 0xb6e8,
.time_high_and_version = 0x4827,
.clock_seq_high_and_reserved = 0xb7,
.clock_seq_low = 0x84,
.node = [_]u8{ 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61 },
};
};

44
std/os/uefi/protocols/simple_pointer_protocol.zig Normal file
View File

@ -0,0 +1,44 @@
const uefi = @import("std").os.uefi;
const Event = uefi.Event;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 12.5
pub const SimplePointerProtocol = struct {
_reset: extern fn (*const SimplePointerProtocol, bool) usize,
_get_state: extern fn (*const SimplePointerProtocol, *SimplePointerState) usize,
wait_for_input: Event,
mode: *SimplePointerMode,
pub fn reset(self: *const SimplePointerProtocol, verify: bool) usize {
return self._reset(self, verify);
}
pub fn getState(self: *const SimplePointerProtocol, state: *SimplePointerState) usize {
return self._get_state(self, state);
}
pub const guid align(8) = Guid{
.time_low = 0x31878c87,
.time_mid = 0x0b75,
.time_high_and_version = 0x11d5,
.clock_seq_high_and_reserved = 0x9a,
.clock_seq_low = 0x4f,
.node = [_]u8{ 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d },
};
};
pub const SimplePointerMode = struct {
resolution_x: u64,
resolution_y: u64,
resolution_z: u64,
left_button: bool,
right_button: bool,
};
pub const SimplePointerState = struct {
relative_movement_x: i32 = undefined,
relative_movement_y: i32 = undefined,
relative_movement_z: i32 = undefined,
left_button: bool = undefined,
right_button: bool = undefined,
};

77
std/os/uefi/protocols/simple_text_input_ex_protocol.zig Normal file
View File

@ -0,0 +1,77 @@
const uefi = @import("std").os.uefi;
const Event = uefi.Event;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 12.3
pub const SimpleTextInputExProtocol = extern struct {
_reset: extern fn (*const SimpleTextInputExProtocol, bool) usize,
_read_key_stroke_ex: extern fn (*const SimpleTextInputExProtocol, *KeyData) usize,
wait_for_key_ex: Event,
_set_state: extern fn (*const SimpleTextInputExProtocol, *const u8) usize,
_register_key_notify: extern fn (*const SimpleTextInputExProtocol, *const KeyData, extern fn (*const KeyData) usize, **c_void) usize,
_unregister_key_notify: extern fn (*const SimpleTextInputExProtocol, *const c_void) usize,
pub fn reset(self: *const SimpleTextInputExProtocol, verify: bool) usize {
return self._reset(self, verify);
}
pub fn readKeyStrokeEx(self: *const SimpleTextInputExProtocol, key_data: *KeyData) usize {
return self._read_key_stroke_ex(self, key_data);
}
pub fn setState(self: *const SimpleTextInputExProtocol, state: *const u8) usize {
return self._set_state(self, state);
}
pub fn registerKeyNotify(self: *const SimpleTextInputExProtocol, key_data: *const KeyData, notify: extern fn (*const KeyData) usize, handle: **c_void) usize {
return self._register_key_notify(self, key_data, notify, handle);
}
pub fn unregisterKeyNotify(self: *const SimpleTextInputExProtocol, handle: *const c_void) usize {
return self._unregister_key_notify(self, handle);
}
pub const guid align(8) = Guid{
.time_low = 0xdd9e7534,
.time_mid = 0x7762,
.time_high_and_version = 0x4698,
.clock_seq_high_and_reserved = 0x8c,
.clock_seq_low = 0x14,
.node = [_]u8{ 0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa },
};
};
pub const KeyData = extern struct {
key: InputKey = undefined,
key_state: KeyState = undefined,
};
pub const KeyState = extern struct {
key_shift_state: packed struct {
right_shift_pressed: bool,
left_shift_pressed: bool,
right_control_pressed: bool,
left_control_pressed: bool,
right_alt_pressed: bool,
left_alt_pressed: bool,
right_logo_pressed: bool,
left_logo_pressed: bool,
menu_key_pressed: bool,
sys_req_pressed: bool,
_pad1: u21,
shift_state_valid: bool,
},
key_toggle_state: packed struct {
scroll_lock_active: bool,
num_lock_active: bool,
caps_lock_active: bool,
_pad1: u3,
key_state_exposed: bool,
toggle_state_valid: bool,
},
};
pub const InputKey = extern struct {
scan_code: u16,
unicode_char: u16,
};

143
std/os/uefi/protocols/simple_text_output_protocol.zig Normal file
View File

@ -0,0 +1,143 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 12.4
pub const SimpleTextOutputProtocol = extern struct {
_reset: extern fn (*const SimpleTextOutputProtocol, bool) usize,
_output_string: extern fn (*const SimpleTextOutputProtocol, [*]const u16) usize,
_test_string: extern fn (*const SimpleTextOutputProtocol, [*]const u16) usize,
_query_mode: extern fn (*const SimpleTextOutputProtocol, usize, *usize, *usize) usize,
_set_mode: extern fn (*const SimpleTextOutputProtocol, usize) usize,
_set_attribute: extern fn (*const SimpleTextOutputProtocol, usize) usize,
_clear_screen: extern fn (*const SimpleTextOutputProtocol) usize,
_set_cursor_position: extern fn (*const SimpleTextOutputProtocol, usize, usize) usize,
_enable_cursor: extern fn (*const SimpleTextOutputProtocol, bool) usize,
mode: *SimpleTextOutputMode,
pub fn reset(self: *const SimpleTextOutputProtocol, verify: bool) usize {
return self._reset(self, verify);
}
pub fn outputString(self: *const SimpleTextOutputProtocol, msg: [*]const u16) usize {
return self._output_string(self, msg);
}
pub fn testString(self: *const SimpleTextOutputProtocol, msg: [*]const u16) usize {
return self._test_string(self, msg);
}
pub fn queryMode(self: *const SimpleTextOutputProtocol, mode_number: usize, columns: *usize, rows: *usize) usize {
return self._query_mode(self, mode_number, columns, rows);
}
pub fn setMode(self: *const SimpleTextOutputProtocol, mode_number: usize) usize {
return self._set_mode(self, mode_number);
}
pub fn setAttribute(self: *const SimpleTextOutputProtocol, attribute: usize) usize {
return self._set_attribute(self, attribute);
}
pub fn clearScreen(self: *const SimpleTextOutputProtocol) usize {
return self._clear_screen(self);
}
pub fn setCursorPosition(self: *const SimpleTextOutputProtocol, column: usize, row: usize) usize {
return self._set_cursor_position(self, column, row);
}
pub fn enableCursor(self: *const SimpleTextOutputProtocol, visible: bool) usize {
return self._enable_cursor(self, visible);
}
pub const guid align(8) = Guid{
.time_low = 0x387477c2,
.time_mid = 0x69c7,
.time_high_and_version = 0x11d2,
.clock_seq_high_and_reserved = 0x8e,
.clock_seq_low = 0x39,
.node = [_]u8{ 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b },
};
pub const boxdraw_horizontal: u16 = 0x2500;
pub const boxdraw_vertical: u16 = 0x2502;
pub const boxdraw_down_right: u16 = 0x250c;
pub const boxdraw_down_left: u16 = 0x2510;
pub const boxdraw_up_right: u16 = 0x2514;
pub const boxdraw_up_left: u16 = 0x2518;
pub const boxdraw_vertical_right: u16 = 0x251c;
pub const boxdraw_vertical_left: u16 = 0x2524;
pub const boxdraw_down_horizontal: u16 = 0x252c;
pub const boxdraw_up_horizontal: u16 = 0x2534;
pub const boxdraw_vertical_horizontal: u16 = 0x253c;
pub const boxdraw_double_horizontal: u16 = 0x2550;
pub const boxdraw_double_vertical: u16 = 0x2551;
pub const boxdraw_down_right_double: u16 = 0x2552;
pub const boxdraw_down_double_right: u16 = 0x2553;
pub const boxdraw_double_down_right: u16 = 0x2554;
pub const boxdraw_down_left_double: u16 = 0x2555;
pub const boxdraw_down_double_left: u16 = 0x2556;
pub const boxdraw_double_down_left: u16 = 0x2557;
pub const boxdraw_up_right_double: u16 = 0x2558;
pub const boxdraw_up_double_right: u16 = 0x2559;
pub const boxdraw_double_up_right: u16 = 0x255a;
pub const boxdraw_up_left_double: u16 = 0x255b;
pub const boxdraw_up_double_left: u16 = 0x255c;
pub const boxdraw_double_up_left: u16 = 0x255d;
pub const boxdraw_vertical_right_double: u16 = 0x255e;
pub const boxdraw_vertical_double_right: u16 = 0x255f;
pub const boxdraw_double_vertical_right: u16 = 0x2560;
pub const boxdraw_vertical_left_double: u16 = 0x2561;
pub const boxdraw_vertical_double_left: u16 = 0x2562;
pub const boxdraw_double_vertical_left: u16 = 0x2563;
pub const boxdraw_down_horizontal_double: u16 = 0x2564;
pub const boxdraw_down_double_horizontal: u16 = 0x2565;
pub const boxdraw_double_down_horizontal: u16 = 0x2566;
pub const boxdraw_up_horizontal_double: u16 = 0x2567;
pub const boxdraw_up_double_horizontal: u16 = 0x2568;
pub const boxdraw_double_up_horizontal: u16 = 0x2569;
pub const boxdraw_vertical_horizontal_double: u16 = 0x256a;
pub const boxdraw_vertical_double_horizontal: u16 = 0x256b;
pub const boxdraw_double_vertical_horizontal: u16 = 0x256c;
pub const blockelement_full_block: u16 = 0x2588;
pub const blockelement_light_shade: u16 = 0x2591;
pub const geometricshape_up_triangle: u16 = 0x25b2;
pub const geometricshape_right_triangle: u16 = 0x25ba;
pub const geometricshape_down_triangle: u16 = 0x25bc;
pub const geometricshape_left_triangle: u16 = 0x25c4;
pub const arrow_up: u16 = 0x2591;
pub const arrow_down: u16 = 0x2593;
pub const black: u8 = 0x00;
pub const blue: u8 = 0x01;
pub const green: u8 = 0x02;
pub const cyan: u8 = 0x03;
pub const red: u8 = 0x04;
pub const magenta: u8 = 0x05;
pub const brown: u8 = 0x06;
pub const lightgray: u8 = 0x07;
pub const bright: u8 = 0x08;
pub const darkgray: u8 = 0x08;
pub const lightblue: u8 = 0x09;
pub const lightgreen: u8 = 0x0a;
pub const lightcyan: u8 = 0x0b;
pub const lightred: u8 = 0x0c;
pub const lightmagenta: u8 = 0x0d;
pub const yellow: u8 = 0x0e;
pub const white: u8 = 0x0f;
pub const background_black: u8 = 0x00;
pub const background_blue: u8 = 0x10;
pub const background_green: u8 = 0x20;
pub const background_cyan: u8 = 0x30;
pub const background_red: u8 = 0x40;
pub const background_magenta: u8 = 0x50;
pub const background_brown: u8 = 0x60;
pub const background_lightgray: u8 = 0x70;
};
pub const SimpleTextOutputMode = extern struct {
max_mode: u32, // specified as signed
mode: u32, // specified as signed
attribute: i32,
cursor_column: i32,
cursor_row: i32,
cursor_visible: bool,
};

46
std/os/uefi/status.zig Normal file
View File

@ -0,0 +1,46 @@
const high_bit = 1 << @typeInfo(usize).Int.bits - 1;
/// UEFI Specification, Version 2.8, Appendix D
pub const success: usize = 0;
pub const load_error: usize = high_bit | 1;
pub const invalid_parameter: usize = high_bit | 2;
pub const unsupported: usize = high_bit | 3;
pub const bad_buffer_size: usize = high_bit | 4;
pub const buffer_too_small: usize = high_bit | 5;
pub const not_ready: usize = high_bit | 6;
pub const device_error: usize = high_bit | 7;
pub const write_protected: usize = high_bit | 8;
pub const out_of_resources: usize = high_bit | 9;
pub const volume_corrupted: usize = high_bit | 10;
pub const volume_full: usize = high_bit | 11;
pub const no_media: usize = high_bit | 12;
pub const media_changed: usize = high_bit | 13;
pub const not_found: usize = high_bit | 14;
pub const access_denied: usize = high_bit | 15;
pub const no_response: usize = high_bit | 16;
pub const no_mapping: usize = high_bit | 17;
pub const timeout: usize = high_bit | 18;
pub const not_started: usize = high_bit | 19;
pub const already_started: usize = high_bit | 20;
pub const aborted: usize = high_bit | 21;
pub const icmp_error: usize = high_bit | 22;
pub const tftp_error: usize = high_bit | 23;
pub const protocol_error: usize = high_bit | 24;
pub const incompatible_version: usize = high_bit | 25;
pub const security_violation: usize = high_bit | 26;
pub const crc_error: usize = high_bit | 27;
pub const end_of_media: usize = high_bit | 28;
pub const end_of_file: usize = high_bit | 31;
pub const invalid_language: usize = high_bit | 32;
pub const compromised_data: usize = high_bit | 33;
pub const ip_address_conflict: usize = high_bit | 34;
pub const http_error: usize = high_bit | 35;
pub const warn_unknown_glyph: usize = 1;
pub const warn_delete_failure: usize = 2;
pub const warn_write_failure: usize = 3;
pub const warn_buffer_too_small: usize = 4;
pub const warn_stale_data: usize = 5;
pub const warn_file_system: usize = 6;
pub const warn_reset_required: usize = 7;

9
std/os/uefi/tables.zig Normal file
View File

@ -0,0 +1,9 @@
pub const BootServices = @import("tables/boot_services.zig").BootServices;
pub const ConfigurationTable = @import("tables/configuration_table.zig").ConfigurationTable;
pub const global_variable align(8) = @import("tables/runtime_services.zig").global_variable;
pub const MemoryDescriptor = @import("tables/boot_services.zig").MemoryDescriptor;
pub const ResetType = @import("tables/runtime_services.zig").ResetType;
pub const RuntimeServices = @import("tables/runtime_services.zig").RuntimeServices;
pub const SystemTable = @import("tables/system_table.zig").SystemTable;
pub const TableHeader = @import("tables/table_header.zig").TableHeader;
pub const TimerDelay = @import("tables/boot_services.zig").TimerDelay;

125
std/os/uefi/tables/boot_services.zig Normal file
View File

@ -0,0 +1,125 @@
const uefi = @import("std").os.uefi;
const Event = uefi.Event;
const Guid = uefi.Guid;
const Handle = uefi.Handle;
const TableHeader = uefi.tables.TableHeader;
/// UEFI Specification, Version 2.8, 4.4
///
/// As the boot_services table may grow with new UEFI versions, it is important to check hdr.header_size.
///
/// Boot Services must not be used after exitBootServices has been called. The only exception is
/// getMemoryMap, which may be used after the first unsuccessful call to exitBootServices.
/// After successfully calling exitBootServices, system_table.console_in_handle, system_table.con_in,
/// system_table.console_out_handle, system_table.con_out, system_table.standard_error_handle,
/// system_table.std_err, and system_table.boot_services should be set to null. After setting these
/// attributes to null, system_table.hdr.crc32 must be recomputed. See UEFI Specification, Version 2.8, 7.4.
pub const BootServices = extern struct {
hdr: TableHeader,
raiseTpl: usize, // TODO
restoreTpl: usize, // TODO
allocatePages: usize, // TODO
freePages: usize, // TODO
getMemoryMap: extern fn (*usize, [*]MemoryDescriptor, *usize, *usize, *u32) usize,
allocatePool: usize, // TODO
freePool: usize, // TODO
createEvent: extern fn (u32, usize, ?extern fn (Event, ?*const c_void) void, ?*const c_void, *Event) usize,
setTimer: extern fn (Event, TimerDelay, u64) usize,
waitForEvent: extern fn (usize, [*]const Event, *usize) usize,
signalEvent: extern fn (Event) usize,
closeEvent: extern fn (Event) usize,
checkEvent: usize, // TODO
installProtocolInterface: usize, // TODO
reinstallProtocolInterface: usize, // TODO
uninstallProtocolInterface: usize, // TODO
handleProtocol: usize, // TODO
reserved: *c_void,
registerProtocolNotify: usize, // TODO
locateHandle: usize, // TODO
locateDevicePath: usize, // TODO
installConfigurationTable: usize, // TODO
imageLoad: usize, // TODO
imageStart: usize, // TODO
exit: extern fn (Handle, usize, usize, ?*const c_void) usize,
imageUnload: usize, // TODO
exitBootServices: usize, // TODO
getNextMonotonicCount: usize, // TODO
stall: extern fn (usize) usize,
setWatchdogTimer: extern fn (usize, u64, usize, ?[*]const u16) usize,
connectController: usize, // TODO
disconnectController: usize, // TODO
openProtocol: usize, // TODO
closeProtocol: usize, // TODO
openProtocolInformation: usize, // TODO
protocolsPerHandle: usize, // TODO
locateHandleBuffer: usize, // TODO
locateProtocol: extern fn (*align(8) const Guid, ?*const c_void, *?*c_void) usize,
installMultipleProtocolInterfaces: usize, // TODO
uninstallMultipleProtocolInterfaces: usize, // TODO
calculateCrc32: usize, // TODO
copyMem: usize, // TODO
setMem: usize, // TODO
createEventEx: usize, // TODO
pub const signature: u64 = 0x56524553544f4f42;
pub const event_timer: u32 = 0x80000000;
pub const event_runtime: u32 = 0x40000000;
pub const event_notify_wait: u32 = 0x00000100;
pub const event_notify_signal: u32 = 0x00000200;
pub const event_signal_exit_boot_services: u32 = 0x00000201;
pub const event_signal_virtual_address_change: u32 = 0x00000202;
pub const tpl_application: usize = 4;
pub const tpl_callback: usize = 8;
pub const tpl_notify: usize = 16;
pub const tpl_high_level: usize = 31;
};
pub const TimerDelay = extern enum(u32) {
TimerCancel,
TimerPeriodic,
TimerRelative,
};
pub const MemoryDescriptor = extern struct {
type: extern enum(u32) {
ReservedMemoryType,
LoaderCode,
LoaderData,
BootServicesCode,
BootServicesData,
RuntimeServicesCode,
RuntimeServicesData,
ConventionalMemory,
UnusableMemory,
ACPIReclaimMemory,
ACPIMemoryNVS,
MemoryMappedIO,
MemoryMappedIOPortSpace,
PalCode,
PersistentMemory,
MaxMemoryType,
},
physical_start: u64,
virtual_start: u64,
number_of_pages: usize,
attribute: packed struct {
uc: bool,
wc: bool,
wt: bool,
wb: bool,
uce: bool,
_pad1: u7,
wp: bool,
rp: bool,
xp: bool,
nv: bool,
more_reliable: bool,
ro: bool,
sp: bool,
cpu_crypto: bool,
_pad2: u43,
memory_runtime: bool,
},
};

82
std/os/uefi/tables/configuration_table.zig Normal file
View File

@ -0,0 +1,82 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
/// UEFI Specification, Version 2.8, 4.6
/// Because GUIDs must be align(8), structs of this type also must be align(8)
pub const ConfigurationTable = extern struct {
vendor_guid: Guid,
vendor_table: *c_void,
pub const acpi_20_table_guid align(8) = Guid{
.time_low = 0x8868e871,
.time_mid = 0xe4f1,
.time_high_and_version = 0x11d3,
.clock_seq_high_and_reserved = 0xbc,
.clock_seq_low = 0x22,
.node = [_]u8{ 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81 },
};
pub const acpi_10_table_guid align(8) = Guid{
.time_low = 0xeb9d2d30,
.time_mid = 0x2d88,
.time_high_and_version = 0x11d3,
.clock_seq_high_and_reserved = 0x9a,
.clock_seq_low = 0x16,
.node = [_]u8{ 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d },
};
pub const sal_system_table_guid align(8) = Guid{
.time_low = 0xeb9d2d32,
.time_mid = 0x2d88,
.time_high_and_version = 0x113d,
.clock_seq_high_and_reserved = 0x9a,
.clock_seq_low = 0x16,
.node = [_]u8{ 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d },
};
pub const smbios_table_guid align(8) = Guid{
.time_low = 0xeb9d2d31,
.time_mid = 0x2d88,
.time_high_and_version = 0x11d3,
.clock_seq_high_and_reserved = 0x9a,
.clock_seq_low = 0x16,
.node = [_]u8{ 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d },
};
pub const smbios3_table_guid align(8) = Guid{
.time_low = 0xf2fd1544,
.time_mid = 0x9794,
.time_high_and_version = 0x4a2c,
.clock_seq_high_and_reserved = 0x99,
.clock_seq_low = 0x2e,
.node = [_]u8{ 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94 },
};
pub const mps_table_guid align(8) = Guid{
.time_low = 0xeb9d2d2f,
.time_mid = 0x2d88,
.time_high_and_version = 0x11d3,
.clock_seq_high_and_reserved = 0x9a,
.clock_seq_low = 0x16,
.node = [_]u8{ 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d },
};
pub const json_config_data_table_guid align(8) = Guid{
.time_low = 0x87367f87,
.time_mid = 0x1119,
.time_high_and_version = 0x41ce,
.clock_seq_high_and_reserved = 0xaa,
.clock_seq_low = 0xec,
.node = [_]u8{ 0x8b, 0xe0, 0x11, 0x1f, 0x55, 0x8a },
};
pub const json_capsule_data_table_guid align(8) = Guid{
.time_low = 0x35e7a725,
.time_mid = 0x8dd2,
.time_high_and_version = 0x4cac,
.clock_seq_high_and_reserved = 0x80,
.clock_seq_low = 0x11,
.node = [_]u8{ 0x33, 0xcd, 0xa8, 0x10, 0x90, 0x56 },
};
pub const json_capsule_result_table_guid align(8) = Guid{
.time_low = 0xdbc461c3,
.time_mid = 0xb3de,
.time_high_and_version = 0x422a,
.clock_seq_high_and_reserved = 0xb9,
.clock_seq_low = 0xb4,
.node = [_]u8{ 0x98, 0x86, 0xfd, 0x49, 0xa1, 0xe5 },
};
};

51
std/os/uefi/tables/runtime_services.zig Normal file
View File

@ -0,0 +1,51 @@
const uefi = @import("std").os.uefi;
const Guid = uefi.Guid;
const TableHeader = uefi.tables.TableHeader;
const Time = uefi.Time;
const TimeCapabilities = uefi.TimeCapabilities;
/// UEFI Specification, Version 2.8, 4.5
///
/// As the runtime_services table may grow with new UEFI versions, it is important to check hdr.header_size.
///
/// Some functions may not be supported. Check the RuntimeServicesSupported variable using getVariable.
/// getVariable is one of the functions that may not be supported. See UEFI Specification, Version 2.8, 8.1.
///
/// Some functions may not be called while other functions are running. See UEFI Specification, Version 2.8, 8.1.
pub const RuntimeServices = extern struct {
hdr: TableHeader,
getTime: extern fn (*uefi.Time, ?*TimeCapabilities) usize,
setTime: usize, // TODO
getWakeupTime: usize, // TODO
setWakeupTime: usize, // TODO
setVirtualAddressMap: usize, // TODO
convertPointer: usize, // TODO
getVariable: extern fn ([*]const u16, *align(8) const Guid, ?*u32, *usize, ?*c_void) usize,
getNextVariableName: extern fn (*usize, [*]u16, *align(8) Guid) usize,
setVariable: extern fn ([*]const u16, *align(8) const Guid, u32, usize, *c_void) usize,
getNextHighMonotonicCount: usize, // TODO
resetSystem: extern fn (ResetType, usize, usize, ?*const c_void) noreturn,
updateCapsule: usize, // TODO
queryCapsuleCapabilities: usize, // TODO
queryVariableInfo: usize, // TODO
pub const signature: u64 = 0x56524553544e5552;
};
/// UEFI Specification, Version 2.8, 8.5.1
pub const ResetType = extern enum(u32) {
ResetCold,
ResetWarm,
ResetShutdown,
ResetPlatformSpecific,
};
/// UEFI Specification, Version 2.8, 3.3
pub const global_variable align(8) = Guid{
.time_low = 0x8be4df61,
.time_mid = 0x93ca,
.time_high_and_version = 0x11d2,
.clock_seq_high_and_reserved = 0xaa,
.clock_seq_low = 0x0d,
.node = [_]u8{ 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c },
};

46
std/os/uefi/tables/system_table.zig Normal file
View File

@ -0,0 +1,46 @@
const uefi = @import("std").os.uefi;
const BootServices = uefi.tables.BootServices;
const ConfigurationTable = uefi.tables.ConfigurationTable;
const Handle = uefi.Handle;
const RuntimeServices = uefi.tables.RuntimeServices;
const SimpleTextInputExProtocol = uefi.protocols.SimpleTextInputExProtocol;
const SimpleTextOutputProtocol = uefi.protocols.SimpleTextOutputProtocol;
const TableHeader = uefi.tables.TableHeader;
/// UEFI Specification, Version 2.8, 4.3
///
/// As the system_table may grow with new UEFI versions, it is important to check hdr.header_size.
///
/// After successfully calling boot_services.exitBootServices, console_in_handle,
/// con_in, console_out_handle, con_out, standard_error_handle, std_err, and
/// boot_services should be set to null. After setting these attributes to null,
/// hdr.crc32 must be recomputed. See UEFI Specification, Version 2.8, 7.4.
pub const SystemTable = extern struct {
hdr: TableHeader,
firmware_vendor: *u16,
firmware_revision: u32,
console_in_handle: ?Handle,
con_in: ?*SimpleTextInputExProtocol,
console_out_handle: ?Handle,
con_out: ?*SimpleTextOutputProtocol,
standard_error_handle: ?Handle,
std_err: ?*SimpleTextOutputProtocol,
runtime_services: *RuntimeServices,
boot_services: ?*BootServices,
number_of_table_entries: usize,
configuration_table: *ConfigurationTable,
pub const signature: u64 = 0x5453595320494249;
pub const revision_1_02: u32 = (1 << 16) | 2;
pub const revision_1_10: u32 = (1 << 16) | 10;
pub const revision_2_00: u32 = (2 << 16);
pub const revision_2_10: u32 = (2 << 16) | 10;
pub const revision_2_20: u32 = (2 << 16) | 20;
pub const revision_2_30: u32 = (2 << 16) | 30;
pub const revision_2_31: u32 = (2 << 16) | 31;
pub const revision_2_40: u32 = (2 << 16) | 40;
pub const revision_2_50: u32 = (2 << 16) | 50;
pub const revision_2_60: u32 = (2 << 16) | 60;
pub const revision_2_70: u32 = (2 << 16) | 70;
pub const revision_2_80: u32 = (2 << 16) | 80;
};

8
std/os/uefi/tables/table_header.zig Normal file
View File

@ -0,0 +1,8 @@
/// UEFI Specification, Version 2.8, 4.2
pub const TableHeader = extern struct {
signature: u64,
revision: u32,
header_size: u32,
crc32: u32,
reserved: u32,
};

69
std/special/start.zig
View File

@ -4,8 +4,9 @@ const root = @import("root");
const std = @import("std");
const builtin = @import("builtin");
const assert = std.debug.assert;
const uefi = std.os.uefi;
var argc_ptr: [*]usize = undefined;
var starting_stack_ptr: [*]usize = undefined;
const is_wasm = switch (builtin.arch) {
.wasm32, .wasm64 => true,
@ -19,6 +20,8 @@ comptime {
@export("WinMainCRTStartup", WinMainCRTStartup, .Strong);
} else if (is_wasm and builtin.os == .freestanding) {
@export("_start", wasm_freestanding_start, .Strong);
} else if (builtin.os == .uefi) {
@export("EfiMain", EfiMain, .Strong);
} else {
@export("_start", _start, .Strong);
}
@ -28,6 +31,29 @@ extern fn wasm_freestanding_start() void {
_ = callMain();
}
extern fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) usize {
const bad_efi_main_ret = "expected return type of main to be 'void', 'noreturn', or 'usize'";
uefi.handle = handle;
uefi.system_table = system_table;
switch (@typeInfo(@typeOf(root.main).ReturnType)) {
.NoReturn => {
root.main();
},
.Void => {
root.main();
return 0;
},
.Int => |info| {
if (info.bits != @typeInfo(usize).Int.bits) {
@compileError(bad_efi_main_ret);
}
return root.main();
},
else => @compileError(bad_efi_main_ret),
}
}
nakedcc fn _start() noreturn {
if (builtin.os == builtin.Os.wasi) {
std.os.wasi.proc_exit(callMain());
@ -35,17 +61,17 @@ nakedcc fn _start() noreturn {
switch (builtin.arch) {
.x86_64 => {
argc_ptr = asm (""
starting_stack_ptr = asm (""
: [argc] "={rsp}" (-> [*]usize)
);
},
.i386 => {
argc_ptr = asm (""
starting_stack_ptr = asm (""
: [argc] "={esp}" (-> [*]usize)
);
},
.aarch64, .aarch64_be, .arm => {
argc_ptr = asm ("mov %[argc], sp"
starting_stack_ptr = asm ("mov %[argc], sp"
: [argc] "=r" (-> [*]usize)
);
},
@ -77,8 +103,8 @@ fn posixCallMainAndExit() noreturn {
if (builtin.os == builtin.Os.freebsd) {
@setAlignStack(16);
}
const argc = argc_ptr[0];
const argv = @ptrCast([*][*]u8, argc_ptr + 1);
const argc = starting_stack_ptr[0];
const argv = @ptrCast([*][*]u8, starting_stack_ptr + 1);
const envp_optional = @ptrCast([*]?[*]u8, argv + argc + 1);
var envp_count: usize = 0;
@ -90,21 +116,40 @@ fn posixCallMainAndExit() noreturn {
const auxv = @ptrCast([*]std.elf.Auxv, envp.ptr + envp_count + 1);
std.os.linux.elf_aux_maybe = auxv;
// Initialize the TLS area
std.os.linux.tls.initTLS();
const gnu_stack_phdr = std.os.linux.tls.initTLS() orelse @panic("ELF missing stack size");
if (std.os.linux.tls.tls_image) |tls_img| {
const tls_addr = std.os.linux.tls.allocateTLS(tls_img.alloc_size);
const tp = std.os.linux.tls.copyTLS(tls_addr);
std.os.linux.tls.setThreadPointer(tp);
}
// TODO This is disabled because what should we do when linking libc and this code
// does not execute? And also it's causing a test failure in stack traces in release modes.
//// Linux ignores the stack size from the ELF file, and instead always does 8 MiB. A further
//// problem is that it uses PROT_GROWSDOWN which prevents stores to addresses too far down
//// the stack and requires "probing". So here we allocate our own stack.
//const wanted_stack_size = gnu_stack_phdr.p_memsz;
//assert(wanted_stack_size % std.mem.page_size == 0);
//// Allocate an extra page as the guard page.
//const total_size = wanted_stack_size + std.mem.page_size;
//const new_stack = std.os.mmap(
// null,
// total_size,
// std.os.PROT_READ | std.os.PROT_WRITE,
// std.os.MAP_PRIVATE | std.os.MAP_ANONYMOUS,
// -1,
// 0,
//) catch @panic("out of memory");
//std.os.mprotect(new_stack[0..std.mem.page_size], std.os.PROT_NONE) catch {};
//std.os.exit(@newStackCall(new_stack, callMainWithArgs, argc, argv, envp));
}
std.os.exit(callMainWithArgs(argc, argv, envp));
std.os.exit(@inlineCall(callMainWithArgs, argc, argv, envp));
}
// 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.
inline fn callMainWithArgs(argc: usize, argv: [*][*]u8, envp: [][*]u8) u8 {
fn callMainWithArgs(argc: usize, argv: [*][*]u8, envp: [][*]u8) u8 {
std.os.argv = argv[0..argc];
std.os.environ = envp;
@ -117,7 +162,7 @@ extern fn main(c_argc: i32, c_argv: [*][*]u8, c_envp: [*]?[*]u8) i32 {
var env_count: usize = 0;
while (c_envp[env_count] != null) : (env_count += 1) {}
const envp = @ptrCast([*][*]u8, c_envp)[0..env_count];
return callMainWithArgs(@intCast(usize, c_argc), c_argv, envp);
return @inlineCall(callMainWithArgs, @intCast(usize, c_argc), c_argv, envp);
}
// General error message for a malformed return type

2
std/thread.zig
View File

@ -145,7 +145,7 @@ pub const Thread = struct {
if (builtin.single_threaded) @compileError("cannot spawn thread when building in single-threaded mode");
// TODO compile-time call graph analysis to determine stack upper bound
// https://github.com/ziglang/zig/issues/157
const default_stack_size = 8 * 1024 * 1024;
const default_stack_size = 16 * 1024 * 1024;
const Context = @typeOf(context);
comptime assert(@ArgType(@typeOf(startFn), 0) == Context);

11
std/zig/tokenizer.zig
View File

@ -222,9 +222,11 @@ pub const Tokenizer = struct {
},
};
} else {
// Skip the UTF-8 BOM if present
const src_start = if (mem.startsWith(u8, buffer, "\xEF\xBB\xBF")) 3 else usize(0);
return Tokenizer{
.buffer = buffer,
.index = 0,
.index = src_start,
.pending_invalid_token = null,
};
}
@ -1455,6 +1457,13 @@ test "tokenizer - line comment followed by identifier" {
});
}
test "tokenizer - UTF-8 BOM is recognized and skipped" {
testTokenize("\xEF\xBB\xBFa;\n", [_]Token.Id{
Token.Id.Identifier,
Token.Id.Semicolon,
});
}
fn testTokenize(source: []const u8, expected_tokens: []const Token.Id) void {
var tokenizer = Tokenizer.init(source);
for (expected_tokens) |expected_token_id| {

23
test/stage1/behavior/enum.zig
View File

@ -1007,3 +1007,26 @@ test "enum literal casting to error union with payload enum" {
expect((try bar) == Bar.B);
}
test "enum with one member and u1 tag type @enumToInt" {
const Enum = enum(u1) {
Test,
};
expect(@enumToInt(Enum.Test) == 0);
}
test "enum with comptime_int tag type" {
const Enum = enum(comptime_int) {
One = 3,
Two = 2,
Three = 1,
};
comptime expect(@TagType(Enum) == comptime_int);
}
test "enum with one member default to u0 tag type" {
const E0 = enum {
X,
};
comptime expect(@TagType(E0) == u0);
}

22
test/stage1/behavior/union.zig
View File

@ -324,7 +324,7 @@ test "union with only 1 field casted to its enum type" {
var e = Expr{ .Literal = Literal{ .Bool = true } };
const Tag = @TagType(Expr);
comptime expect(@TagType(Tag) == comptime_int);
comptime expect(@TagType(Tag) == u0);
var t = Tag(e);
expect(t == Expr.Literal);
}
@ -335,7 +335,7 @@ test "union with only 1 field casted to its enum type which has enum value speci
Bool: bool,
};
const Tag = enum {
const Tag = enum(comptime_int) {
Literal = 33,
};
@ -469,7 +469,7 @@ test "union no tag with struct member" {
}
fn testComparison() void {
var x = Payload{.A = 42};
var x = Payload{ .A = 42 };
expect(x == .A);
expect(x != .B);
expect(x != .C);
@ -494,3 +494,19 @@ test "packed union generates correctly aligned LLVM type" {
};
foo[0].f1();
}
test "union with one member defaults to u0 tag type" {
const U0 = union(enum) {
X: u32,
};
comptime expect(@TagType(@TagType(U0)) == u0);
}
test "union with comptime_int tag" {
const Union = union(enum(comptime_int)) {
X: u32,
Y: u16,
Z: u8,
};
comptime expect(@TagType(@TagType(Union)) == comptime_int);
}