Commit 5f3d59f0ac78e01bd50419dab54d7fcbae15f17c | zig

doc/langref.html.in+16-4

 @@ -6379,7 +6379,7 @@ comptime {
       {#header_close#}
       {#header_open|@asyncCall#}
-      <pre>{#syntax#}@asyncCall(frame_buffer: []u8, result_ptr, function_ptr, args: ...) anyframe->T{#endsyntax#}</pre>
+      <pre>{#syntax#}@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: ...) anyframe->T{#endsyntax#}</pre>
       <p>
       {#syntax#}@asyncCall{#endsyntax#} performs an {#syntax#}async{#endsyntax#} call on a function pointer,
       which may or may not be an {#link|async function|Async Functions#}.
 @@ -6405,7 +6405,7 @@ test "async fn pointer in a struct field" {
         bar: async fn (*i32) void,
     };
     var foo = Foo{ .bar = func };
-    var bytes: [64]u8 = undefined;
+    var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined;
     const f = @asyncCall(&bytes, {}, foo.bar, &data);
     assert(data == 2);
     resume f;
 @@ -7322,17 +7322,22 @@ mem.set(u8, dest, c);{#endsyntax#}</pre>
       {#header_close#}
       {#header_open|@newStackCall#}
-      <pre>{#syntax#}@newStackCall(new_stack: []u8, function: var, args: ...) var{#endsyntax#}</pre>
+      <pre>{#syntax#}@newStackCall(new_stack: []align(target_stack_align) u8, function: var, args: ...) var{#endsyntax#}</pre>
       <p>
       This calls a function, in the same way that invoking an expression with parentheses does. However,
       instead of using the same stack as the caller, the function uses the stack provided in the {#syntax#}new_stack{#endsyntax#}
       parameter.
       </p>
+      <p>
+      The new stack must be aligned to {#syntax#}target_stack_align{#endsyntax#} bytes. This is a target-specific
+      number. A safe value that will work on all targets is {#syntax#}16{#endsyntax#}. This value can
+      also be obtained by using {#link|@sizeOf#} on the {#link|@Frame#} type of {#link|Async Functions#}.
+      </p>
       {#code_begin|test#}
 const std = @import("std");
 const assert = std.debug.assert;
-var new_stack_bytes: [1024]u8 = undefined;
+var new_stack_bytes: [1024]u8 align(16) = undefined;
 test "calling a function with a new stack" {
     const arg = 1234;
 @@ -9318,6 +9323,13 @@ const c = @cImport({
         <li>Does not support Zig-only pointer attributes such as alignment. Use normal {#link|Pointers#}
         please!</li>
       </ul>
+      <p>When a C pointer is pointing to a single struct (not an array), deference the C pointer to
+        access to the struct's fields or member data. That syntax looks like
+        this: </p>
+        <p>{#syntax#}ptr_to_struct.*.struct_member{#endsyntax#}</p>
+        <p>This is comparable to doing {#syntax#}->{#endsyntax#} in C.</p>
+        <p> When a C pointer is pointing to an array of structs, the syntax reverts to this:</p>
+        <p>{#syntax#}ptr_to_struct_array[index].struct_member{#endsyntax#}</p>
       {#header_close#}
       {#header_open|Exporting a C Library#}

src/all_types.hpp+7

 @@ -1279,6 +1279,12 @@ struct ZigTypeOpaque {
 struct ZigTypeFnFrame {
     ZigFn *fn;
     ZigType *locals_struct;
+    // This is set to the type that resolving the frame currently depends on, null if none.
+    // It's for generating a helpful error message.
+    ZigType *resolve_loop_type;
+    AstNode *resolve_loop_src_node;
+    bool reported_loop_err;
 };
 struct ZigTypeAnyFrame {
 @@ -1396,6 +1402,7 @@ struct ZigFn {
     AstNode *set_cold_node;
     const AstNode *inferred_async_node;
     ZigFn *inferred_async_fn;
+    AstNode *non_async_node;
     ZigList<GlobalExport> export_list;
     ZigList<IrInstructionCallGen *> call_list;

src/analyze.cpp+52-4

...	@@ -4144,8 +4144,15 @@ void semantic_analyze(CodeGen *g) {	...	@@ -4144,8 +4144,15 @@ void semantic_analyze(CodeGen *g) {
4144		4144
4145	// second pass over functions for detecting async	4145	// second pass over functions for detecting async
4146	for (g->fn_defs_index = 0; g->fn_defs_index < g->fn_defs.length; g->fn_defs_index += 1) {	4146	for (g->fn_defs_index = 0; g->fn_defs_index < g->fn_defs.length; g->fn_defs_index += 1) {
4147	ZigFn *fn_entry = g->fn_defs.at(g->fn_defs_index);	4147	ZigFn *fn = g->fn_defs.at(g->fn_defs_index);
4148	analyze_fn_async(g, fn_entry, true);	4148	analyze_fn_async(g, fn, true);
		4149	if (fn_is_async(fn) && fn->non_async_node != nullptr) {
		4150	ErrorMsg *msg = add_node_error(g, fn->proto_node,
		4151	buf_sprintf("'%s' cannot be async", buf_ptr(&fn->symbol_name)));
		4152	add_error_note(g, msg, fn->non_async_node,
		4153	buf_sprintf("required to be non-async here"));
		4154	add_async_error_notes(g, msg, fn);
		4155	}
4149	}	4156	}
4150	}	4157	}
4151		4158
...	@@ -5190,6 +5197,27 @@ static ZigType get_async_fn_type(CodeGen g, ZigType *orig_fn_type) {	...	@@ -5190,6 +5197,27 @@ static ZigType get_async_fn_type(CodeGen g, ZigType *orig_fn_type) {
5190	return fn_type;	5197	return fn_type;
5191	}	5198	}
5192		5199
		5200	static void emit_error_notes_for_type_loop(CodeGen g, ErrorMsg msg, ZigType *stop_type,
		5201	ZigType ty, AstNode src_node)
		5202	{
		5203	ErrorMsg *note = add_error_note(g, msg, src_node,
		5204	buf_sprintf("when analyzing type '%s' here", buf_ptr(&ty->name)));
		5205	if (ty == stop_type)
		5206	return;
		5207	switch (ty->id) {
		5208	case ZigTypeIdFnFrame: {
		5209	ty->data.frame.reported_loop_err = true;
		5210	ZigType *depending_type = ty->data.frame.resolve_loop_type;
		5211	if (depending_type == nullptr)
		5212	return;
		5213	emit_error_notes_for_type_loop(g, note, stop_type,
		5214	depending_type, ty->data.frame.resolve_loop_src_node);
		5215	}
		5216	default:
		5217	return;
		5218	}
		5219	}
		5220
5193	static Error resolve_async_frame(CodeGen g, ZigType frame_type) {	5221	static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
5194	Error err;	5222	Error err;
5195		5223
...	@@ -5199,6 +5227,20 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {	...	@@ -5199,6 +5227,20 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
5199	ZigFn *fn = frame_type->data.frame.fn;	5227	ZigFn *fn = frame_type->data.frame.fn;
5200	assert(!fn->type_entry->data.fn.is_generic);	5228	assert(!fn->type_entry->data.fn.is_generic);
5201		5229
		5230	if (frame_type->data.frame.resolve_loop_type != nullptr) {
		5231	if (!frame_type->data.frame.reported_loop_err) {
		5232	frame_type->data.frame.reported_loop_err = true;
		5233	ErrorMsg *msg = add_node_error(g, fn->proto_node,
		5234	buf_sprintf("'%s' depends on itself", buf_ptr(&frame_type->name)));
		5235	emit_error_notes_for_type_loop(g, msg,
		5236	frame_type,
		5237	frame_type->data.frame.resolve_loop_type,
		5238	frame_type->data.frame.resolve_loop_src_node);
		5239	emit_error_notes_for_ref_stack(g, msg);
		5240	}
		5241	return ErrorSemanticAnalyzeFail;
		5242	}
		5243
5202	switch (fn->anal_state) {	5244	switch (fn->anal_state) {
5203	case FnAnalStateInvalid:	5245	case FnAnalStateInvalid:
5204	return ErrorSemanticAnalyzeFail;	5246	return ErrorSemanticAnalyzeFail;
...	@@ -5292,6 +5334,10 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {	...	@@ -5292,6 +5334,10 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
5292	return ErrorSemanticAnalyzeFail;	5334	return ErrorSemanticAnalyzeFail;
5293	}	5335	}
5294		5336
		5337	ZigType *callee_frame_type = get_fn_frame_type(g, callee);
		5338	frame_type->data.frame.resolve_loop_type = callee_frame_type;
		5339	frame_type->data.frame.resolve_loop_src_node = call->base.source_node;
		5340
5295	analyze_fn_body(g, callee);	5341	analyze_fn_body(g, callee);
5296	if (callee->anal_state == FnAnalStateInvalid) {	5342	if (callee->anal_state == FnAnalStateInvalid) {
5297	frame_type->data.frame.locals_struct = g->builtin_types.entry_invalid;	5343	frame_type->data.frame.locals_struct = g->builtin_types.entry_invalid;
...	@@ -5301,8 +5347,6 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {	...	@@ -5301,8 +5347,6 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
5301	if (!fn_is_async(callee))	5347	if (!fn_is_async(callee))
5302	continue;	5348	continue;
5303		5349
5304	ZigType *callee_frame_type = get_fn_frame_type(g, callee);
5305
5306	IrInstructionAllocaGen *alloca_gen = allocate<IrInstructionAllocaGen>(1);	5350	IrInstructionAllocaGen *alloca_gen = allocate<IrInstructionAllocaGen>(1);
5307	alloca_gen->base.id = IrInstructionIdAllocaGen;	5351	alloca_gen->base.id = IrInstructionIdAllocaGen;
5308	alloca_gen->base.source_node = call->base.source_node;	5352	alloca_gen->base.source_node = call->base.source_node;
...	@@ -5371,9 +5415,13 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {	...	@@ -5371,9 +5415,13 @@ static Error resolve_async_frame(CodeGen g, ZigType frame_type) {
5371	continue;	5415	continue;
5372	}	5416	}
5373	}	5417	}
		5418
		5419	frame_type->data.frame.resolve_loop_type = child_type;
		5420	frame_type->data.frame.resolve_loop_src_node = instruction->base.source_node;
5374	if ((err = type_resolve(g, child_type, ResolveStatusSizeKnown))) {	5421	if ((err = type_resolve(g, child_type, ResolveStatusSizeKnown))) {
5375	return err;	5422	return err;
5376	}	5423	}
		5424
5377	const char *name;	5425	const char *name;
5378	if (*instruction->name_hint == 0) {	5426	if (*instruction->name_hint == 0) {
5379	name = buf_ptr(buf_sprintf("@local%" ZIG_PRI_usize, alloca_i));	5427	name = buf_ptr(buf_sprintf("@local%" ZIG_PRI_usize, alloca_i));

src/ir.cpp+128-13

...	@@ -6743,6 +6743,25 @@ static Error parse_asm_template(IrBuilder irb, AstNode source_node, Buf *asm_t	...	@@ -6743,6 +6743,25 @@ static Error parse_asm_template(IrBuilder irb, AstNode source_node, Buf *asm_t
6743	return ErrorNone;	6743	return ErrorNone;
6744	}	6744	}
6745		6745
		6746	static size_t find_asm_index(CodeGen g, AstNode node, AsmToken tok, Buf src_template) {
		6747	const char *ptr = buf_ptr(src_template) + tok->start + 2;
		6748	size_t len = tok->end - tok->start - 2;
		6749	size_t result = 0;
		6750	for (size_t i = 0; i < node->data.asm_expr.output_list.length; i += 1, result += 1) {
		6751	AsmOutput *asm_output = node->data.asm_expr.output_list.at(i);
		6752	if (buf_eql_mem(asm_output->asm_symbolic_name, ptr, len)) {
		6753	return result;
		6754	}
		6755	}
		6756	for (size_t i = 0; i < node->data.asm_expr.input_list.length; i += 1, result += 1) {
		6757	AsmInput *asm_input = node->data.asm_expr.input_list.at(i);
		6758	if (buf_eql_mem(asm_input->asm_symbolic_name, ptr, len)) {
		6759	return result;
		6760	}
		6761	}
		6762	return SIZE_MAX;
		6763	}
		6764
6746	static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode node) {	6765	static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode node) {
6747	Error err;	6766	Error err;
6748	assert(node->type == NodeTypeAsmExpr);	6767	assert(node->type == NodeTypeAsmExpr);
...	@@ -6830,6 +6849,22 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode nod	...	@@ -6830,6 +6849,22 @@ static IrInstruction ir_gen_asm_expr(IrBuilder irb, Scope scope, AstNode nod
6830	input_list[i] = input_value;	6849	input_list[i] = input_value;
6831	}	6850	}
6832		6851
		6852	for (size_t token_i = 0; token_i < tok_list.length; token_i += 1) {
		6853	AsmToken asm_token = tok_list.at(token_i);
		6854	if (asm_token.id == AsmTokenIdVar) {
		6855	size_t index = find_asm_index(irb->codegen, node, &asm_token, template_buf);
		6856	if (index == SIZE_MAX) {
		6857	const char *ptr = buf_ptr(template_buf) + asm_token.start + 2;
		6858	uint32_t len = asm_token.end - asm_token.start - 2;
		6859
		6860	add_node_error(irb->codegen, node,
		6861	buf_sprintf("could not find '%.*s' in the inputs or outputs.",
		6862	len, ptr));
		6863	return irb->codegen->invalid_instruction;
		6864	}
		6865	}
		6866	}
		6867
6833	return ir_build_asm(irb, scope, node, template_buf, tok_list.items, tok_list.length,	6868	return ir_build_asm(irb, scope, node, template_buf, tok_list.items, tok_list.length,
6834	input_list, output_types, output_vars, return_count, is_volatile);	6869	input_list, output_types, output_vars, return_count, is_volatile);
6835	}	6870	}
...	@@ -9485,10 +9520,6 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted	...	@@ -9485,10 +9520,6 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
9485	result.id = ConstCastResultIdFnAlign;	9520	result.id = ConstCastResultIdFnAlign;
9486	return result;	9521	return result;
9487	}	9522	}
9488	if (wanted_type->data.fn.fn_type_id.cc != actual_type->data.fn.fn_type_id.cc) {
9489	result.id = ConstCastResultIdFnCC;
9490	return result;
9491	}
9492	if (wanted_type->data.fn.fn_type_id.is_var_args != actual_type->data.fn.fn_type_id.is_var_args) {	9523	if (wanted_type->data.fn.fn_type_id.is_var_args != actual_type->data.fn.fn_type_id.is_var_args) {
9493	result.id = ConstCastResultIdFnVarArgs;	9524	result.id = ConstCastResultIdFnVarArgs;
9494	return result;	9525	return result;
...	@@ -9546,6 +9577,11 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted	...	@@ -9546,6 +9577,11 @@ static ConstCastOnly types_match_const_cast_only(IrAnalyze ira, ZigType wanted
9546	return result;	9577	return result;
9547	}	9578	}
9548	}	9579	}
		9580	if (wanted_type->data.fn.fn_type_id.cc != actual_type->data.fn.fn_type_id.cc) {
		9581	// ConstCastResultIdFnCC is guaranteed to be the last one reported, meaning everything else is ok.
		9582	result.id = ConstCastResultIdFnCC;
		9583	return result;
		9584	}
9549	return result;	9585	return result;
9550	}	9586	}
9551		9587
...	@@ -11780,8 +11816,11 @@ static void report_recursive_error(IrAnalyze ira, AstNode source_node, ConstCa	...	@@ -11780,8 +11816,11 @@ static void report_recursive_error(IrAnalyze ira, AstNode source_node, ConstCa
11780	add_error_note(ira->codegen, parent_msg, source_node,	11816	add_error_note(ira->codegen, parent_msg, source_node,
11781	buf_sprintf("only one of the functions is generic"));	11817	buf_sprintf("only one of the functions is generic"));
11782	break;	11818	break;
		11819	case ConstCastResultIdFnCC:
		11820	add_error_note(ira->codegen, parent_msg, source_node,
		11821	buf_sprintf("calling convention mismatch"));
		11822	break;
11783	case ConstCastResultIdFnAlign: // TODO	11823	case ConstCastResultIdFnAlign: // TODO
11784	case ConstCastResultIdFnCC: // TODO
11785	case ConstCastResultIdFnVarArgs: // TODO	11824	case ConstCastResultIdFnVarArgs: // TODO
11786	case ConstCastResultIdFnReturnType: // TODO	11825	case ConstCastResultIdFnReturnType: // TODO
11787	case ConstCastResultIdFnArgCount: // TODO	11826	case ConstCastResultIdFnArgCount: // TODO
...	@@ -11891,6 +11930,21 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -11891,6 +11930,21 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
11891	return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop);	11930	return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop);
11892	}	11931	}
11893		11932
		11933	if (const_cast_result.id == ConstCastResultIdFnCC) {
		11934	ir_assert(value->value.type->id == ZigTypeIdFn, source_instr);
		11935	// ConstCastResultIdFnCC is guaranteed to be the last one reported, meaning everything else is ok.
		11936	if (wanted_type->data.fn.fn_type_id.cc == CallingConventionAsync &&
		11937	actual_type->data.fn.fn_type_id.cc == CallingConventionUnspecified)
		11938	{
		11939	ir_assert(value->value.data.x_ptr.special == ConstPtrSpecialFunction, source_instr);
		11940	ZigFn *fn = value->value.data.x_ptr.data.fn.fn_entry;
		11941	if (fn->inferred_async_node == nullptr) {
		11942	fn->inferred_async_node = source_instr->source_node;
		11943	}
		11944	return ir_resolve_cast(ira, source_instr, value, wanted_type, CastOpNoop);
		11945	}
		11946	}
		11947
11894	// cast from T to ?T	11948	// cast from T to ?T
11895	// note that the T to ?T case is handled via the "ConstCastOnly" mechanism	11949	// note that the T to ?T case is handled via the "ConstCastOnly" mechanism
11896	if (wanted_type->id == ZigTypeIdOptional) {	11950	if (wanted_type->id == ZigTypeIdOptional) {
...	@@ -12110,7 +12164,26 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst	...	@@ -12110,7 +12164,26 @@ static IrInstruction ir_analyze_cast(IrAnalyze ira, IrInstruction *source_inst
12110	array_type->data.array.child_type, source_node,	12164	array_type->data.array.child_type, source_node,
12111	!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)	12165	!slice_ptr_type->data.pointer.is_const).id == ConstCastResultIdOk)
12112	{	12166	{
12113	return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, wanted_type, result_loc);	12167	// If the pointers both have ABI align, it works.
		12168	bool ok_align = slice_ptr_type->data.pointer.explicit_alignment == 0 &&
		12169	actual_type->data.pointer.explicit_alignment == 0;
		12170	if (!ok_align) {
		12171	// If either one has non ABI align, we have to resolve them both
		12172	if ((err = type_resolve(ira->codegen, actual_type->data.pointer.child_type,
		12173	ResolveStatusAlignmentKnown)))
		12174	{
		12175	return ira->codegen->invalid_instruction;
		12176	}
		12177	if ((err = type_resolve(ira->codegen, slice_ptr_type->data.pointer.child_type,
		12178	ResolveStatusAlignmentKnown)))
		12179	{
		12180	return ira->codegen->invalid_instruction;
		12181	}
		12182	ok_align = get_ptr_align(ira->codegen, actual_type) >= get_ptr_align(ira->codegen, slice_ptr_type);
		12183	}
		12184	if (ok_align) {
		12185	return ir_resolve_ptr_of_array_to_slice(ira, source_instr, value, wanted_type, result_loc);
		12186	}
12114	}	12187	}
12115	}	12188	}
12116		12189
...	@@ -13902,8 +13975,7 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *	...	@@ -13902,8 +13975,7 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *
13902	uint64_t old_array_len = array_type->data.array.len;	13975	uint64_t old_array_len = array_type->data.array.len;
13903	uint64_t new_array_len;	13976	uint64_t new_array_len;
13904		13977
13905	if (mul_u64_overflow(old_array_len, mult_amt, &new_array_len))	13978	if (mul_u64_overflow(old_array_len, mult_amt, &new_array_len)) {
13906	{
13907	ir_add_error(ira, &instruction->base, buf_sprintf("operation results in overflow"));	13979	ir_add_error(ira, &instruction->base, buf_sprintf("operation results in overflow"));
13908	return ira->codegen->invalid_instruction;	13980	return ira->codegen->invalid_instruction;
13909	}	13981	}
...	@@ -13918,6 +13990,15 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *	...	@@ -13918,6 +13990,15 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *
13918	return result;	13990	return result;
13919	}	13991	}
13920		13992
		13993	switch (type_has_one_possible_value(ira->codegen, result->value.type)) {
		13994	case OnePossibleValueInvalid:
		13995	return ira->codegen->invalid_instruction;
		13996	case OnePossibleValueYes:
		13997	return result;
		13998	case OnePossibleValueNo:
		13999	break;
		14000	}
		14001
13921	// TODO optimize the buf case	14002	// TODO optimize the buf case
13922	expand_undef_array(ira->codegen, array_val);	14003	expand_undef_array(ira->codegen, array_val);
13923	out_val->data.x_array.data.s_none.elements = create_const_vals(new_array_len);	14004	out_val->data.x_array.data.s_none.elements = create_const_vals(new_array_len);
...	@@ -13925,8 +14006,11 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *	...	@@ -13925,8 +14006,11 @@ static IrInstruction ir_analyze_array_mult(IrAnalyze ira, IrInstructionBinOp *
13925	uint64_t i = 0;	14006	uint64_t i = 0;
13926	for (uint64_t x = 0; x < mult_amt; x += 1) {	14007	for (uint64_t x = 0; x < mult_amt; x += 1) {
13927	for (uint64_t y = 0; y < old_array_len; y += 1) {	14008	for (uint64_t y = 0; y < old_array_len; y += 1) {
13928	copy_const_val(&out_val->data.x_array.data.s_none.elements[i],	14009	ConstExprValue *elem_dest_val = &out_val->data.x_array.data.s_none.elements[i];
13929	&array_val->data.x_array.data.s_none.elements[y], false);	14010	copy_const_val(elem_dest_val, &array_val->data.x_array.data.s_none.elements[y], false);
		14011	elem_dest_val->parent.id = ConstParentIdArray;
		14012	elem_dest_val->parent.data.p_array.array_val = out_val;
		14013	elem_dest_val->parent.data.p_array.elem_index = i;
13930	i += 1;	14014	i += 1;
13931	}	14015	}
13932	}	14016	}
...	@@ -14753,6 +14837,9 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe	...	@@ -14753,6 +14837,9 @@ static IrInstruction ir_resolve_result_raw(IrAnalyze ira, IrInstruction *suspe
14753	return ira->codegen->invalid_instruction;	14837	return ira->codegen->invalid_instruction;
14754	}	14838	}
14755	uint64_t parent_ptr_align = get_ptr_align(ira->codegen, parent_ptr_type);	14839	uint64_t parent_ptr_align = get_ptr_align(ira->codegen, parent_ptr_type);
		14840	if ((err = type_resolve(ira->codegen, value_type, ResolveStatusAlignmentKnown))) {
		14841	return ira->codegen->invalid_instruction;
		14842	}
14756	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, value_type,	14843	ZigType *ptr_type = get_pointer_to_type_extra(ira->codegen, value_type,
14757	parent_ptr_type->data.pointer.is_const, parent_ptr_type->data.pointer.is_volatile, PtrLenSingle,	14844	parent_ptr_type->data.pointer.is_const, parent_ptr_type->data.pointer.is_volatile, PtrLenSingle,
14758	parent_ptr_align, 0, 0, parent_ptr_type->data.pointer.allow_zero);	14845	parent_ptr_align, 0, 0, parent_ptr_type->data.pointer.allow_zero);
...	@@ -15141,6 +15228,20 @@ no_mem_slot:	...	@@ -15141,6 +15228,20 @@ no_mem_slot:
15141	return var_ptr_instruction;	15228	return var_ptr_instruction;
15142	}	15229	}
15143		15230
		15231	// This function is called when a comptime value becomes accessible at runtime.
		15232	static void mark_comptime_value_escape(IrAnalyze ira, IrInstruction source_instr, ConstExprValue *val) {
		15233	ir_assert(value_is_comptime(val), source_instr);
		15234	if (val->special == ConstValSpecialUndef)
		15235	return;
		15236
		15237	if (val->type->id == ZigTypeIdFn && val->type->data.fn.fn_type_id.cc == CallingConventionUnspecified) {
		15238	ir_assert(val->data.x_ptr.special == ConstPtrSpecialFunction, source_instr);
		15239	if (val->data.x_ptr.data.fn.fn_entry->non_async_node == nullptr) {
		15240	val->data.x_ptr.data.fn.fn_entry->non_async_node = source_instr->source_node;
		15241	}
		15242	}
		15243	}
		15244
15144	static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source_instr,	15245	static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source_instr,
15145	IrInstruction ptr, IrInstruction uncasted_value, bool allow_write_through_const)	15246	IrInstruction ptr, IrInstruction uncasted_value, bool allow_write_through_const)
15146	{	15247	{
...	@@ -15237,6 +15338,10 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source	...	@@ -15237,6 +15338,10 @@ static IrInstruction ir_analyze_store_ptr(IrAnalyze ira, IrInstruction *source
15237	break;	15338	break;
15238	}	15339	}
15239		15340
		15341	if (instr_is_comptime(value)) {
		15342	mark_comptime_value_escape(ira, source_instr, &value->value);
		15343	}
		15344
15240	IrInstructionStorePtr *store_ptr = ir_build_store_ptr(&ira->new_irb, source_instr->scope,	15345	IrInstructionStorePtr *store_ptr = ir_build_store_ptr(&ira->new_irb, source_instr->scope,
15241	source_instr->source_node, ptr, value);	15346	source_instr->source_node, ptr, value);
15242	return &store_ptr->base;	15347	return &store_ptr->base;
...	@@ -15421,7 +15526,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstructionCallSrc *c	...	@@ -15421,7 +15526,7 @@ static IrInstruction ir_analyze_fn_call(IrAnalyze ira, IrInstructionCallSrc *c
15421	IrInstruction *casted_new_stack = nullptr;	15526	IrInstruction *casted_new_stack = nullptr;
15422	if (call_instruction->new_stack != nullptr) {	15527	if (call_instruction->new_stack != nullptr) {
15423	ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,	15528	ZigType *u8_ptr = get_pointer_to_type_extra(ira->codegen, ira->codegen->builtin_types.entry_u8,
15424	false, false, PtrLenUnknown, 0, 0, 0, false);	15529	false, false, PtrLenUnknown, target_fn_align(ira->codegen->zig_target), 0, 0, false);
15425	ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);	15530	ZigType *u8_slice = get_slice_type(ira->codegen, u8_ptr);
15426	IrInstruction *new_stack = call_instruction->new_stack->child;	15531	IrInstruction *new_stack = call_instruction->new_stack->child;
15427	if (type_is_invalid(new_stack->value.type))	15532	if (type_is_invalid(new_stack->value.type))
...	@@ -17123,7 +17228,7 @@ static void add_link_lib_symbol(IrAnalyze ira, Buf lib_name, Buf *symbol_name,	...	@@ -17123,7 +17228,7 @@ static void add_link_lib_symbol(IrAnalyze ira, Buf lib_name, Buf *symbol_name,
17123	buf_sprintf("dependency on dynamic library '%s' requires enabling Position Independent Code",	17228	buf_sprintf("dependency on dynamic library '%s' requires enabling Position Independent Code",
17124	buf_ptr(lib_name)));	17229	buf_ptr(lib_name)));
17125	add_error_note(ira->codegen, msg, source_node,	17230	add_error_note(ira->codegen, msg, source_node,
17126	buf_sprintf("fixed by `--library %s` or `--enable-pic`", buf_ptr(lib_name)));	17231	buf_sprintf("fixed by `--library %s` or `-fPIC`", buf_ptr(lib_name)));
17127	ira->codegen->reported_bad_link_libc_error = true;	17232	ira->codegen->reported_bad_link_libc_error = true;
17128	}	17233	}
17129		17234
...	@@ -20841,6 +20946,12 @@ static IrInstruction ir_analyze_instruction_fence(IrAnalyze ira, IrInstruction	...	@@ -20841,6 +20946,12 @@ static IrInstruction ir_analyze_instruction_fence(IrAnalyze ira, IrInstruction
20841	if (!ir_resolve_atomic_order(ira, order_value, &order))	20946	if (!ir_resolve_atomic_order(ira, order_value, &order))
20842	return ira->codegen->invalid_instruction;	20947	return ira->codegen->invalid_instruction;
20843		20948
		20949	if (order < AtomicOrderAcquire) {
		20950	ir_add_error(ira, order_value,
		20951	buf_sprintf("atomic ordering must be Acquire or stricter"));
		20952	return ira->codegen->invalid_instruction;
		20953	}
		20954
20844	IrInstruction *result = ir_build_fence(&ira->new_irb,	20955	IrInstruction *result = ir_build_fence(&ira->new_irb,
20845	instruction->base.scope, instruction->base.source_node, order_value, order);	20956	instruction->base.scope, instruction->base.source_node, order_value, order);
20846	result->value.type = ira->codegen->builtin_types.entry_void;	20957	result->value.type = ira->codegen->builtin_types.entry_void;
...	@@ -24491,7 +24602,11 @@ static IrInstruction ir_analyze_instruction_bit_cast_src(IrAnalyze ira, IrInst	...	@@ -24491,7 +24602,11 @@ static IrInstruction ir_analyze_instruction_bit_cast_src(IrAnalyze ira, IrInst
24491	if (result_loc != nullptr && (type_is_invalid(result_loc->value.type) \|\| instr_is_unreachable(result_loc)))	24602	if (result_loc != nullptr && (type_is_invalid(result_loc->value.type) \|\| instr_is_unreachable(result_loc)))
24492	return result_loc;	24603	return result_loc;
24493		24604
24494	return instruction->result_loc_bit_cast->parent->gen_instruction;	24605	if (instruction->result_loc_bit_cast->parent->gen_instruction != nullptr) {
		24606	return instruction->result_loc_bit_cast->parent->gen_instruction;
		24607	}
		24608
		24609	return result_loc;
24495	}	24610	}
24496		24611
24497	static IrInstruction ir_analyze_instruction_union_init_named_field(IrAnalyze ira,	24612	static IrInstruction ir_analyze_instruction_union_init_named_field(IrAnalyze ira,

src/link.cpp+1-1

...	@@ -1755,7 +1755,7 @@ static void construct_linker_job_elf(LinkJob *lj) {	...	@@ -1755,7 +1755,7 @@ static void construct_linker_job_elf(LinkJob *lj) {
1755		1755
1756		1756
1757	// libc dep	1757	// libc dep
1758	if (g->libc_link_lib != nullptr) {	1758	if (g->libc_link_lib != nullptr && g->out_type != OutTypeObj) {
1759	if (g->libc != nullptr) {	1759	if (g->libc != nullptr) {
1760	if (!g->have_dynamic_link) {	1760	if (!g->have_dynamic_link) {
1761	lj->args.append("--start-group");	1761	lj->args.append("--start-group");

std/c.zig+3-1

std/c/freebsd.zig+1-1

...	@@ -6,4 +6,4 @@ pub const _errno = __error;	...	@@ -6,4 +6,4 @@ pub const _errno = __error;
6		6
7	pub extern "c" fn getdents(fd: c_int, buf_ptr: [*]u8, nbytes: usize) usize;	7	pub extern "c" fn getdents(fd: c_int, buf_ptr: [*]u8, nbytes: usize) usize;
8	pub extern "c" fn sigaltstack(ss: ?stack_t, old_ss: ?stack_t) c_int;	8	pub extern "c" fn sigaltstack(ss: ?stack_t, old_ss: ?stack_t) c_int;
9	pub extern "c" fn getrandom(buf_ptr: [*]u8, buf_len: usize, flags: c_uint) c_int;	9	pub extern "c" fn getrandom(buf_ptr: [*]u8, buf_len: usize, flags: c_uint) isize;

std/c/linux.zig+1-1

...	@@ -7,7 +7,7 @@ pub const _errno = __errno_location;	...	@@ -7,7 +7,7 @@ pub const _errno = __errno_location;
7		7
8	pub const MAP_FAILED = @intToPtr(*c_void, maxInt(usize));	8	pub const MAP_FAILED = @intToPtr(*c_void, maxInt(usize));
9		9
10	pub extern "c" fn getrandom(buf_ptr: [*]u8, buf_len: usize, flags: c_uint) c_int;	10	pub extern "c" fn getrandom(buf_ptr: [*]u8, buf_len: usize, flags: c_uint) isize;
11	pub extern "c" fn sched_getaffinity(pid: c_int, size: usize, set: *cpu_set_t) c_int;	11	pub extern "c" fn sched_getaffinity(pid: c_int, size: usize, set: *cpu_set_t) c_int;
12	pub extern "c" fn eventfd(initval: c_uint, flags: c_uint) c_int;	12	pub extern "c" fn eventfd(initval: c_uint, flags: c_uint) c_int;
13	pub extern "c" fn epoll_ctl(epfd: fd_t, op: c_uint, fd: fd_t, event: ?*epoll_event) c_int;	13	pub extern "c" fn epoll_ctl(epfd: fd_t, op: c_uint, fd: fd_t, event: ?*epoll_event) c_int;

std/event/fs.zig+89-46

 @@ -23,6 +23,7 @@ pub const Request = struct {
     };
     pub const Msg = union(enum) {
+        WriteV: WriteV,
         PWriteV: PWriteV,
         PReadV: PReadV,
         Open: Open,
 @@ -30,6 +31,14 @@ pub const Request = struct {
         WriteFile: WriteFile,
         End, // special - means the fs thread should exit
+        pub const WriteV = struct {
+            fd: fd_t,
+            iov: []const os.iovec_const,
+            result: Error!void,
+            pub const Error = os.WriteError;
+        };
         pub const PWriteV = struct {
             fd: fd_t,
             iov: []const os.iovec_const,
 @@ -77,7 +86,7 @@ pub const Request = struct {
 pub const PWriteVError = error{OutOfMemory} || File.WriteError;
 /// data - just the inner references - must live until pwritev frame completes.
-pub async fn pwritev(loop: *Loop, fd: fd_t, data: []const []const u8, offset: usize) PWriteVError!void {
+pub fn pwritev(loop: *Loop, fd: fd_t, data: []const []const u8, offset: usize) PWriteVError!void {
     switch (builtin.os) {
         .macosx,
         .linux,
 @@ -94,31 +103,31 @@ pub async fn pwritev(loop: *Loop, fd: fd_t, data: []const []const u8, offset: us
                 };
             }
-            return await (async pwritevPosix(loop, fd, iovecs, offset) catch unreachable);
+            return pwritevPosix(loop, fd, iovecs, offset);
         },
         .windows => {
             const data_copy = try std.mem.dupe(loop.allocator, []const u8, data);
             defer loop.allocator.free(data_copy);
-            return await (async pwritevWindows(loop, fd, data, offset) catch unreachable);
+            return pwritevWindows(loop, fd, data, offset);
         },
         else => @compileError("Unsupported OS"),
     }
 }
 /// data must outlive the returned frame
-pub async fn pwritevWindows(loop: *Loop, fd: fd_t, data: []const []const u8, offset: usize) os.WindowsWriteError!void {
+pub fn pwritevWindows(loop: *Loop, fd: fd_t, data: []const []const u8, offset: usize) os.WindowsWriteError!void {
     if (data.len == 0) return;
-    if (data.len == 1) return await (async pwriteWindows(loop, fd, data[0], offset) catch unreachable);
+    if (data.len == 1) return pwriteWindows(loop, fd, data[0], offset);
     // TODO do these in parallel
     var off = offset;
     for (data) |buf| {
-        try await (async pwriteWindows(loop, fd, buf, off) catch unreachable);
+        try pwriteWindows(loop, fd, buf, off);
         off += buf.len;
     }
 }
-pub async fn pwriteWindows(loop: *Loop, fd: fd_t, data: []const u8, offset: u64) os.WindowsWriteError!void {
+pub fn pwriteWindows(loop: *Loop, fd: fd_t, data: []const u8, offset: u64) os.WindowsWriteError!void {
     var resume_node = Loop.ResumeNode.Basic{
         .base = Loop.ResumeNode{
             .id = Loop.ResumeNode.Id.Basic,
 @@ -158,7 +167,7 @@ pub async fn pwriteWindows(loop: *Loop, fd: fd_t, data: []const u8, offset: u64)
 }
 /// iovecs must live until pwritev frame completes.
-pub async fn pwritevPosix(
+pub fn pwritevPosix(
     loop: *Loop,
     fd: fd_t,
     iovecs: []const os.iovec_const,
 @@ -195,10 +204,44 @@ pub async fn pwritevPosix(
     return req_node.data.msg.PWriteV.result;
 }
+/// iovecs must live until pwritev frame completes.
+pub fn writevPosix(
+    loop: *Loop,
+    fd: fd_t,
+    iovecs: []const os.iovec_const,
+) os.WriteError!void {
+    var req_node = RequestNode{
+        .prev = null,
+        .next = null,
+        .data = Request{
+            .msg = Request.Msg{
+                .WriteV = Request.Msg.WriteV{
+                    .fd = fd,
+                    .iov = iovecs,
+                    .result = undefined,
+                },
+            },
+            .finish = Request.Finish{
+                .TickNode = Loop.NextTickNode{
+                    .prev = null,
+                    .next = null,
+                    .data = @frame(),
+                },
+            },
+        },
+    };
+    suspend {
+        loop.posixFsRequest(&req_node);
+    }
+    return req_node.data.msg.WriteV.result;
+}
 pub const PReadVError = error{OutOfMemory} || File.ReadError;
 /// data - just the inner references - must live until preadv frame completes.
-pub async fn preadv(loop: *Loop, fd: fd_t, data: []const []u8, offset: usize) PReadVError!usize {
+pub fn preadv(loop: *Loop, fd: fd_t, data: []const []u8, offset: usize) PReadVError!usize {
     assert(data.len != 0);
     switch (builtin.os) {
         .macosx,
 @@ -216,21 +259,21 @@ pub async fn preadv(loop: *Loop, fd: fd_t, data: []const []u8, offset: usize) PR
                 };
             }
-            return await (async preadvPosix(loop, fd, iovecs, offset) catch unreachable);
+            return preadvPosix(loop, fd, iovecs, offset);
         },
         .windows => {
             const data_copy = try std.mem.dupe(loop.allocator, []u8, data);
             defer loop.allocator.free(data_copy);
-            return await (async preadvWindows(loop, fd, data_copy, offset) catch unreachable);
+            return preadvWindows(loop, fd, data_copy, offset);
         },
         else => @compileError("Unsupported OS"),
     }
 }
 /// data must outlive the returned frame
-pub async fn preadvWindows(loop: *Loop, fd: fd_t, data: []const []u8, offset: u64) !usize {
+pub fn preadvWindows(loop: *Loop, fd: fd_t, data: []const []u8, offset: u64) !usize {
     assert(data.len != 0);
-    if (data.len == 1) return await (async preadWindows(loop, fd, data[0], offset) catch unreachable);
+    if (data.len == 1) return preadWindows(loop, fd, data[0], offset);
     // TODO do these in parallel?
     var off: usize = 0;
 @@ -238,7 +281,7 @@ pub async fn preadvWindows(loop: *Loop, fd: fd_t, data: []const []u8, offset: u6
     var inner_off: usize = 0;
     while (true) {
         const v = data[iov_i];
-        const amt_read = try await (async preadWindows(loop, fd, v[inner_off .. v.len - inner_off], offset + off) catch unreachable);
+        const amt_read = try preadWindows(loop, fd, v[inner_off .. v.len - inner_off], offset + off);
         off += amt_read;
         inner_off += amt_read;
         if (inner_off == v.len) {
 @@ -252,7 +295,7 @@ pub async fn preadvWindows(loop: *Loop, fd: fd_t, data: []const []u8, offset: u6
     }
 }
-pub async fn preadWindows(loop: *Loop, fd: fd_t, data: []u8, offset: u64) !usize {
+pub fn preadWindows(loop: *Loop, fd: fd_t, data: []u8, offset: u64) !usize {
     var resume_node = Loop.ResumeNode.Basic{
         .base = Loop.ResumeNode{
             .id = Loop.ResumeNode.Id.Basic,
 @@ -291,7 +334,7 @@ pub async fn preadWindows(loop: *Loop, fd: fd_t, data: []u8, offset: u64) !usize
 }
 /// iovecs must live until preadv frame completes
-pub async fn preadvPosix(
+pub fn preadvPosix(
     loop: *Loop,
     fd: fd_t,
     iovecs: []const os.iovec,
 @@ -328,7 +371,7 @@ pub async fn preadvPosix(
     return req_node.data.msg.PReadV.result;
 }
-pub async fn openPosix(
+pub fn openPosix(
     loop: *Loop,
     path: []const u8,
     flags: u32,
 @@ -367,11 +410,11 @@ pub async fn openPosix(
     return req_node.data.msg.Open.result;
 }
-pub async fn openRead(loop: *Loop, path: []const u8) File.OpenError!fd_t {
+pub fn openRead(loop: *Loop, path: []const u8) File.OpenError!fd_t {
     switch (builtin.os) {
         .macosx, .linux, .freebsd, .netbsd => {
             const flags = os.O_LARGEFILE | os.O_RDONLY | os.O_CLOEXEC;
-            return await (async openPosix(loop, path, flags, File.default_mode) catch unreachable);
+            return openPosix(loop, path, flags, File.default_mode);
         },
         .windows => return windows.CreateFile(
 @@ -390,12 +433,12 @@ pub async fn openRead(loop: *Loop, path: []const u8) File.OpenError!fd_t {
 /// Creates if does not exist. Truncates the file if it exists.
 /// Uses the default mode.
-pub async fn openWrite(loop: *Loop, path: []const u8) File.OpenError!fd_t {
+pub fn openWrite(loop: *Loop, path: []const u8) File.OpenError!fd_t {
-    return await (async openWriteMode(loop, path, File.default_mode) catch unreachable);
+    return openWriteMode(loop, path, File.default_mode);
 }
 /// Creates if does not exist. Truncates the file if it exists.
-pub async fn openWriteMode(loop: *Loop, path: []const u8, mode: File.Mode) File.OpenError!fd_t {
+pub fn openWriteMode(loop: *Loop, path: []const u8, mode: File.Mode) File.OpenError!fd_t {
     switch (builtin.os) {
         .macosx,
         .linux,
 @@ -403,7 +446,7 @@ pub async fn openWriteMode(loop: *Loop, path: []const u8, mode: File.Mode) File.
         .netbsd,
         => {
             const flags = os.O_LARGEFILE | os.O_WRONLY | os.O_CREAT | os.O_CLOEXEC | os.O_TRUNC;
-            return await (async openPosix(loop, path, flags, File.default_mode) catch unreachable);
+            return openPosix(loop, path, flags, File.default_mode);
         },
         .windows => return windows.CreateFile(
             path,
 @@ -419,7 +462,7 @@ pub async fn openWriteMode(loop: *Loop, path: []const u8, mode: File.Mode) File.
 }
 /// Creates if does not exist. Does not truncate.
-pub async fn openReadWrite(
+pub fn openReadWrite(
     loop: *Loop,
     path: []const u8,
     mode: File.Mode,
 @@ -427,7 +470,7 @@ pub async fn openReadWrite(
     switch (builtin.os) {
         .macosx, .linux, .freebsd, .netbsd => {
             const flags = os.O_LARGEFILE | os.O_RDWR | os.O_CREAT | os.O_CLOEXEC;
-            return await (async openPosix(loop, path, flags, mode) catch unreachable);
+            return openPosix(loop, path, flags, mode);
         },
         .windows => return windows.CreateFile(
 @@ -576,24 +619,24 @@ pub const CloseOperation = struct {
 /// contents must remain alive until writeFile completes.
 /// TODO make this atomic or provide writeFileAtomic and rename this one to writeFileTruncate
-pub async fn writeFile(loop: *Loop, path: []const u8, contents: []const u8) !void {
+pub fn writeFile(loop: *Loop, path: []const u8, contents: []const u8) !void {
-    return await (async writeFileMode(loop, path, contents, File.default_mode) catch unreachable);
+    return writeFileMode(loop, path, contents, File.default_mode);
 }
 /// contents must remain alive until writeFile completes.
-pub async fn writeFileMode(loop: *Loop, path: []const u8, contents: []const u8, mode: File.Mode) !void {
+pub fn writeFileMode(loop: *Loop, path: []const u8, contents: []const u8, mode: File.Mode) !void {
     switch (builtin.os) {
         .linux,
         .macosx,
         .freebsd,
         .netbsd,
-        => return await (async writeFileModeThread(loop, path, contents, mode) catch unreachable),
+        => return writeFileModeThread(loop, path, contents, mode),
-        .windows => return await (async writeFileWindows(loop, path, contents) catch unreachable),
+        .windows => return writeFileWindows(loop, path, contents),
         else => @compileError("Unsupported OS"),
     }
 }
-async fn writeFileWindows(loop: *Loop, path: []const u8, contents: []const u8) !void {
+fn writeFileWindows(loop: *Loop, path: []const u8, contents: []const u8) !void {
     const handle = try windows.CreateFile(
         path,
         windows.GENERIC_WRITE,
 @@ -605,10 +648,10 @@ async fn writeFileWindows(loop: *Loop, path: []const u8, contents: []const u8) !
     );
     defer os.close(handle);
-    try await (async pwriteWindows(loop, handle, contents, 0) catch unreachable);
+    try pwriteWindows(loop, handle, contents, 0);
 }
-async fn writeFileModeThread(loop: *Loop, path: []const u8, contents: []const u8, mode: File.Mode) !void {
+fn writeFileModeThread(loop: *Loop, path: []const u8, contents: []const u8, mode: File.Mode) !void {
     const path_with_null = try std.cstr.addNullByte(loop.allocator, path);
     defer loop.allocator.free(path_with_null);
 @@ -646,11 +689,11 @@ async fn writeFileModeThread(loop: *Loop, path: []const u8, contents: []const u8
 /// The frame resumes when the last data has been confirmed written, but before the file handle
 /// is closed.
 /// Caller owns returned memory.
-pub async fn readFile(loop: *Loop, file_path: []const u8, max_size: usize) ![]u8 {
+pub fn readFile(loop: *Loop, file_path: []const u8, max_size: usize) ![]u8 {
     var close_op = try CloseOperation.start(loop);
     defer close_op.finish();
-    const fd = try await (async openRead(loop, file_path) catch unreachable);
+    const fd = try openRead(loop, file_path);
     close_op.setHandle(fd);
     var list = std.ArrayList(u8).init(loop.allocator);
 @@ -660,7 +703,7 @@ pub async fn readFile(loop: *Loop, file_path: []const u8, max_size: usize) ![]u8
         try list.ensureCapacity(list.len + mem.page_size);
         const buf = list.items[list.len..];
         const buf_array = [_][]u8{buf};
-        const amt = try await (async preadv(loop, fd, buf_array, list.len) catch unreachable);
+        const amt = try preadv(loop, fd, buf_array, list.len);
         list.len += amt;
         if (list.len > max_size) {
             return error.FileTooBig;
 @@ -1273,11 +1316,11 @@ const test_tmp_dir = "std_event_fs_test";
 //    return result;
 //}
-async fn testFsWatchCantFail(loop: *Loop, result: *(anyerror!void)) void {
+fn testFsWatchCantFail(loop: *Loop, result: *(anyerror!void)) void {
-    result.* = await (async testFsWatch(loop) catch unreachable);
+    result.* = testFsWatch(loop);
 }
-async fn testFsWatch(loop: *Loop) !void {
+fn testFsWatch(loop: *Loop) !void {
     const file_path = try std.fs.path.join(loop.allocator, [][]const u8{ test_tmp_dir, "file.txt" });
     defer loop.allocator.free(file_path);
 @@ -1288,27 +1331,27 @@ async fn testFsWatch(loop: *Loop) !void {
     const line2_offset = 7;
     // first just write then read the file
-    try await try async writeFile(loop, file_path, contents);
+    try writeFile(loop, file_path, contents);
-    const read_contents = try await try async readFile(loop, file_path, 1024 * 1024);
+    const read_contents = try readFile(loop, file_path, 1024 * 1024);
     testing.expectEqualSlices(u8, contents, read_contents);
     // now watch the file
     var watch = try Watch(void).create(loop, 0);
     defer watch.destroy();
-    testing.expect((try await try async watch.addFile(file_path, {})) == null);
+    testing.expect((try watch.addFile(file_path, {})) == null);
-    const ev = try async watch.channel.get();
+    const ev = async watch.channel.get();
     var ev_consumed = false;
     defer if (!ev_consumed) await ev;
     // overwrite line 2
-    const fd = try await try async openReadWrite(loop, file_path, File.default_mode);
+    const fd = try await openReadWrite(loop, file_path, File.default_mode);
     {
         defer os.close(fd);
-        try await try async pwritev(loop, fd, []const []const u8{"lorem ipsum"}, line2_offset);
+        try pwritev(loop, fd, []const []const u8{"lorem ipsum"}, line2_offset);
     }
     ev_consumed = true;
 @@ -1316,7 +1359,7 @@ async fn testFsWatch(loop: *Loop) !void {
         WatchEventId.CloseWrite => {},
         WatchEventId.Delete => @panic("wrong event"),
     }
-    const contents_updated = try await try async readFile(loop, file_path, 1024 * 1024);
+    const contents_updated = try readFile(loop, file_path, 1024 * 1024);
     testing.expectEqualSlices(u8,
         \\line 1
         \\lorem ipsum

std/event/future.zig+5-6

 @@ -97,28 +97,27 @@ test "std.event.Future" {
     loop.run();
 }
-async fn testFuture(loop: *Loop) void {
+fn testFuture(loop: *Loop) void {
     var future = Future(i32).init(loop);
     var a = async waitOnFuture(&future);
     var b = async waitOnFuture(&future);
-    var c = async resolveFuture(&future);
+    resolveFuture(&future);
-    // TODO make this work:
+    // TODO https://github.com/ziglang/zig/issues/3077
     //const result = (await a) + (await b);
     const a_result = await a;
     const b_result = await b;
     const result = a_result + b_result;
-    await c;
     testing.expect(result == 12);
 }
-async fn waitOnFuture(future: *Future(i32)) i32 {
+fn waitOnFuture(future: *Future(i32)) i32 {
     return future.get().*;
 }
-async fn resolveFuture(future: *Future(i32)) void {
+fn resolveFuture(future: *Future(i32)) void {
     future.data = 6;
     future.resolve();
 }

std/event/loop.zig+16-8

 @@ -89,12 +89,15 @@ pub const Loop = struct {
     pub const IoMode = enum {
         blocking,
         evented,
+        mixed,
     };
     pub const io_mode: IoMode = if (@hasDecl(root, "io_mode")) root.io_mode else IoMode.blocking;
     var global_instance_state: Loop = undefined;
+    threadlocal var per_thread_instance: ?*Loop = null;
     const default_instance: ?*Loop = switch (io_mode) {
         .blocking => null,
         .evented => &global_instance_state,
+        .mixed => per_thread_instance,
     };
     pub const instance: ?*Loop = if (@hasDecl(root, "event_loop")) root.event_loop else default_instance;
 @@ -146,10 +149,12 @@ pub const Loop = struct {
                 .overlapped = ResumeNode.overlapped_init,
             },
         };
+        // We need at least one of these in case the fs thread wants to use onNextTick
         const extra_thread_count = thread_count - 1;
+        const resume_node_count = std.math.max(extra_thread_count, 1);
         self.eventfd_resume_nodes = try self.allocator.alloc(
             std.atomic.Stack(ResumeNode.EventFd).Node,
-            extra_thread_count,
+            resume_node_count,
         );
         errdefer self.allocator.free(self.eventfd_resume_nodes);
 @@ -194,7 +199,7 @@ pub const Loop = struct {
                     eventfd_node.* = std.atomic.Stack(ResumeNode.EventFd).Node{
                         .data = ResumeNode.EventFd{
                             .base = ResumeNode{
-                                .id = ResumeNode.Id.EventFd,
+                                .id = .EventFd,
                                 .handle = undefined,
                                 .overlapped = ResumeNode.overlapped_init,
                             },
 @@ -451,12 +456,12 @@ pub const Loop = struct {
         self.finishOneEvent();
     }
-    pub async fn linuxWaitFd(self: *Loop, fd: i32, flags: u32) !void {
+    pub fn linuxWaitFd(self: *Loop, fd: i32, flags: u32) !void {
         defer self.linuxRemoveFd(fd);
         suspend {
             var resume_node = ResumeNode.Basic{
                 .base = ResumeNode{
-                    .id = ResumeNode.Id.Basic,
+                    .id = .Basic,
                     .handle = @frame(),
                     .overlapped = ResumeNode.overlapped_init,
                 },
 @@ -790,12 +795,15 @@ pub const Loop = struct {
     fn posixFsRun(self: *Loop) void {
         while (true) {
-            if (builtin.os == builtin.Os.linux) {
+            if (builtin.os == .linux) {
-                _ = @atomicRmw(i32, &self.os_data.fs_queue_item, AtomicRmwOp.Xchg, 0, AtomicOrder.SeqCst);
+                _ = @atomicRmw(i32, &self.os_data.fs_queue_item, .Xchg, 0, .SeqCst);
             }
             while (self.os_data.fs_queue.get()) |node| {
                 switch (node.data.msg) {
                     .End => return,
+                    .WriteV => |*msg| {
+                        msg.result = os.writev(msg.fd, msg.iov);
+                    },
                     .PWriteV => |*msg| {
                         msg.result = os.pwritev(msg.fd, msg.iov, msg.offset);
                     },
 @@ -827,14 +835,14 @@ pub const Loop = struct {
                 self.finishOneEvent();
             }
             switch (builtin.os) {
-                builtin.Os.linux => {
+                .linux => {
                     const rc = os.linux.futex_wait(&self.os_data.fs_queue_item, os.linux.FUTEX_WAIT, 0, null);
                     switch (os.linux.getErrno(rc)) {
                         0, os.EINTR, os.EAGAIN => continue,
                         else => unreachable,
                     }
                 },
-                builtin.Os.macosx, builtin.Os.freebsd, builtin.Os.netbsd => {
+                .macosx, .freebsd, .netbsd => {
                     const fs_kevs = (*const [1]os.Kevent)(&self.os_data.fs_kevent_wait);
                     var out_kevs: [1]os.Kevent = undefined;
                     _ = os.kevent(self.os_data.fs_kqfd, fs_kevs, out_kevs[0..], null) catch unreachable;

std/fmt.zig+72-75

 @@ -69,7 +69,6 @@ pub fn format(
         FormatFillAndAlign,
         FormatWidth,
         FormatPrecision,
-        Pointer,
     };
     comptime var start_index = 0;
 @@ -109,9 +108,6 @@ pub fn format(
                     state = .Start;
                     start_index = i;
                 },
-                '*' => {
-                    state = .Pointer;
-                },
                 ':' => {
                     state = if (comptime peekIsAlign(fmt[i..])) State.FormatFillAndAlign else State.FormatWidth;
                     specifier_end = i;
 @@ -256,19 +252,6 @@ pub fn format(
                     @compileError("Unexpected character in precision value: " ++ [_]u8{c});
                 },
             },
-            .Pointer => switch (c) {
-                '}' => {
-                    const arg_to_print = comptime nextArg(&used_pos_args, maybe_pos_arg, &next_arg);
-                    try output(context, @typeName(@typeOf(args[arg_to_print]).Child));
-                    try output(context, "@");
-                    try formatInt(@ptrToInt(args[arg_to_print]), 16, false, 0, context, Errors, output);
-                    state = .Start;
-                    start_index = i + 1;
-                },
-                else => @compileError("Unexpected format character after '*'"),
-            },
         }
     }
     comptime {
 @@ -293,12 +276,19 @@ pub fn format(
 pub fn formatType(
     value: var,
     comptime fmt: []const u8,
-    comptime options: FormatOptions,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
     max_depth: usize,
 ) Errors!void {
+    if (comptime std.mem.eql(u8, fmt, "*")) {
+        try output(context, @typeName(@typeOf(value).Child));
+        try output(context, "@");
+        try formatInt(@ptrToInt(value), 16, false, FormatOptions{}, context, Errors, output);
+        return;
+    }
     const T = @typeOf(value);
     switch (@typeInfo(T)) {
         .ComptimeInt, .Int, .Float => {
 @@ -438,15 +428,15 @@ pub fn formatType(
 fn formatValue(
     value: var,
     comptime fmt: []const u8,
-    comptime options: FormatOptions,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 ) Errors!void {
     if (comptime std.mem.eql(u8, fmt, "B")) {
-        return formatBytes(value, options.width, 1000, context, Errors, output);
+        return formatBytes(value, options, 1000, context, Errors, output);
     } else if (comptime std.mem.eql(u8, fmt, "Bi")) {
-        return formatBytes(value, options.width, 1024, context, Errors, output);
+        return formatBytes(value, options, 1024, context, Errors, output);
     }
     const T = @typeOf(value);
 @@ -460,7 +450,7 @@ fn formatValue(
 pub fn formatIntValue(
     value: var,
     comptime fmt: []const u8,
-    comptime options: FormatOptions,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -479,7 +469,7 @@ pub fn formatIntValue(
         uppercase = false;
     } else if (comptime std.mem.eql(u8, fmt, "c")) {
         if (@typeOf(int_value).bit_count <= 8) {
-            return formatAsciiChar(u8(int_value), context, Errors, output);
+            return formatAsciiChar(u8(int_value), options, context, Errors, output);
         } else {
             @compileError("Cannot print integer that is larger than 8 bits as a ascii");
         }
 @@ -496,21 +486,21 @@ pub fn formatIntValue(
         @compileError("Unknown format string: '" ++ fmt ++ "'");
     }
-    return formatInt(int_value, radix, uppercase, options.width orelse 0, context, Errors, output);
+    return formatInt(int_value, radix, uppercase, options, context, Errors, output);
 }
 fn formatFloatValue(
     value: var,
     comptime fmt: []const u8,
-    comptime options: FormatOptions,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 ) Errors!void {
     if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "e")) {
-        return formatFloatScientific(value, options.precision, context, Errors, output);
+        return formatFloatScientific(value, options, context, Errors, output);
     } else if (comptime std.mem.eql(u8, fmt, "d")) {
-        return formatFloatDecimal(value, options.precision, context, Errors, output);
+        return formatFloatDecimal(value, options, context, Errors, output);
     } else {
         @compileError("Unknown format string: '" ++ fmt ++ "'");
     }
 @@ -519,7 +509,7 @@ fn formatFloatValue(
 pub fn formatText(
     bytes: []const u8,
     comptime fmt: []const u8,
-    comptime options: FormatOptions,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -527,11 +517,10 @@ pub fn formatText(
     if (fmt.len == 0) {
         return output(context, bytes);
     } else if (comptime std.mem.eql(u8, fmt, "s")) {
-        if (options.width) |w| return formatBuf(bytes, w, context, Errors, output);
+        return formatBuf(bytes, options, context, Errors, output);
-        return formatBuf(bytes, 0, context, Errors, output);
     } else if (comptime (std.mem.eql(u8, fmt, "x") or std.mem.eql(u8, fmt, "X"))) {
         for (bytes) |c| {
-            try formatInt(c, 16, fmt[0] == 'X', 2, context, Errors, output);
+            try formatInt(c, 16, fmt[0] == 'X', FormatOptions{ .width = 2, .fill = '0' }, context, Errors, output);
         }
         return;
     } else {
 @@ -541,6 +530,7 @@ pub fn formatText(
 pub fn formatAsciiChar(
     c: u8,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -550,15 +540,16 @@ pub fn formatAsciiChar(
 pub fn formatBuf(
     buf: []const u8,
-    width: usize,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 ) Errors!void {
     try output(context, buf);
+    const width = options.width orelse 0;
     var leftover_padding = if (width > buf.len) (width - buf.len) else return;
-    const pad_byte: u8 = ' ';
+    const pad_byte: u8 = options.fill;
     while (leftover_padding > 0) : (leftover_padding -= 1) {
         try output(context, (*const [1]u8)(&pad_byte)[0..1]);
     }
 @@ -569,7 +560,7 @@ pub fn formatBuf(
 // same type unambiguously.
 pub fn formatFloatScientific(
     value: var,
-    maybe_precision: ?usize,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -591,7 +582,7 @@ pub fn formatFloatScientific(
     if (x == 0.0) {
         try output(context, "0");
-        if (maybe_precision) |precision| {
+        if (options.precision) |precision| {
             if (precision != 0) {
                 try output(context, ".");
                 var i: usize = 0;
 @@ -610,7 +601,7 @@ pub fn formatFloatScientific(
     var buffer: [32]u8 = undefined;
     var float_decimal = errol.errol3(x, buffer[0..]);
-    if (maybe_precision) |precision| {
+    if (options.precision) |precision| {
         errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Scientific);
         try output(context, float_decimal.digits[0..1]);
 @@ -650,13 +641,13 @@ pub fn formatFloatScientific(
         if (exp > -10 and exp < 10) {
             try output(context, "0");
         }
-        try formatInt(exp, 10, false, 0, context, Errors, output);
+        try formatInt(exp, 10, false, FormatOptions{ .width = 0 }, context, Errors, output);
     } else {
         try output(context, "-");
         if (exp > -10 and exp < 10) {
             try output(context, "0");
         }
-        try formatInt(-exp, 10, false, 0, context, Errors, output);
+        try formatInt(-exp, 10, false, FormatOptions{ .width = 0 }, context, Errors, output);
     }
 }
 @@ -664,7 +655,7 @@ pub fn formatFloatScientific(
 // By default floats are printed at full precision (no rounding).
 pub fn formatFloatDecimal(
     value: var,
-    maybe_precision: ?usize,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -686,7 +677,7 @@ pub fn formatFloatDecimal(
     if (x == 0.0) {
         try output(context, "0");
-        if (maybe_precision) |precision| {
+        if (options.precision) |precision| {
             if (precision != 0) {
                 try output(context, ".");
                 var i: usize = 0;
 @@ -707,7 +698,7 @@ pub fn formatFloatDecimal(
     var buffer: [32]u8 = undefined;
     var float_decimal = errol.errol3(x, buffer[0..]);
-    if (maybe_precision) |precision| {
+    if (options.precision) |precision| {
         errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Decimal);
         // exp < 0 means the leading is always 0 as errol result is normalized.
 @@ -809,7 +800,7 @@ pub fn formatFloatDecimal(
 pub fn formatBytes(
     value: var,
-    width: ?usize,
+    options: FormatOptions,
     comptime radix: usize,
     context: var,
     comptime Errors: type,
 @@ -833,7 +824,7 @@ pub fn formatBytes(
         else => unreachable,
     };
-    try formatFloatDecimal(new_value, width, context, Errors, output);
+    try formatFloatDecimal(new_value, options, context, Errors, output);
     if (suffix == ' ') {
         return output(context, "B");
 @@ -851,7 +842,7 @@ pub fn formatInt(
     value: var,
     base: u8,
     uppercase: bool,
-    width: usize,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -863,9 +854,9 @@ pub fn formatInt(
         value;
     if (@typeOf(int_value).is_signed) {
-        return formatIntSigned(int_value, base, uppercase, width, context, Errors, output);
+        return formatIntSigned(int_value, base, uppercase, options, context, Errors, output);
     } else {
-        return formatIntUnsigned(int_value, base, uppercase, width, context, Errors, output);
+        return formatIntUnsigned(int_value, base, uppercase, options, context, Errors, output);
     }
 }
 @@ -873,26 +864,30 @@ fn formatIntSigned(
     value: var,
     base: u8,
     uppercase: bool,
-    width: usize,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 ) Errors!void {
+    const new_options = FormatOptions{
+        .width = if (options.width) |w| (if (w == 0) 0 else w - 1) else null,
+        .precision = options.precision,
+        .fill = options.fill,
+    };
     const uint = @IntType(false, @typeOf(value).bit_count);
     if (value < 0) {
         const minus_sign: u8 = '-';
         try output(context, (*const [1]u8)(&minus_sign)[0..]);
         const new_value = @intCast(uint, -(value + 1)) + 1;
-        const new_width = if (width == 0) 0 else (width - 1);
+        return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
-        return formatIntUnsigned(new_value, base, uppercase, new_width, context, Errors, output);
+    } else if (options.width == null or options.width.? == 0) {
-    } else if (width == 0) {
+        return formatIntUnsigned(@intCast(uint, value), base, uppercase, options, context, Errors, output);
-        return formatIntUnsigned(@intCast(uint, value), base, uppercase, width, context, Errors, output);
     } else {
         const plus_sign: u8 = '+';
         try output(context, (*const [1]u8)(&plus_sign)[0..]);
         const new_value = @intCast(uint, value);
-        const new_width = if (width == 0) 0 else (width - 1);
+        return formatIntUnsigned(new_value, base, uppercase, new_options, context, Errors, output);
-        return formatIntUnsigned(new_value, base, uppercase, new_width, context, Errors, output);
     }
 }
 @@ -900,7 +895,7 @@ fn formatIntUnsigned(
     value: var,
     base: u8,
     uppercase: bool,
-    width: usize,
+    options: FormatOptions,
     context: var,
     comptime Errors: type,
     output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -921,31 +916,32 @@ fn formatIntUnsigned(
     }
     const digits_buf = buf[index..];
+    const width = options.width orelse 0;
     const padding = if (width > digits_buf.len) (width - digits_buf.len) else 0;
     if (padding > index) {
-        const zero_byte: u8 = '0';
+        const zero_byte: u8 = options.fill;
         var leftover_padding = padding - index;
         while (true) {
             try output(context, (*const [1]u8)(&zero_byte)[0..]);
             leftover_padding -= 1;
             if (leftover_padding == 0) break;
         }
-        mem.set(u8, buf[0..index], '0');
+        mem.set(u8, buf[0..index], options.fill);
         return output(context, buf);
     } else {
         const padded_buf = buf[index - padding ..];
-        mem.set(u8, padded_buf[0..padding], '0');
+        mem.set(u8, padded_buf[0..padding], options.fill);
         return output(context, padded_buf);
     }
 }
-pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, width: usize) usize {
+pub fn formatIntBuf(out_buf: []u8, value: var, base: u8, uppercase: bool, options: FormatOptions) usize {
     var context = FormatIntBuf{
         .out_buf = out_buf,
         .index = 0,
     };
-    formatInt(value, base, uppercase, width, &context, error{}, formatIntCallback) catch unreachable;
+    formatInt(value, base, uppercase, options, &context, error{}, formatIntCallback) catch unreachable;
     return context.index;
 }
 const FormatIntBuf = struct {
 @@ -1088,23 +1084,23 @@ fn countSize(size: *usize, bytes: []const u8) (error{}!void) {
 test "bufPrintInt" {
     var buffer: [100]u8 = undefined;
     const buf = buffer[0..];
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 2, false, 0), "-101111000110000101001110"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 2, false, FormatOptions{}), "-101111000110000101001110"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 10, false, 0), "-12345678"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 10, false, FormatOptions{}), "-12345678"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, false, 0), "-bc614e"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, false, FormatOptions{}), "-bc614e"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, true, 0), "-BC614E"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-12345678), 16, true, FormatOptions{}), "-BC614E"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(12345678), 10, true, 0), "12345678"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(12345678), 10, true, FormatOptions{}), "12345678"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(666), 10, false, 6), "000666"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(666), 10, false, FormatOptions{ .width = 6 }), "   666"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 6), "001234"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, FormatOptions{ .width = 6 }), "  1234"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, 1), "1234"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, u32(0x1234), 16, false, FormatOptions{ .width = 1 }), "1234"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(42), 10, false, 3), "+42"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(42), 10, false, FormatOptions{ .width = 3 }), "+42"));
-    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-42), 10, false, 3), "-42"));
+    testing.expect(mem.eql(u8, bufPrintIntToSlice(buf, i32(-42), 10, false, FormatOptions{ .width = 3 }), "-42"));
 }
-fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, width: usize) []u8 {
+fn bufPrintIntToSlice(buf: []u8, value: var, base: u8, uppercase: bool, options: FormatOptions) []u8 {
-    return buf[0..formatIntBuf(buf, value, base, uppercase, width)];
+    return buf[0..formatIntBuf(buf, value, base, uppercase, options)];
 }
 test "parse u64 digit too big" {
 @@ -1162,7 +1158,8 @@ test "int.specifier" {
 }
 test "int.padded" {
-    try testFmt("u8: '0001'", "u8: '{:4}'", u8(1));
+    try testFmt("u8: '   1'", "u8: '{:4}'", u8(1));
+    try testFmt("u8: 'xxx1'", "u8: '{:x<4}'", u8(1));
 }
 test "buffer" {
 @@ -1237,7 +1234,7 @@ test "cstr" {
 test "filesize" {
     try testFmt("file size: 63MiB\n", "file size: {Bi}\n", usize(63 * 1024 * 1024));
-    try testFmt("file size: 66.06MB\n", "file size: {B:2}\n", usize(63 * 1024 * 1024));
+    try testFmt("file size: 66.06MB\n", "file size: {B:.2}\n", usize(63 * 1024 * 1024));
 }
 test "struct" {
 @@ -1342,7 +1339,7 @@ test "custom" {
         pub fn format(
             self: SelfType,
             comptime fmt: []const u8,
-            comptime options: FormatOptions,
+            options: FormatOptions,
             context: var,
             comptime Errors: type,
             output: fn (@typeOf(context), []const u8) Errors!void,
 @@ -1548,7 +1545,7 @@ test "formatType max_depth" {
         pub fn format(
             self: SelfType,
             comptime fmt: []const u8,
-            comptime options: FormatOptions,
+            options: FormatOptions,
             context: var,
             comptime Errors: type,
             output: fn (@typeOf(context), []const u8) Errors!void,

std/fs.zig+13

...	@@ -442,6 +442,8 @@ pub fn deleteTree(allocator: *Allocator, full_path: []const u8) DeleteTreeError!	...	@@ -442,6 +442,8 @@ pub fn deleteTree(allocator: *Allocator, full_path: []const u8) DeleteTreeError!
442	}	442	}
443	}	443	}
444		444
		445	/// TODO: separate this API into the one that opens directory handles to then subsequently open
		446	/// files, and into the one that reads files from an open directory handle.
445	pub const Dir = struct {	447	pub const Dir = struct {
446	handle: Handle,	448	handle: Handle,
447	allocator: *Allocator,	449	allocator: *Allocator,
...	@@ -564,6 +566,17 @@ pub const Dir = struct {	...	@@ -564,6 +566,17 @@ pub const Dir = struct {
564	}	566	}
565	}	567	}
566		568
		569	pub fn openRead(self: Dir, file_path: []const u8) os.OpenError!File {
		570	const path_c = try os.toPosixPath(file_path);
		571	return self.openReadC(&path_c);
		572	}
		573
		574	pub fn openReadC(self: Dir, file_path: [*]const u8) OpenError!File {
		575	const flags = os.O_LARGEFILE \| os.O_RDONLY;
		576	const fd = try os.openatC(self.handle.fd, file_path, flags, 0);
		577	return File.openHandle(fd);
		578	}
		579
567	fn nextDarwin(self: *Dir) !?Entry {	580	fn nextDarwin(self: *Dir) !?Entry {
568	start_over: while (true) {	581	start_over: while (true) {
569	if (self.handle.index >= self.handle.end_index) {	582	if (self.handle.index >= self.handle.end_index) {

std/fs/file.zig+8

...	@@ -302,6 +302,14 @@ pub const File = struct {	...	@@ -302,6 +302,14 @@ pub const File = struct {
302	return os.write(self.handle, bytes);	302	return os.write(self.handle, bytes);
303	}	303	}
304		304
		305	pub fn writev_iovec(self: File, iovecs: []const os.iovec_const) WriteError!void {
		306	if (std.event.Loop.instance) \|loop\| {
		307	return std.event.fs.writevPosix(loop, self.handle, iovecs);
		308	} else {
		309	return os.writev(self.handle, iovecs);
		310	}
		311	}
		312
305	pub fn inStream(file: File) InStream {	313	pub fn inStream(file: File) InStream {
306	return InStream{	314	return InStream{
307	.file = file,	315	.file = file,

std/io.zig+1-1

...	@@ -146,7 +146,7 @@ pub fn InStream(comptime ReadError: type) type {	...	@@ -146,7 +146,7 @@ pub fn InStream(comptime ReadError: type) type {
146		146
147	/// Same as `readFull` but end of stream returns `error.EndOfStream`.	147	/// Same as `readFull` but end of stream returns `error.EndOfStream`.
148	pub fn readNoEof(self: *Self, buf: []u8) !void {	148	pub fn readNoEof(self: *Self, buf: []u8) !void {
149	const amt_read = try self.read(buf);	149	const amt_read = try self.readFull(buf);
150	if (amt_read < buf.len) return error.EndOfStream;	150	if (amt_read < buf.len) return error.EndOfStream;
151	}	151	}
152		152

std/math/big/int.zig+1-1

...	@@ -519,7 +519,7 @@ pub const Int = struct {	...	@@ -519,7 +519,7 @@ pub const Int = struct {
519	pub fn format(	519	pub fn format(
520	self: Int,	520	self: Int,
521	comptime fmt: []const u8,	521	comptime fmt: []const u8,
522	comptime options: std.fmt.FormatOptions,	522	options: std.fmt.FormatOptions,
523	context: var,	523	context: var,
524	comptime FmtError: type,	524	comptime FmtError: type,
525	output: fn (@typeOf(context), []const u8) FmtError!void,	525	output: fn (@typeOf(context), []const u8) FmtError!void,

std/net.zig+30

...	@@ -215,3 +215,33 @@ test "std.net.parseIp6" {	...	@@ -215,3 +215,33 @@ test "std.net.parseIp6" {
215	assert(addr.addr[1] == 0x01);	215	assert(addr.addr[1] == 0x01);
216	assert(addr.addr[2] == 0x00);	216	assert(addr.addr[2] == 0x00);
217	}	217	}
		218
		219	pub fn connectUnixSocket(path: []const u8) !std.fs.File {
		220	const opt_non_block = if (std.event.Loop.instance != null) os.SOCK_NONBLOCK else 0;
		221	const sockfd = try os.socket(
		222	os.AF_UNIX,
		223	os.SOCK_STREAM \| os.SOCK_CLOEXEC \| opt_non_block,
		224	0,
		225	);
		226	errdefer os.close(sockfd);
		227
		228	var sock_addr = os.sockaddr{
		229	.un = os.sockaddr_un{
		230	.family = os.AF_UNIX,
		231	.path = undefined,
		232	},
		233	};
		234
		235	if (path.len > @typeOf(sock_addr.un.path).len) return error.NameTooLong;
		236	mem.copy(u8, sock_addr.un.path[0..], path);
		237	const size = @intCast(u32, @sizeOf(os.sa_family_t) + path.len);
		238	if (std.event.Loop.instance) \|loop\| {
		239	try os.connect_async(sockfd, &sock_addr, size);
		240	try loop.linuxWaitFd(sockfd, os.EPOLLIN \| os.EPOLLOUT \| os.EPOLLET);
		241	try os.getsockoptError(sockfd);
		242	} else {
		243	try os.connect(sockfd, &sock_addr, size);
		244	}
		245
		246	return std.fs.File.openHandle(sockfd);
		247	}

std/os.zig+93-26

...	@@ -99,47 +99,46 @@ pub const GetRandomError = OpenError;	...	@@ -99,47 +99,46 @@ pub const GetRandomError = OpenError;
99	/// When linking against libc, this calls the	99	/// When linking against libc, this calls the
100	/// appropriate OS-specific library call. Otherwise it uses the zig standard	100	/// appropriate OS-specific library call. Otherwise it uses the zig standard
101	/// library implementation.	101	/// library implementation.
102	pub fn getrandom(buf: []u8) GetRandomError!void {	102	pub fn getrandom(buffer: []u8) GetRandomError!void {
103	if (windows.is_the_target) {	103	if (windows.is_the_target) {
104	return windows.RtlGenRandom(buf);	104	return windows.RtlGenRandom(buffer);
105	}	105	}
106	if (linux.is_the_target) {	106	if (linux.is_the_target or freebsd.is_the_target) {
107	while (true) {	107	var buf = buffer;
108	const err = if (std.c.versionCheck(builtin.Version{ .major = 2, .minor = 25, .patch = 0 }).ok) blk: {	108	const use_c = !linux.is_the_target or
109	break :blk errno(std.c.getrandom(buf.ptr, buf.len, 0));	109	std.c.versionCheck(builtin.Version{ .major = 2, .minor = 25, .patch = 0 }).ok;
		110
		111	while (buf.len != 0) {
		112	var err: u16 = undefined;
		113
		114	const num_read = if (use_c) blk: {
		115	const rc = std.c.getrandom(buf.ptr, buf.len, 0);
		116	err = std.c.getErrno(rc);
		117	break :blk @bitCast(usize, rc);
110	} else blk: {	118	} else blk: {
111	break :blk linux.getErrno(linux.getrandom(buf.ptr, buf.len, 0));	119	const rc = linux.getrandom(buf.ptr, buf.len, 0);
		120	err = linux.getErrno(rc);
		121	break :blk rc;
112	};	122	};
113	switch (err) {
114	0 => return,
115	EINVAL => unreachable,
116	EFAULT => unreachable,
117	EINTR => continue,
118	ENOSYS => return getRandomBytesDevURandom(buf),
119	else => return unexpectedErrno(err),
120	}
121	}
122	}
123	if (freebsd.is_the_target) {
124	while (true) {
125	const err = std.c.getErrno(std.c.getrandom(buf.ptr, buf.len, 0));
126		123
127	switch (err) {	124	switch (err) {
128	0 => return,	125	0 => buf = buf[num_read..],
129	EINVAL => unreachable,	126	EINVAL => unreachable,
130	EFAULT => unreachable,	127	EFAULT => unreachable,
131	EINTR => continue,	128	EINTR => continue,
		129	ENOSYS => return getRandomBytesDevURandom(buf),
132	else => return unexpectedErrno(err),	130	else => return unexpectedErrno(err),
133	}	131	}
134	}	132	}
		133	return;
135	}	134	}
136	if (wasi.is_the_target) {	135	if (wasi.is_the_target) {
137	switch (wasi.random_get(buf.ptr, buf.len)) {	136	switch (wasi.random_get(buffer.ptr, buffer.len)) {
138	0 => return,	137	0 => return,
139	else => \|err\| return unexpectedErrno(err),	138	else => \|err\| return unexpectedErrno(err),
140	}	139	}
141	}	140	}
142	return getRandomBytesDevURandom(buf);	141	return getRandomBytesDevURandom(buffer);
143	}	142	}
144		143
145	fn getRandomBytesDevURandom(buf: []u8) !void {	144	fn getRandomBytesDevURandom(buf: []u8) !void {
...	@@ -440,6 +439,33 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!void {	...	@@ -440,6 +439,33 @@ pub fn write(fd: fd_t, bytes: []const u8) WriteError!void {
440		439
441	/// Write multiple buffers to a file descriptor. Keeps trying if it gets interrupted.	440	/// Write multiple buffers to a file descriptor. Keeps trying if it gets interrupted.
442	/// This function is for blocking file descriptors only. For non-blocking, see	441	/// This function is for blocking file descriptors only. For non-blocking, see
		442	/// `writevAsync`.
		443	pub fn writev(fd: fd_t, iov: []const iovec_const) WriteError!void {
		444	while (true) {
		445	// TODO handle the case when iov_len is too large and get rid of this @intCast
		446	const rc = system.writev(fd, iov.ptr, @intCast(u32, iov.len));
		447	switch (errno(rc)) {
		448	0 => return,
		449	EINTR => continue,
		450	EINVAL => unreachable,
		451	EFAULT => unreachable,
		452	EAGAIN => unreachable, // This function is for blocking writes.
		453	EBADF => unreachable, // Always a race condition.
		454	EDESTADDRREQ => unreachable, // `connect` was never called.
		455	EDQUOT => return error.DiskQuota,
		456	EFBIG => return error.FileTooBig,
		457	EIO => return error.InputOutput,
		458	ENOSPC => return error.NoSpaceLeft,
		459	EPERM => return error.AccessDenied,
		460	EPIPE => return error.BrokenPipe,
		461	else => \|err\| return unexpectedErrno(err),
		462	}
		463	}
		464	}
		465
		466	/// Write multiple buffers to a file descriptor, with a position offset.
		467	/// Keeps trying if it gets interrupted.
		468	/// This function is for blocking file descriptors only. For non-blocking, see
443	/// `pwritevAsync`.	469	/// `pwritevAsync`.
444	pub fn pwritev(fd: fd_t, iov: []const iovec_const, offset: u64) WriteError!void {	470	pub fn pwritev(fd: fd_t, iov: []const iovec_const, offset: u64) WriteError!void {
445	if (darwin.is_the_target) {	471	if (darwin.is_the_target) {
...	@@ -524,7 +550,6 @@ pub const OpenError = error{	...	@@ -524,7 +550,6 @@ pub const OpenError = error{
524	};	550	};
525		551
526	/// Open and possibly create a file. Keeps trying if it gets interrupted.	552	/// Open and possibly create a file. Keeps trying if it gets interrupted.
527	/// `file_path` needs to be copied in memory to add a null terminating byte.
528	/// See also `openC`.	553	/// See also `openC`.
529	pub fn open(file_path: []const u8, flags: u32, perm: usize) OpenError!fd_t {	554	pub fn open(file_path: []const u8, flags: u32, perm: usize) OpenError!fd_t {
530	const file_path_c = try toPosixPath(file_path);	555	const file_path_c = try toPosixPath(file_path);
...	@@ -564,6 +589,47 @@ pub fn openC(file_path: [*]const u8, flags: u32, perm: usize) OpenError!fd_t {	...	@@ -564,6 +589,47 @@ pub fn openC(file_path: [*]const u8, flags: u32, perm: usize) OpenError!fd_t {
564	}	589	}
565	}	590	}
566		591
		592	/// Open and possibly create a file. Keeps trying if it gets interrupted.
		593	/// `file_path` is relative to the open directory handle `dir_fd`.
		594	/// See also `openatC`.
		595	pub fn openat(dir_fd: fd_t, file_path: []const u8, flags: u32, mode: usize) OpenError!fd_t {
		596	const file_path_c = try toPosixPath(file_path);
		597	return openatC(dir_fd, &file_path_c, flags, mode);
		598	}
		599
		600	/// Open and possibly create a file. Keeps trying if it gets interrupted.
		601	/// `file_path` is relative to the open directory handle `dir_fd`.
		602	/// See also `openat`.
		603	pub fn openatC(dir_fd: fd_t, file_path: [*]const u8, flags: u32, mode: usize) OpenError!fd_t {
		604	while (true) {
		605	const rc = system.openat(dir_fd, file_path, flags, mode);
		606	switch (errno(rc)) {
		607	0 => return @intCast(fd_t, rc),
		608	EINTR => continue,
		609
		610	EFAULT => unreachable,
		611	EINVAL => unreachable,
		612	EACCES => return error.AccessDenied,
		613	EFBIG => return error.FileTooBig,
		614	EOVERFLOW => return error.FileTooBig,
		615	EISDIR => return error.IsDir,
		616	ELOOP => return error.SymLinkLoop,
		617	EMFILE => return error.ProcessFdQuotaExceeded,
		618	ENAMETOOLONG => return error.NameTooLong,
		619	ENFILE => return error.SystemFdQuotaExceeded,
		620	ENODEV => return error.NoDevice,
		621	ENOENT => return error.FileNotFound,
		622	ENOMEM => return error.SystemResources,
		623	ENOSPC => return error.NoSpaceLeft,
		624	ENOTDIR => return error.NotDir,
		625	EPERM => return error.AccessDenied,
		626	EEXIST => return error.PathAlreadyExists,
		627	EBUSY => return error.DeviceBusy,
		628	else => \|err\| return unexpectedErrno(err),
		629	}
		630	}
		631	}
		632
567	pub fn dup2(old_fd: fd_t, new_fd: fd_t) !void {	633	pub fn dup2(old_fd: fd_t, new_fd: fd_t) !void {
568	while (true) {	634	while (true) {
569	switch (errno(system.dup2(old_fd, new_fd))) {	635	switch (errno(system.dup2(old_fd, new_fd))) {
...	@@ -1655,7 +1721,7 @@ pub const ConnectError = error{	...	@@ -1655,7 +1721,7 @@ pub const ConnectError = error{
1655	/// For non-blocking, see `connect_async`.	1721	/// For non-blocking, see `connect_async`.
1656	pub fn connect(sockfd: i32, sock_addr: *sockaddr, len: socklen_t) ConnectError!void {	1722	pub fn connect(sockfd: i32, sock_addr: *sockaddr, len: socklen_t) ConnectError!void {
1657	while (true) {	1723	while (true) {
1658	switch (errno(system.connect(sockfd, sock_addr, @sizeOf(sockaddr)))) {	1724	switch (errno(system.connect(sockfd, sock_addr, len))) {
1659	0 => return,	1725	0 => return,
1660	EACCES => return error.PermissionDenied,	1726	EACCES => return error.PermissionDenied,
1661	EPERM => return error.PermissionDenied,	1727	EPERM => return error.PermissionDenied,
...	@@ -1683,7 +1749,8 @@ pub fn connect(sockfd: i32, sock_addr: *sockaddr, len: socklen_t) ConnectError!v	...	@@ -1683,7 +1749,8 @@ pub fn connect(sockfd: i32, sock_addr: *sockaddr, len: socklen_t) ConnectError!v
1683	/// It expects to receive EINPROGRESS`.	1749	/// It expects to receive EINPROGRESS`.
1684	pub fn connect_async(sockfd: i32, sock_addr: *sockaddr, len: socklen_t) ConnectError!void {	1750	pub fn connect_async(sockfd: i32, sock_addr: *sockaddr, len: socklen_t) ConnectError!void {
1685	while (true) {	1751	while (true) {
1686	switch (errno(system.connect(sockfd, sock_addr, @sizeOf(sockaddr)))) {	1752	switch (errno(system.connect(sockfd, sock_addr, len))) {
		1753	EINVAL => unreachable,
1687	EINTR => continue,	1754	EINTR => continue,
1688	0, EINPROGRESS => return,	1755	0, EINPROGRESS => return,
1689	EACCES => return error.PermissionDenied,	1756	EACCES => return error.PermissionDenied,

std/os/bits/linux.zig+1

...	@@ -784,6 +784,7 @@ pub const socklen_t = u32;	...	@@ -784,6 +784,7 @@ pub const socklen_t = u32;
784	pub const sockaddr = extern union {	784	pub const sockaddr = extern union {
785	in: sockaddr_in,	785	in: sockaddr_in,
786	in6: sockaddr_in6,	786	in6: sockaddr_in6,
		787	un: sockaddr_un,
787	};	788	};
788		789
789	pub const sockaddr_in = extern struct {	790	pub const sockaddr_in = extern struct {

test/compare_output.zig+1-1

...	@@ -124,7 +124,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -124,7 +124,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
124	\\ const stdout = &(io.getStdOut() catch unreachable).outStream().stream;	124	\\ const stdout = &(io.getStdOut() catch unreachable).outStream().stream;
125	\\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", u32(12), u16(0x12), u8('a')) catch unreachable;	125	\\ stdout.print("Hello, world!\n{d:4} {x:3} {c}\n", u32(12), u16(0x12), u8('a')) catch unreachable;
126	\\}	126	\\}
127	, "Hello, world!\n0012 012 a\n");	127	, "Hello, world!\n 12 12 a\n");
128		128
129	cases.addC("number literals",	129	cases.addC("number literals",
130	\\const builtin = @import("builtin");	130	\\const builtin = @import("builtin");

test/compile_errors.zig+102-1

...	@@ -2,6 +2,107 @@ const tests = @import("tests.zig");	...	@@ -2,6 +2,107 @@ const tests = @import("tests.zig");
2	const builtin = @import("builtin");	2	const builtin = @import("builtin");
3		3
4	pub fn addCases(cases: *tests.CompileErrorContext) void {	4	pub fn addCases(cases: *tests.CompileErrorContext) void {
		5	cases.addCase(x: {
		6	var tc = cases.create("variable in inline assembly template cannot be found",
		7	\\export fn entry() void {
		8	\\ var sp = asm volatile (
		9	\\ "mov %[foo], sp"
		10	\\ : [bar] "=r" (-> usize)
		11	\\ );
		12	\\}
		13	, "tmp.zig:2:14: error: could not find 'foo' in the inputs or outputs.");
		14	tc.target = tests.Target{
		15	.Cross = tests.CrossTarget{
		16	.arch = .x86_64,
		17	.os = .linux,
		18	.abi = .gnu,
		19	},
		20	};
		21	break :x tc;
		22	});
		23
		24	cases.add(
		25	"indirect recursion of async functions detected",
		26	\\var frame: ?anyframe = null;
		27	\\
		28	\\export fn a() void {
		29	\\ _ = async rangeSum(10);
		30	\\ while (frame) \|f\| resume f;
		31	\\}
		32	\\
		33	\\fn rangeSum(x: i32) i32 {
		34	\\ suspend {
		35	\\ frame = @frame();
		36	\\ }
		37	\\ frame = null;
		38	\\
		39	\\ if (x == 0) return 0;
		40	\\ var child = rangeSumIndirect(x - 1);
		41	\\ return child + 1;
		42	\\}
		43	\\
		44	\\fn rangeSumIndirect(x: i32) i32 {
		45	\\ suspend {
		46	\\ frame = @frame();
		47	\\ }
		48	\\ frame = null;
		49	\\
		50	\\ if (x == 0) return 0;
		51	\\ var child = rangeSum(x - 1);
		52	\\ return child + 1;
		53	\\}
		54	,
		55	"tmp.zig:8:1: error: '@Frame(rangeSum)' depends on itself",
		56	"tmp.zig:15:33: note: when analyzing type '@Frame(rangeSumIndirect)' here",
		57	"tmp.zig:26:25: note: when analyzing type '@Frame(rangeSum)' here",
		58	);
		59
		60	cases.add(
		61	"non-async function pointer eventually is inferred to become async",
		62	\\export fn a() void {
		63	\\ var non_async_fn: fn () void = undefined;
		64	\\ non_async_fn = func;
		65	\\}
		66	\\fn func() void {
		67	\\ suspend;
		68	\\}
		69	,
		70	"tmp.zig:5:1: error: 'func' cannot be async",
		71	"tmp.zig:3:20: note: required to be non-async here",
		72	"tmp.zig:6:5: note: suspends here",
		73	);
		74
		75	cases.add(
		76	"bad alignment in @asyncCall",
		77	\\export fn entry() void {
		78	\\ var ptr: async fn () void = func;
		79	\\ var bytes: [64]u8 = undefined;
		80	\\ _ = @asyncCall(&bytes, {}, ptr);
		81	\\}
		82	\\async fn func() void {}
		83	,
		84	"tmp.zig:4:21: error: expected type '[]align(16) u8', found '*[64]u8'",
		85	);
		86
		87	cases.add(
		88	"atomic orderings of fence Acquire or stricter",
		89	\\export fn entry() void {
		90	\\ @fence(.Monotonic);
		91	\\}
		92	,
		93	"tmp.zig:2:12: error: atomic ordering must be Acquire or stricter",
		94	);
		95
		96	cases.add(
		97	"bad alignment in implicit cast from array pointer to slice",
		98	\\export fn a() void {
		99	\\ var x: [10]u8 = undefined;
		100	\\ var y: []align(16) u8 = &x;
		101	\\}
		102	,
		103	"tmp.zig:3:30: error: expected type '[]align(16) u8', found '*[10]u8'",
		104	);
		105
5	cases.add(	106	cases.add(
6	"result location incompatibility mismatching handle_is_ptr (generic call)",	107	"result location incompatibility mismatching handle_is_ptr (generic call)",
7	\\export fn entry() void {	108	\\export fn entry() void {
...	@@ -164,7 +265,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {	...	@@ -164,7 +265,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
164	"non async function pointer passed to @asyncCall",	265	"non async function pointer passed to @asyncCall",
165	\\export fn entry() void {	266	\\export fn entry() void {
166	\\ var ptr = afunc;	267	\\ var ptr = afunc;
167	\\ var bytes: [100]u8 = undefined;	268	\\ var bytes: [100]u8 align(16) = undefined;
168	\\ _ = @asyncCall(&bytes, {}, ptr);	269	\\ _ = @asyncCall(&bytes, {}, ptr);
169	\\}	270	\\}
170	\\fn afunc() void { }	271	\\fn afunc() void { }

test/runtime_safety.zig+1-1

...	@@ -30,7 +30,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {	...	@@ -30,7 +30,7 @@ pub fn addCases(cases: *tests.CompareOutputContext) void {
30	\\ @import("std").os.exit(126);	30	\\ @import("std").os.exit(126);
31	\\}	31	\\}
32	\\pub fn main() void {	32	\\pub fn main() void {
33	\\ var bytes: [1]u8 = undefined;	33	\\ var bytes: [1]u8 align(16) = undefined;
34	\\ var ptr = other;	34	\\ var ptr = other;
35	\\ var frame = @asyncCall(&bytes, {}, ptr);	35	\\ var frame = @asyncCall(&bytes, {}, ptr);
36	\\}	36	\\}

test/stage1/behavior/array.zig+20-2

...	@@ -1,5 +1,6 @@	...	@@ -1,5 +1,6 @@
1	const expect = @import("std").testing.expect;	1	const std = @import("std");
2	const mem = @import("std").mem;	2	const expect = std.testing.expect;
		3	const mem = std.mem;
3		4
4	test "arrays" {	5	test "arrays" {
5	var array: [5]u32 = undefined;	6	var array: [5]u32 = undefined;
...	@@ -274,3 +275,20 @@ test "double nested array to const slice cast in array literal" {	...	@@ -274,3 +275,20 @@ test "double nested array to const slice cast in array literal" {
274	S.entry(2);	275	S.entry(2);
275	comptime S.entry(2);	276	comptime S.entry(2);
276	}	277	}
		278
		279	test "read/write through global variable array of struct fields initialized via array mult" {
		280	const S = struct {
		281	fn doTheTest() void {
		282	expect(storage[0].term == 1);
		283	storage[0] = MyStruct{ .term = 123 };
		284	expect(storage[0].term == 123);
		285	}
		286
		287	pub const MyStruct = struct {
		288	term: usize,
		289	};
		290
		291	var storage: [1]MyStruct = [_]MyStruct{MyStruct{ .term = 1 }} ** 1;
		292	};
		293	S.doTheTest();
		294	}

test/stage1/behavior/async_fn.zig+29-2

...	@@ -280,7 +280,7 @@ test "async fn pointer in a struct field" {	...	@@ -280,7 +280,7 @@ test "async fn pointer in a struct field" {
280	bar: async fn (*i32) void,	280	bar: async fn (*i32) void,
281	};	281	};
282	var foo = Foo{ .bar = simpleAsyncFn2 };	282	var foo = Foo{ .bar = simpleAsyncFn2 };
283	var bytes: [64]u8 = undefined;	283	var bytes: [64]u8 align(16) = undefined;
284	const f = @asyncCall(&bytes, {}, foo.bar, &data);	284	const f = @asyncCall(&bytes, {}, foo.bar, &data);
285	comptime expect(@typeOf(f) == anyframe->void);	285	comptime expect(@typeOf(f) == anyframe->void);
286	expect(data == 2);	286	expect(data == 2);
...	@@ -317,7 +317,7 @@ test "@asyncCall with return type" {	...	@@ -317,7 +317,7 @@ test "@asyncCall with return type" {
317	}	317	}
318	};	318	};
319	var foo = Foo{ .bar = Foo.middle };	319	var foo = Foo{ .bar = Foo.middle };
320	var bytes: [150]u8 = undefined;	320	var bytes: [150]u8 align(16) = undefined;
321	var aresult: i32 = 0;	321	var aresult: i32 = 0;
322	_ = @asyncCall(&bytes, &aresult, foo.bar);	322	_ = @asyncCall(&bytes, &aresult, foo.bar);
323	expect(aresult == 0);	323	expect(aresult == 0);
...	@@ -817,3 +817,30 @@ test "struct parameter to async function is copied to the frame" {	...	@@ -817,3 +817,30 @@ test "struct parameter to async function is copied to the frame" {
817	};	817	};
818	S.doTheTest();	818	S.doTheTest();
819	}	819	}
		820
		821	test "cast fn to async fn when it is inferred to be async" {
		822	const S = struct {
		823	var frame: anyframe = undefined;
		824	var ok = false;
		825
		826	fn doTheTest() void {
		827	var ptr: async fn () i32 = undefined;
		828	ptr = func;
		829	var buf: [100]u8 align(16) = undefined;
		830	var result: i32 = undefined;
		831	_ = await @asyncCall(&buf, &result, ptr);
		832	expect(result == 1234);
		833	ok = true;
		834	}
		835
		836	fn func() i32 {
		837	suspend {
		838	frame = @frame();
		839	}
		840	return 1234;
		841	}
		842	};
		843	_ = async S.doTheTest();
		844	resume S.frame;
		845	expect(S.ok);
		846	}

test/stage1/behavior/bitcast.zig+14

...	@@ -125,3 +125,17 @@ test "implicit cast to error union by returning" {	...	@@ -125,3 +125,17 @@ test "implicit cast to error union by returning" {
125	S.entry();	125	S.entry();
126	comptime S.entry();	126	comptime S.entry();
127	}	127	}
		128
		129	// issue #3010: compiler segfault
		130	test "bitcast literal [4]u8 param to u32" {
		131	const ip = @bitCast(u32, [_]u8{ 255, 255, 255, 255 });
		132	expect(ip == maxInt(u32));
		133	}
		134
		135	test "bitcast packed struct literal to byte" {
		136	const Foo = packed struct {
		137	value: u8,
		138	};
		139	const casted = @bitCast(u8, Foo{ .value = 0xF });
		140	expect(casted == 0xf);
		141	}

test/stage1/behavior/enum_with_members.zig+2-2

...	@@ -8,8 +8,8 @@ const ET = union(enum) {	...	@@ -8,8 +8,8 @@ const ET = union(enum) {
8		8
9	pub fn print(a: *const ET, buf: []u8) anyerror!usize {	9	pub fn print(a: *const ET, buf: []u8) anyerror!usize {
10	return switch (a.*) {	10	return switch (a.*) {
11	ET.SINT => \|x\| fmt.formatIntBuf(buf, x, 10, false, 0),	11	ET.SINT => \|x\| fmt.formatIntBuf(buf, x, 10, false, fmt.FormatOptions{}),
12	ET.UINT => \|x\| fmt.formatIntBuf(buf, x, 10, false, 0),	12	ET.UINT => \|x\| fmt.formatIntBuf(buf, x, 10, false, fmt.FormatOptions{}),
13	};	13	};
14	}	14	}
15	};	15	};

test/stage1/behavior/new_stack_call.zig+1-1

...	@@ -1,7 +1,7 @@	...	@@ -1,7 +1,7 @@
1	const std = @import("std");	1	const std = @import("std");
2	const expect = std.testing.expect;	2	const expect = std.testing.expect;
3		3
4	var new_stack_bytes: [1024]u8 = undefined;	4	var new_stack_bytes: [1024]u8 align(16) = undefined;
5		5
6	test "calling a function with a new stack" {	6	test "calling a function with a new stack" {
7	const arg = 1234;	7	const arg = 1234;

test/stage1/behavior/void.zig+5

...	@@ -33,3 +33,8 @@ test "void optional" {	...	@@ -33,3 +33,8 @@ test "void optional" {
33	var x: ?void = {};	33	var x: ?void = {};
34	expect(x != null);	34	expect(x != null);
35	}	35	}
		36
		37	test "void array as a local variable initializer" {
		38	var x = [_]void{{}} ** 1004;
		39	var y = x[0];
		40	}

test/tests.zig+15-10

 @@ -2,6 +2,8 @@ const std = @import("std");
 const debug = std.debug;
 const warn = debug.warn;
 const build = std.build;
+pub const Target = build.Target;
+pub const CrossTarget = build.CrossTarget;
 const Buffer = std.Buffer;
 const io = std.io;
 const fs = std.fs;
 @@ -20,24 +22,18 @@ const runtime_safety = @import("runtime_safety.zig");
 const translate_c = @import("translate_c.zig");
 const gen_h = @import("gen_h.zig");
-const TestTarget = struct {
+const test_targets = [_]CrossTarget{
-    os: builtin.Os,
+    CrossTarget{
-    arch: builtin.Arch,
-    abi: builtin.Abi,
-};
-const test_targets = [_]TestTarget{
-    TestTarget{
         .os = .linux,
         .arch = .x86_64,
         .abi = .gnu,
     },
-    TestTarget{
+    CrossTarget{
         .os = .macosx,
         .arch = .x86_64,
         .abi = .gnu,
     },
-    TestTarget{
+    CrossTarget{
         .os = .windows,
         .arch = .x86_64,
         .abi = .msvc,
 @@ -568,6 +564,7 @@ pub const CompileErrorContext = struct {
         link_libc: bool,
         is_exe: bool,
         is_test: bool,
+        target: Target = .Native,
         const SourceFile = struct {
             filename: []const u8,
 @@ -655,6 +652,14 @@ pub const CompileErrorContext = struct {
             zig_args.append("--output-dir") catch unreachable;
             zig_args.append(b.pathFromRoot(b.cache_root)) catch unreachable;
+            switch (self.case.target) {
+                .Native => {},
+                .Cross => {
+                    try zig_args.append("-target");
+                    try zig_args.append(try self.case.target.zigTriple(b.allocator));
+                },
+            }
             switch (self.build_mode) {
                 Mode.Debug => {},
                 Mode.ReleaseSafe => zig_args.append("--release-safe") catch unreachable,

author	Andrew Kelley <andrew@ziglang.org> 2019-08-20 19:09:52-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-08-20 19:09:52-04:00
log	5f3d59f0ac78e01bd50419dab54d7fcbae15f17c
tree	59313f6debbbaafc18dafc5dfed6a479cede8cef
parent	c39bb3ebc49096af45f3a69d4742e5f4d50cab62
parent	3b5a8858c29582daf37856534abe150b568a7bb7
signature	Commit is signed but in an unrecognized format.

...	@@ -55,6 +55,7 @@ pub extern "c" fn fclose(stream: *FILE) c_int;	...	@@ -55,6 +55,7 @@ pub extern "c" fn fclose(stream: *FILE) c_int;
55	pub extern "c" fn fwrite(ptr: []const u8, size_of_type: usize, item_count: usize, stream: FILE) usize;	55	pub extern "c" fn fwrite(ptr: []const u8, size_of_type: usize, item_count: usize, stream: FILE) usize;
56	pub extern "c" fn fread(ptr: []u8, size_of_type: usize, item_count: usize, stream: FILE) usize;	56	pub extern "c" fn fread(ptr: []u8, size_of_type: usize, item_count: usize, stream: FILE) usize;
57		57
		58	pub extern "c" fn printf(format: [*]const u8, ...) c_int;
58	pub extern "c" fn abort() noreturn;	59	pub extern "c" fn abort() noreturn;
59	pub extern "c" fn exit(code: c_int) noreturn;	60	pub extern "c" fn exit(code: c_int) noreturn;
60	pub extern "c" fn isatty(fd: fd_t) c_int;	61	pub extern "c" fn isatty(fd: fd_t) c_int;
...	@@ -64,10 +65,12 @@ pub extern "c" fn fstat(fd: fd_t, buf: *Stat) c_int;	...	@@ -64,10 +65,12 @@ pub extern "c" fn fstat(fd: fd_t, buf: *Stat) c_int;
64	pub extern "c" fn @"fstat$INODE64"(fd: fd_t, buf: *Stat) c_int;	65	pub extern "c" fn @"fstat$INODE64"(fd: fd_t, buf: *Stat) c_int;
65	pub extern "c" fn lseek(fd: fd_t, offset: isize, whence: c_int) isize;	66	pub extern "c" fn lseek(fd: fd_t, offset: isize, whence: c_int) isize;
66	pub extern "c" fn open(path: [*]const u8, oflag: c_uint, ...) c_int;	67	pub extern "c" fn open(path: [*]const u8, oflag: c_uint, ...) c_int;
		68	pub extern "c" fn openat(fd: c_int, path: [*]const u8, oflag: c_uint, ...) c_int;
67	pub extern "c" fn raise(sig: c_int) c_int;	69	pub extern "c" fn raise(sig: c_int) c_int;
68	pub extern "c" fn read(fd: fd_t, buf: [*]u8, nbyte: usize) isize;	70	pub extern "c" fn read(fd: fd_t, buf: [*]u8, nbyte: usize) isize;
69	pub extern "c" fn pread(fd: fd_t, buf: [*]u8, nbyte: usize, offset: u64) isize;	71	pub extern "c" fn pread(fd: fd_t, buf: [*]u8, nbyte: usize, offset: u64) isize;
70	pub extern "c" fn preadv(fd: c_int, iov: [*]const iovec, iovcnt: c_uint, offset: usize) isize;	72	pub extern "c" fn preadv(fd: c_int, iov: [*]const iovec, iovcnt: c_uint, offset: usize) isize;
		73	pub extern "c" fn writev(fd: c_int, iov: [*]const iovec_const, iovcnt: c_uint) isize;
71	pub extern "c" fn pwritev(fd: c_int, iov: [*]const iovec_const, iovcnt: c_uint, offset: usize) isize;	74	pub extern "c" fn pwritev(fd: c_int, iov: [*]const iovec_const, iovcnt: c_uint, offset: usize) isize;
72	pub extern "c" fn stat(noalias path: []const u8, noalias buf: Stat) c_int;	75	pub extern "c" fn stat(noalias path: []const u8, noalias buf: Stat) c_int;
73	pub extern "c" fn write(fd: fd_t, buf: [*]const u8, nbyte: usize) isize;	76	pub extern "c" fn write(fd: fd_t, buf: [*]const u8, nbyte: usize) isize;
...	@@ -112,7 +115,6 @@ pub extern "c" fn accept4(sockfd: fd_t, addr: sockaddr, addrlen: socklen_t, fl	...	@@ -112,7 +115,6 @@ pub extern "c" fn accept4(sockfd: fd_t, addr: sockaddr, addrlen: socklen_t, fl
112	pub extern "c" fn getsockopt(sockfd: fd_t, level: c_int, optname: c_int, optval: c_void, optlen: socklen_t) c_int;	115	pub extern "c" fn getsockopt(sockfd: fd_t, level: c_int, optname: c_int, optval: c_void, optlen: socklen_t) c_int;
113	pub extern "c" fn kill(pid: pid_t, sig: c_int) c_int;	116	pub extern "c" fn kill(pid: pid_t, sig: c_int) c_int;
114	pub extern "c" fn getdirentries(fd: fd_t, buf_ptr: []u8, nbytes: usize, basep: i64) isize;	117	pub extern "c" fn getdirentries(fd: fd_t, buf_ptr: []u8, nbytes: usize, basep: i64) isize;
115	pub extern "c" fn openat(fd: c_int, path: [*]const u8, flags: c_int) c_int;
116	pub extern "c" fn setgid(ruid: c_uint, euid: c_uint) c_int;	118	pub extern "c" fn setgid(ruid: c_uint, euid: c_uint) c_int;
117	pub extern "c" fn setuid(uid: c_uint) c_int;	119	pub extern "c" fn setuid(uid: c_uint) c_int;
118	pub extern "c" fn clock_gettime(clk_id: c_int, tp: *timespec) c_int;	120	pub extern "c" fn clock_gettime(clk_id: c_int, tp: *timespec) c_int;

Merge branch 'master' into llvm9