Commit 5eaead6a56ed95c200e249737c4ecf3c7cacf794 | zig

author	Andrew Kelley <andrew@ziglang.org> 2019-03-25 12:55:45-04:00
committer	Andrew Kelley <andrew@ziglang.org> 2019-03-25 12:55:45-04:00
log	5eaead6a56ed95c200e249737c4ecf3c7cacf794
tree	70fe5c0238d6f1d72fc8504a4aaec710f059db37
parent	3306e43984a8b17472ecc4b13a2f2815d6630eef
signature	Commit is signed but in an unrecognized format.

implement allowzero pointer attribute

closes #1953

only needed for freestanding targets.

also adds safety for `@intToPtr` when the address is zero.

18 files changed, 225 insertions(+), 78 deletions(-)

doc
- docgen.zig
- langref.html.in
src
std
- zig
test
- compile_errors.zig
- runtime_safety.zig
- stage1
  - behavior
    pointers.zig

doc/docgen.zig+1

...	@@ -779,6 +779,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok	...	@@ -779,6 +779,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
779	std.zig.Token.Id.Keyword_use,	779	std.zig.Token.Id.Keyword_use,
780	std.zig.Token.Id.Keyword_var,	780	std.zig.Token.Id.Keyword_var,
781	std.zig.Token.Id.Keyword_volatile,	781	std.zig.Token.Id.Keyword_volatile,
		782	std.zig.Token.Id.Keyword_allowzero,
782	std.zig.Token.Id.Keyword_while,	783	std.zig.Token.Id.Keyword_while,
783	=> {	784	=> {
784	try out.write("<span class=\"tok-kw\">");	785	try out.write("<span class=\"tok-kw\">");

doc/langref.html.in+36-8

...	@@ -1721,7 +1721,7 @@ test "comptime @intToPtr" {	...	@@ -1721,7 +1721,7 @@ test "comptime @intToPtr" {
1721	}	1721	}
1722	}	1722	}
1723	{#code_end#}	1723	{#code_end#}
1724	{#see_also\|Optional Pointers\|@intToPtr\|@ptrToInt#}	1724	{#see_also\|Optional Pointers\|@intToPtr\|@ptrToInt\|C Pointers\|Pointers to Zero Bit Types#}
1725	{#header_open\|volatile#}	1725	{#header_open\|volatile#}
1726	<p>Loads and stores are assumed to not have side effects. If a given load or store	1726	<p>Loads and stores are assumed to not have side effects. If a given load or store
1727	should have side effects, such as Memory Mapped Input/Output (MMIO), use {#syntax#}volatile{#endsyntax#}.	1727	should have side effects, such as Memory Mapped Input/Output (MMIO), use {#syntax#}volatile{#endsyntax#}.
...	@@ -1850,7 +1850,25 @@ fn foo(bytes: []u8) u32 {	...	@@ -1850,7 +1850,25 @@ fn foo(bytes: []u8) u32 {
1850	}	1850	}
1851	{#code_end#}	1851	{#code_end#}
1852	{#header_close#}	1852	{#header_close#}
1853	{#see_also\|C Pointers\|Pointers to Zero Bit Types#}	1853
		1854	{#header_open\|allowzero#}
		1855	<p>
		1856	This pointer attribute allows a pointer to have address zero. This is only ever needed on the
		1857	freestanding OS target, where the address zero is mappable. In this code example, if the pointer
		1858	did not have the {#syntax#}allowzero{#endsyntax#} attribute, this would be a
		1859	{#link\|Pointer Cast Invalid Null#} panic:
		1860	</p>
		1861	{#code_begin\|test\|allowzero#}
		1862	const std = @import("std");
		1863	const assert = std.debug.assert;
		1864
		1865	test "allowzero" {
		1866	var zero: usize = 0;
		1867	var ptr = @intToPtr(*allowzero i32, zero);
		1868	assert(@ptrToInt(ptr) == 0);
		1869	}
		1870	{#code_end#}
		1871	{#header_close#}
1854	{#header_close#}	1872	{#header_close#}
1855		1873
1856	{#header_open\|Slices#}	1874	{#header_open\|Slices#}
...	@@ -6635,9 +6653,13 @@ fn add(a: i32, b: i32) i32 { return a + b; }	...	@@ -6635,9 +6653,13 @@ fn add(a: i32, b: i32) i32 { return a + b; }
6635	{#header_close#}	6653	{#header_close#}
6636		6654
6637	{#header_open\|@intToPtr#}	6655	{#header_open\|@intToPtr#}
6638	<pre>{#syntax#}@intToPtr(comptime DestType: type, int: usize) DestType{#endsyntax#}</pre>	6656	<pre>{#syntax#}@intToPtr(comptime DestType: type, address: usize) DestType{#endsyntax#}</pre>
		6657	<p>
		6658	Converts an integer to a {#link\|pointer\|Pointers#}. To convert the other way, use {#link\|@ptrToInt#}.
		6659	</p>
6639	<p>	6660	<p>
6640	Converts an integer to a pointer. To convert the other way, use {#link\|@ptrToInt#}.	6661	If the destination pointer type does not allow address zero and {#syntax#}address{#endsyntax#}
		6662	is zero, this invokes safety-checked {#link\|Undefined Behavior#}.
6641	</p>	6663	</p>
6642	{#header_close#}	6664	{#header_close#}
6643		6665
...	@@ -8128,6 +8150,11 @@ fn bar(f: *Foo) void {	...	@@ -8128,6 +8150,11 @@ fn bar(f: *Foo) void {
8128	{#header_close#}	8150	{#header_close#}
8129		8151
8130	{#header_open\|Pointer Cast Invalid Null#}	8152	{#header_open\|Pointer Cast Invalid Null#}
		8153	<p>
		8154	This happens when casting a pointer with the address 0 to a pointer which may not have the address 0.
		8155	For example, {#link\|C Pointers#}, {#link\|Optional Pointers#}, and {#link\|allowzero#} pointers
		8156	allow address zero, but normal {#link\|Pointers#} do not.
		8157	</p>
8131	<p>At compile-time:</p>	8158	<p>At compile-time:</p>
8132	{#code_begin\|test_err\|null pointer casted to type#}	8159	{#code_begin\|test_err\|null pointer casted to type#}
8133	comptime {	8160	comptime {
...	@@ -8988,7 +9015,7 @@ Available libcs:	...	@@ -8988,7 +9015,7 @@ Available libcs:
8988	<ul>	9015	<ul>
8989	<li>Linux x86_64</li>	9016	<li>Linux x86_64</li>
8990	<li>Windows x86_64</li>	9017	<li>Windows x86_64</li>
8991	<li>MacOS x86_64</li>	9018	<li>macOS x86_64</li>
8992	</ul>	9019	</ul>
8993	{#header_close#}	9020	{#header_close#}
8994	{#header_open\|Style Guide#}	9021	{#header_open\|Style Guide#}
...	@@ -9412,8 +9439,8 @@ PrefixOp	...	@@ -9412,8 +9439,8 @@ PrefixOp
9412	PrefixTypeOp	9439	PrefixTypeOp
9413	<- QUESTIONMARK	9440	<- QUESTIONMARK
9414	/ KEYWORD_promise MINUSRARROW	9441	/ KEYWORD_promise MINUSRARROW
9415	/ ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile)*	9442	/ ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
9416	/ PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile)*	9443	/ PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile / KEYWORD_allowzero)*
9417		9444
9418	SuffixOp	9445	SuffixOp
9419	<- LBRACKET Expr (DOT2 Expr?)? RBRACKET	9446	<- LBRACKET Expr (DOT2 Expr?)? RBRACKET
...	@@ -9564,6 +9591,7 @@ TILDE <- '~' skip	...	@@ -9564,6 +9591,7 @@ TILDE <- '~' skip
9564		9591
9565	end_of_word <- ![a-zA-Z0-9_] skip	9592	end_of_word <- ![a-zA-Z0-9_] skip
9566	KEYWORD_align <- 'align' end_of_word	9593	KEYWORD_align <- 'align' end_of_word
		9594	KEYWORD_allowzero <- 'allowzero' end_of_word
9567	KEYWORD_and <- 'and' end_of_word	9595	KEYWORD_and <- 'and' end_of_word
9568	KEYWORD_anyerror <- 'anyerror' end_of_word	9596	KEYWORD_anyerror <- 'anyerror' end_of_word
9569	KEYWORD_asm <- 'asm' end_of_word	9597	KEYWORD_asm <- 'asm' end_of_word
...	@@ -9614,7 +9642,7 @@ KEYWORD_var <- 'var' end_of_word	...	@@ -9614,7 +9642,7 @@ KEYWORD_var <- 'var' end_of_word
9614	KEYWORD_volatile <- 'volatile' end_of_word	9642	KEYWORD_volatile <- 'volatile' end_of_word
9615	KEYWORD_while <- 'while' end_of_word	9643	KEYWORD_while <- 'while' end_of_word
9616		9644
9617	keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyerror / KEYWORD_asm	9645	keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_allowzero / KEYWORD_anyerror / KEYWORD_asm
9618	/ KEYWORD_async / KEYWORD_await / KEYWORD_break / KEYWORD_cancel	9646	/ KEYWORD_async / KEYWORD_await / KEYWORD_break / KEYWORD_cancel
9619	/ KEYWORD_catch / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue	9647	/ KEYWORD_catch / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue
9620	/ KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer	9648	/ KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer

src/all_types.hpp+2-2

...	@@ -2668,7 +2668,7 @@ struct IrInstructionPtrType {	...	@@ -2668,7 +2668,7 @@ struct IrInstructionPtrType {
2668	PtrLen ptr_len;	2668	PtrLen ptr_len;
2669	bool is_const;	2669	bool is_const;
2670	bool is_volatile;	2670	bool is_volatile;
2671	bool allow_zero;	2671	bool is_allow_zero;
2672	};	2672	};
2673		2673
2674	struct IrInstructionPromiseType {	2674	struct IrInstructionPromiseType {
...	@@ -2684,7 +2684,7 @@ struct IrInstructionSliceType {	...	@@ -2684,7 +2684,7 @@ struct IrInstructionSliceType {
2684	IrInstruction *child_type;	2684	IrInstruction *child_type;
2685	bool is_const;	2685	bool is_const;
2686	bool is_volatile;	2686	bool is_volatile;
2687	bool allow_zero;	2687	bool is_allow_zero;
2688	};	2688	};
2689		2689
2690	struct IrInstructionGlobalAsm {	2690	struct IrInstructionGlobalAsm {

src/analyze.cpp+11-13

src/analyze.hpp+3-1

 @@ -18,7 +18,9 @@ void emit_error_notes_for_ref_stack(CodeGen *g, ErrorMsg *msg);
 ZigType *new_type_table_entry(ZigTypeId id);
 ZigType *get_pointer_to_type(CodeGen *g, ZigType *child_type, bool is_const);
 ZigType *get_pointer_to_type_extra(CodeGen *g, ZigType *child_type, bool is_const,
-        bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count);
+        bool is_volatile, PtrLen ptr_len,
+        uint32_t byte_alignment, uint32_t bit_offset, uint32_t unaligned_bit_count,
+        bool allow_zero);
 uint64_t type_size(CodeGen *g, ZigType *type_entry);
 uint64_t type_size_bits(CodeGen *g, ZigType *type_entry);
 ZigType *get_int_type(CodeGen *g, bool is_signed, uint32_t size_in_bits);

src/codegen.cpp+22-9

src/ir.cpp+71-43

src/parser.cpp+12-1

 @@ -2530,6 +2530,12 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
     if (array != nullptr) {
         assert(array->type == NodeTypeArrayType);
         while (true) {
+            Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
+            if (allowzero_token != nullptr) {
+                array->data.array_type.allow_zero_token = allowzero_token;
+                continue;
+            }
             AstNode *align_expr = ast_parse_byte_align(pc);
             if (align_expr != nullptr) {
                 array->data.array_type.align_expr = align_expr;
 @@ -2545,7 +2551,6 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
                 array->data.array_type.is_volatile = true;
                 continue;
             }
             break;
         }
 @@ -2560,6 +2565,12 @@ static AstNode *ast_parse_prefix_type_op(ParseContext *pc) {
         if (child == nullptr)
             child = ptr;
         while (true) {
+            Token *allowzero_token = eat_token_if(pc, TokenIdKeywordAllowZero);
+            if (allowzero_token != nullptr) {
+                child->data.pointer_type.allow_zero_token = allowzero_token;
+                continue;
+            }
             if (eat_token_if(pc, TokenIdKeywordAlign) != nullptr) {
                 expect_token(pc, TokenIdLParen);
                 AstNode *align_expr = ast_parse_expr(pc);

src/tokenizer.cpp+2

src/tokenizer.hpp+2-1

...	@@ -50,6 +50,7 @@ enum TokenId {	...	@@ -50,6 +50,7 @@ enum TokenId {
50	TokenIdFloatLiteral,	50	TokenIdFloatLiteral,
51	TokenIdIntLiteral,	51	TokenIdIntLiteral,
52	TokenIdKeywordAlign,	52	TokenIdKeywordAlign,
		53	TokenIdKeywordAllowZero,
53	TokenIdKeywordAnd,	54	TokenIdKeywordAnd,
54	TokenIdKeywordAnyerror,	55	TokenIdKeywordAnyerror,
55	TokenIdKeywordAsm,	56	TokenIdKeywordAsm,
...	@@ -73,6 +74,7 @@ enum TokenId {	...	@@ -73,6 +74,7 @@ enum TokenId {
73	TokenIdKeywordFor,	74	TokenIdKeywordFor,
74	TokenIdKeywordIf,	75	TokenIdKeywordIf,
75	TokenIdKeywordInline,	76	TokenIdKeywordInline,
		77	TokenIdKeywordLinkSection,
76	TokenIdKeywordNakedCC,	78	TokenIdKeywordNakedCC,
77	TokenIdKeywordNoAlias,	79	TokenIdKeywordNoAlias,
78	TokenIdKeywordNull,	80	TokenIdKeywordNull,
...	@@ -83,7 +85,6 @@ enum TokenId {	...	@@ -83,7 +85,6 @@ enum TokenId {
83	TokenIdKeywordPub,	85	TokenIdKeywordPub,
84	TokenIdKeywordResume,	86	TokenIdKeywordResume,
85	TokenIdKeywordReturn,	87	TokenIdKeywordReturn,
86	TokenIdKeywordLinkSection,
87	TokenIdKeywordStdcallCC,	88	TokenIdKeywordStdcallCC,
88	TokenIdKeywordStruct,	89	TokenIdKeywordStruct,
89	TokenIdKeywordSuspend,	90	TokenIdKeywordSuspend,

std/zig/ast.zig+5

std/zig/parse.zig+11

 @@ -1688,6 +1688,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
                             .align_info = null,
                             .const_token = null,
                             .volatile_token = null,
+                            .allowzero_token = null,
                         },
                     };
                     stack.append(State{ .TypeExprBegin = OptionalCtx{ .Required = &node.rhs } }) catch unreachable;
 @@ -1743,6 +1744,15 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
                         addr_of_info.volatile_token = token_index;
                         continue;
                     },
+                    Token.Id.Keyword_allowzero => {
+                        stack.append(state) catch unreachable;
+                        if (addr_of_info.allowzero_token != null) {
+                            ((try tree.errors.addOne())).* = Error{ .ExtraAllowZeroQualifier = Error.ExtraAllowZeroQualifier{ .token = token_index } };
+                            return tree;
+                        }
+                        addr_of_info.allowzero_token = token_index;
+                        continue;
+                    },
                     else => {
                         prevToken(&tok_it, &tree);
                         continue;
 @@ -3552,6 +3562,7 @@ fn tokenIdToPrefixOp(id: Token.Id) ?ast.Node.PrefixOp.Op {
                 .align_info = null,
                 .const_token = null,
                 .volatile_token = null,
+                .allowzero_token = null,
             },
         },
         Token.Id.QuestionMark => ast.Node.PrefixOp.Op{ .OptionalType = void{} },

std/zig/parser_test.zig+7

...	@@ -1,3 +1,10 @@	...	@@ -1,3 +1,10 @@
		1	test "zig fmt: allowzero pointer" {
		2	try testCanonical(
		3	\\const T = [*]allowzero const u8;
		4	\\
		5	);
		6	}
		7
1	test "zig fmt: enum literal" {	8	test "zig fmt: enum literal" {
2	try testCanonical(	9	try testCanonical(
3	\\const x = .hi;	10	\\const x = .hi;

std/zig/render.zig+6

 @@ -379,6 +379,9 @@ fn renderExpression(
                         else => usize(0),
                     };
                     try renderTokenOffset(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None, star_offset); // *
+                    if (ptr_info.allowzero_token) |allowzero_token| {
+                        try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
+                    }
                     if (ptr_info.align_info) |align_info| {
                         const lparen_token = tree.prevToken(align_info.node.firstToken());
                         const align_token = tree.prevToken(lparen_token);
 @@ -416,6 +419,9 @@ fn renderExpression(
                     try renderToken(tree, stream, prefix_op_node.op_token, indent, start_col, Space.None); // [
                     try renderToken(tree, stream, tree.nextToken(prefix_op_node.op_token), indent, start_col, Space.None); // ]
+                    if (ptr_info.allowzero_token) |allowzero_token| {
+                        try renderToken(tree, stream, allowzero_token, indent, start_col, Space.Space); // allowzero
+                    }
                     if (ptr_info.align_info) |align_info| {
                         const lparen_token = tree.prevToken(align_info.node.firstToken());
                         const align_token = tree.prevToken(lparen_token);

std/zig/tokenizer.zig+2

...	@@ -13,6 +13,7 @@ pub const Token = struct {	...	@@ -13,6 +13,7 @@ pub const Token = struct {
13		13
14	pub const keywords = []Keyword{	14	pub const keywords = []Keyword{
15	Keyword{ .bytes = "align", .id = Id.Keyword_align },	15	Keyword{ .bytes = "align", .id = Id.Keyword_align },
		16	Keyword{ .bytes = "allowzero", .id = Id.Keyword_allowzero },
16	Keyword{ .bytes = "and", .id = Id.Keyword_and },	17	Keyword{ .bytes = "and", .id = Id.Keyword_and },
17	Keyword{ .bytes = "anyerror", .id = Id.Keyword_anyerror },	18	Keyword{ .bytes = "anyerror", .id = Id.Keyword_anyerror },
18	Keyword{ .bytes = "asm", .id = Id.Keyword_asm },	19	Keyword{ .bytes = "asm", .id = Id.Keyword_asm },
...	@@ -143,6 +144,7 @@ pub const Token = struct {	...	@@ -143,6 +144,7 @@ pub const Token = struct {
143	BracketStarCBracket,	144	BracketStarCBracket,
144	ShebangLine,	145	ShebangLine,
145	Keyword_align,	146	Keyword_align,
		147	Keyword_allowzero,
146	Keyword_and,	148	Keyword_and,
147	Keyword_anyerror,	149	Keyword_anyerror,
148	Keyword_asm,	150	Keyword_asm,

test/compile_errors.zig+9

...	@@ -2,6 +2,15 @@ const tests = @import("tests.zig");	...	@@ -2,6 +2,15 @@ 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.add(
		6	"@ptrToInt 0 to non optional pointer",
		7	\\export fn entry() void {
		8	\\ var b = @intToPtr(*i32, 0);
		9	\\}
		10	,
		11	"tmp.zig:2:13: error: pointer type '*i32' does not allow address zero",
		12	);
		13
5	cases.add(	14	cases.add(
6	"cast enum literal to enum but it doesn't match",	15	"cast enum literal to enum but it doesn't match",
7	\\const Foo = enum {	16	\\const Foo = enum {

test/runtime_safety.zig+10

...	@@ -1,6 +1,16 @@	...	@@ -1,6 +1,16 @@
1	const tests = @import("tests.zig");	1	const tests = @import("tests.zig");
2		2
3	pub fn addCases(cases: *tests.CompareOutputContext) void {	3	pub fn addCases(cases: *tests.CompareOutputContext) void {
		4	cases.addRuntimeSafety("@ptrToInt address zero to non-optional pointer",
		5	\\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
		6	\\ @import("std").os.exit(126);
		7	\\}
		8	\\pub fn main() void {
		9	\\ var zero: usize = 0;
		10	\\ var b = @intToPtr(*i32, zero);
		11	\\}
		12	);
		13
4	cases.addRuntimeSafety("pointer casting null to non-optional pointer",	14	cases.addRuntimeSafety("pointer casting null to non-optional pointer",
5	\\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {	15	\\pub fn panic(message: []const u8, stack_trace: ?*@import("builtin").StackTrace) noreturn {
6	\\ @import("std").os.exit(126);	16	\\ @import("std").os.exit(126);

test/stage1/behavior/pointers.zig+13

...	@@ -137,3 +137,16 @@ test "compare equality of optional and non-optional pointer" {	...	@@ -137,3 +137,16 @@ test "compare equality of optional and non-optional pointer" {
137	expect(a == b);	137	expect(a == b);
138	expect(b == a);	138	expect(b == a);
139	}	139	}
		140
		141	test "allowzero pointer and slice" {
		142	var ptr = @intToPtr([*]allowzero i32, 0);
		143	var opt_ptr: ?[*]allowzero i32 = ptr;
		144	expect(opt_ptr != null);
		145	expect(@ptrToInt(ptr) == 0);
		146	var slice = ptr[0..10];
		147	expect(@typeOf(slice) == []allowzero i32);
		148	expect(@ptrToInt(&slice[5]) == 20);
		149
		150	expect(@typeInfo(@typeOf(ptr)).Pointer.is_allowzero);
		151	expect(@typeInfo(@typeOf(slice)).Pointer.is_allowzero);
		152	}

...	@@ -418,11 +418,9 @@ static const char *ptr_len_to_star_str(PtrLen ptr_len) {	...	@@ -418,11 +418,9 @@ static const char *ptr_len_to_star_str(PtrLen ptr_len) {
418		418
419	ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_const,	419	ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_const,
420	bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment,	420	bool is_volatile, PtrLen ptr_len, uint32_t byte_alignment,
421	uint32_t bit_offset_in_host, uint32_t host_int_bytes)	421	uint32_t bit_offset_in_host, uint32_t host_int_bytes, bool allow_zero)
422	{	422	{
423	// TODO when implementing https://github.com/ziglang/zig/issues/1953	423	assert(ptr_len != PtrLenC \|\| allow_zero);
424	// move this to a parameter
425	bool allow_zero = (ptr_len == PtrLenC);
426	assert(!type_is_invalid(child_type));	424	assert(!type_is_invalid(child_type));
427	assert(ptr_len == PtrLenSingle \|\| child_type->id != ZigTypeIdOpaque);	425	assert(ptr_len == PtrLenSingle \|\| child_type->id != ZigTypeIdOpaque);
428		426
...	@@ -505,7 +503,7 @@ ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_cons	...	@@ -505,7 +503,7 @@ ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_cons
505	bit_offset_in_host != 0 \|\| allow_zero)	503	bit_offset_in_host != 0 \|\| allow_zero)
506	{	504	{
507	ZigType *peer_type = get_pointer_to_type_extra(g, child_type, false, false,	505	ZigType *peer_type = get_pointer_to_type_extra(g, child_type, false, false,
508	PtrLenSingle, 0, 0, host_int_bytes);	506	PtrLenSingle, 0, 0, host_int_bytes, false);
509	entry->type_ref = peer_type->type_ref;	507	entry->type_ref = peer_type->type_ref;
510	entry->di_type = peer_type->di_type;	508	entry->di_type = peer_type->di_type;
511	} else {	509	} else {
...	@@ -548,7 +546,7 @@ ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_cons	...	@@ -548,7 +546,7 @@ ZigType get_pointer_to_type_extra(CodeGen g, ZigType *child_type, bool is_cons
548	}	546	}
549		547
550	ZigType get_pointer_to_type(CodeGen g, ZigType *child_type, bool is_const) {	548	ZigType get_pointer_to_type(CodeGen g, ZigType *child_type, bool is_const) {
551	return get_pointer_to_type_extra(g, child_type, is_const, false, PtrLenSingle, 0, 0, 0);	549	return get_pointer_to_type_extra(g, child_type, is_const, false, PtrLenSingle, 0, 0, 0, false);
552	}	550	}
553		551
554	ZigType get_promise_frame_type(CodeGen g, ZigType *return_type) {	552	ZigType get_promise_frame_type(CodeGen g, ZigType *return_type) {
...	@@ -857,7 +855,7 @@ ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {	...	@@ -857,7 +855,7 @@ ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {
857	ptr_type->data.pointer.explicit_alignment != 0 \|\| ptr_type->data.pointer.allow_zero)	855	ptr_type->data.pointer.explicit_alignment != 0 \|\| ptr_type->data.pointer.allow_zero)
858	{	856	{
859	ZigType *peer_ptr_type = get_pointer_to_type_extra(g, child_type, false, false,	857	ZigType *peer_ptr_type = get_pointer_to_type_extra(g, child_type, false, false,
860	PtrLenUnknown, 0, 0, 0);	858	PtrLenUnknown, 0, 0, 0, false);
861	ZigType *peer_slice_type = get_slice_type(g, peer_ptr_type);	859	ZigType *peer_slice_type = get_slice_type(g, peer_ptr_type);
862		860
863	slice_type_common_init(g, ptr_type, entry);	861	slice_type_common_init(g, ptr_type, entry);
...	@@ -881,10 +879,10 @@ ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {	...	@@ -881,10 +879,10 @@ ZigType get_slice_type(CodeGen g, ZigType *ptr_type) {
881	{	879	{
882	ZigType *grand_child_type = child_ptr_type->data.pointer.child_type;	880	ZigType *grand_child_type = child_ptr_type->data.pointer.child_type;
883	ZigType *bland_child_ptr_type = get_pointer_to_type_extra(g, grand_child_type, false, false,	881	ZigType *bland_child_ptr_type = get_pointer_to_type_extra(g, grand_child_type, false, false,
884	PtrLenUnknown, 0, 0, 0);	882	PtrLenUnknown, 0, 0, 0, false);
885	ZigType *bland_child_slice = get_slice_type(g, bland_child_ptr_type);	883	ZigType *bland_child_slice = get_slice_type(g, bland_child_ptr_type);
886	ZigType *peer_ptr_type = get_pointer_to_type_extra(g, bland_child_slice, false, false,	884	ZigType *peer_ptr_type = get_pointer_to_type_extra(g, bland_child_slice, false, false,
887	PtrLenUnknown, 0, 0, 0);	885	PtrLenUnknown, 0, 0, 0, false);
888	ZigType *peer_slice_type = get_slice_type(g, peer_ptr_type);	886	ZigType *peer_slice_type = get_slice_type(g, peer_ptr_type);
889		887
890	entry->type_ref = peer_slice_type->type_ref;	888	entry->type_ref = peer_slice_type->type_ref;
...	@@ -1419,7 +1417,7 @@ static bool analyze_const_align(CodeGen g, Scope scope, AstNode *node, uint32_	...	@@ -1419,7 +1417,7 @@ static bool analyze_const_align(CodeGen g, Scope scope, AstNode *node, uint32_
1419		1417
1420	static bool analyze_const_string(CodeGen g, Scope scope, AstNode node, Buf *out_buffer) {	1418	static bool analyze_const_string(CodeGen g, Scope scope, AstNode node, Buf *out_buffer) {
1421	ZigType *ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,	1419	ZigType *ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
1422	PtrLenUnknown, 0, 0, 0);	1420	PtrLenUnknown, 0, 0, 0, false);
1423	ZigType *str_type = get_slice_type(g, ptr_type);	1421	ZigType *str_type = get_slice_type(g, ptr_type);
1424	ConstExprValue *result_val = analyze_const_value(g, scope, node, str_type, nullptr);	1422	ConstExprValue *result_val = analyze_const_value(g, scope, node, str_type, nullptr);
1425	if (type_is_invalid(result_val->type))	1423	if (type_is_invalid(result_val->type))
...	@@ -5336,7 +5334,7 @@ void init_const_c_str_lit(CodeGen g, ConstExprValue const_val, Buf *str) {	...	@@ -5336,7 +5334,7 @@ void init_const_c_str_lit(CodeGen g, ConstExprValue const_val, Buf *str) {
5336	const_val->special = ConstValSpecialStatic;	5334	const_val->special = ConstValSpecialStatic;
5337	// TODO make this `[]null u8` instead of `[]u8`	5335	// TODO make this `[]null u8` instead of `[]u8`
5338	const_val->type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,	5336	const_val->type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
5339	PtrLenUnknown, 0, 0, 0);	5337	PtrLenUnknown, 0, 0, 0, false);
5340	const_val->data.x_ptr.special = ConstPtrSpecialBaseArray;	5338	const_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
5341	const_val->data.x_ptr.data.base_array.array_val = array_val;	5339	const_val->data.x_ptr.data.base_array.array_val = array_val;
5342	const_val->data.x_ptr.data.base_array.elem_index = 0;	5340	const_val->data.x_ptr.data.base_array.elem_index = 0;
...	@@ -5481,7 +5479,7 @@ void init_const_slice(CodeGen g, ConstExprValue const_val, ConstExprValue *arr	...	@@ -5481,7 +5479,7 @@ void init_const_slice(CodeGen g, ConstExprValue const_val, ConstExprValue *arr
5481	assert(array_val->type->id == ZigTypeIdArray);	5479	assert(array_val->type->id == ZigTypeIdArray);
5482		5480
5483	ZigType *ptr_type = get_pointer_to_type_extra(g, array_val->type->data.array.child_type,	5481	ZigType *ptr_type = get_pointer_to_type_extra(g, array_val->type->data.array.child_type,
5484	is_const, false, PtrLenUnknown, 0, 0, 0);	5482	is_const, false, PtrLenUnknown, 0, 0, 0, false);
5485		5483
5486	const_val->special = ConstValSpecialStatic;	5484	const_val->special = ConstValSpecialStatic;
5487	const_val->type = get_slice_type(g, ptr_type);	5485	const_val->type = get_slice_type(g, ptr_type);
...	@@ -5506,7 +5504,7 @@ void init_const_ptr_array(CodeGen g, ConstExprValue const_val, ConstExprValue	...	@@ -5506,7 +5504,7 @@ void init_const_ptr_array(CodeGen g, ConstExprValue const_val, ConstExprValue
5506		5504
5507	const_val->special = ConstValSpecialStatic;	5505	const_val->special = ConstValSpecialStatic;
5508	const_val->type = get_pointer_to_type_extra(g, child_type, is_const, false,	5506	const_val->type = get_pointer_to_type_extra(g, child_type, is_const, false,
5509	ptr_len, 0, 0, 0);	5507	ptr_len, 0, 0, 0, false);
5510	const_val->data.x_ptr.special = ConstPtrSpecialBaseArray;	5508	const_val->data.x_ptr.special = ConstPtrSpecialBaseArray;
5511	const_val->data.x_ptr.data.base_array.array_val = array_val;	5509	const_val->data.x_ptr.data.base_array.array_val = array_val;
5512	const_val->data.x_ptr.data.base_array.elem_index = elem_index;	5510	const_val->data.x_ptr.data.base_array.elem_index = elem_index;

...	@@ -956,7 +956,7 @@ static LLVMValueRef get_panic_msg_ptr_val(CodeGen *g, PanicMsgId msg_id) {	...	@@ -956,7 +956,7 @@ static LLVMValueRef get_panic_msg_ptr_val(CodeGen *g, PanicMsgId msg_id) {
956	}	956	}
957		957
958	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,	958	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
959	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);	959	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0, false);
960	ZigType *str_type = get_slice_type(g, u8_ptr_type);	960	ZigType *str_type = get_slice_type(g, u8_ptr_type);
961	return LLVMConstBitCast(val->global_refs->llvm_global, LLVMPointerType(str_type->type_ref, 0));	961	return LLVMConstBitCast(val->global_refs->llvm_global, LLVMPointerType(str_type->type_ref, 0));
962	}	962	}
...	@@ -1515,7 +1515,7 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {	...	@@ -1515,7 +1515,7 @@ static LLVMValueRef get_safety_crash_err_fn(CodeGen *g) {
1515		1515
1516		1516
1517	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,	1517	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
1518	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);	1518	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0, false);
1519	ZigType *str_type = get_slice_type(g, u8_ptr_type);	1519	ZigType *str_type = get_slice_type(g, u8_ptr_type);
1520	LLVMValueRef global_slice_fields[] = {	1520	LLVMValueRef global_slice_fields[] = {
1521	full_buf_ptr,	1521	full_buf_ptr,
...	@@ -3103,6 +3103,18 @@ static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutable executa	...	@@ -3103,6 +3103,18 @@ static LLVMValueRef ir_render_widen_or_shorten(CodeGen g, IrExecutable executa
3103	static LLVMValueRef ir_render_int_to_ptr(CodeGen g, IrExecutable executable, IrInstructionIntToPtr *instruction) {	3103	static LLVMValueRef ir_render_int_to_ptr(CodeGen g, IrExecutable executable, IrInstructionIntToPtr *instruction) {
3104	ZigType *wanted_type = instruction->base.value.type;	3104	ZigType *wanted_type = instruction->base.value.type;
3105	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);	3105	LLVMValueRef target_val = ir_llvm_value(g, instruction->target);
		3106	if (!ptr_allows_addr_zero(wanted_type) && ir_want_runtime_safety(g, &instruction->base)) {
		3107	LLVMValueRef zero = LLVMConstNull(LLVMTypeOf(target_val));
		3108	LLVMValueRef is_zero_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, target_val, zero, "");
		3109	LLVMBasicBlockRef bad_block = LLVMAppendBasicBlock(g->cur_fn_val, "PtrToIntBad");
		3110	LLVMBasicBlockRef ok_block = LLVMAppendBasicBlock(g->cur_fn_val, "PtrToIntOk");
		3111	LLVMBuildCondBr(g->builder, is_zero_bit, bad_block, ok_block);
		3112
		3113	LLVMPositionBuilderAtEnd(g->builder, bad_block);
		3114	gen_safety_crash(g, PanicMsgIdPtrCastNull);
		3115
		3116	LLVMPositionBuilderAtEnd(g->builder, ok_block);
		3117	}
3106	return LLVMBuildIntToPtr(g->builder, target_val, wanted_type->type_ref, "");	3118	return LLVMBuildIntToPtr(g->builder, target_val, wanted_type->type_ref, "");
3107	}	3119	}
3108		3120
...	@@ -3270,7 +3282,7 @@ static LLVMValueRef ir_render_decl_var(CodeGen g, IrExecutable executable,	...	@@ -3270,7 +3282,7 @@ static LLVMValueRef ir_render_decl_var(CodeGen g, IrExecutable executable,
3270		3282
3271	if (have_init_expr) {	3283	if (have_init_expr) {
3272	ZigType *var_ptr_type = get_pointer_to_type_extra(g, var->var_type, false, false,	3284	ZigType *var_ptr_type = get_pointer_to_type_extra(g, var->var_type, false, false,
3273	PtrLenSingle, var->align_bytes, 0, 0);	3285	PtrLenSingle, var->align_bytes, 0, 0, false);
3274	LLVMValueRef llvm_init_val = ir_llvm_value(g, init_value);	3286	LLVMValueRef llvm_init_val = ir_llvm_value(g, init_value);
3275	gen_assign_raw(g, var->value_ref, var_ptr_type, llvm_init_val);	3287	gen_assign_raw(g, var->value_ref, var_ptr_type, llvm_init_val);
3276	} else if (ir_want_runtime_safety(g, &decl_var_instruction->base)) {	3288	} else if (ir_want_runtime_safety(g, &decl_var_instruction->base)) {
...	@@ -4160,7 +4172,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen g, ZigType enum_type) {	...	@@ -4160,7 +4172,7 @@ static LLVMValueRef get_enum_tag_name_function(CodeGen g, ZigType enum_type) {
4160	return enum_type->data.enumeration.name_function;	4172	return enum_type->data.enumeration.name_function;
4161		4173
4162	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,	4174	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,
4163	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);	4175	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0, false);
4164	ZigType *u8_slice_type = get_slice_type(g, u8_ptr_type);	4176	ZigType *u8_slice_type = get_slice_type(g, u8_ptr_type);
4165	ZigType *tag_int_type = enum_type->data.enumeration.tag_int_type;	4177	ZigType *tag_int_type = enum_type->data.enumeration.tag_int_type;
4166		4178
...	@@ -4953,7 +4965,7 @@ static LLVMValueRef ir_render_struct_init(CodeGen g, IrExecutable executable,	...	@@ -4953,7 +4965,7 @@ static LLVMValueRef ir_render_struct_init(CodeGen g, IrExecutable executable,
4953		4965
4954	ZigType *ptr_type = get_pointer_to_type_extra(g, type_struct_field->type_entry,	4966	ZigType *ptr_type = get_pointer_to_type_extra(g, type_struct_field->type_entry,
4955	false, false, PtrLenSingle, field_align_bytes,	4967	false, false, PtrLenSingle, field_align_bytes,
4956	(uint32_t)type_struct_field->bit_offset_in_host, host_int_bytes);	4968	(uint32_t)type_struct_field->bit_offset_in_host, host_int_bytes, false);
4957		4969
4958	gen_assign_raw(g, field_ptr, ptr_type, value);	4970	gen_assign_raw(g, field_ptr, ptr_type, value);
4959	}	4971	}
...	@@ -4969,7 +4981,7 @@ static LLVMValueRef ir_render_union_init(CodeGen g, IrExecutable executable, I	...	@@ -4969,7 +4981,7 @@ static LLVMValueRef ir_render_union_init(CodeGen g, IrExecutable executable, I
4969	uint32_t field_align_bytes = get_abi_alignment(g, type_union_field->type_entry);	4981	uint32_t field_align_bytes = get_abi_alignment(g, type_union_field->type_entry);
4970	ZigType *ptr_type = get_pointer_to_type_extra(g, type_union_field->type_entry,	4982	ZigType *ptr_type = get_pointer_to_type_extra(g, type_union_field->type_entry,
4971	false, false, PtrLenSingle, field_align_bytes,	4983	false, false, PtrLenSingle, field_align_bytes,
4972	0, 0);	4984	0, 0, false);
4973		4985
4974	LLVMValueRef uncasted_union_ptr;	4986	LLVMValueRef uncasted_union_ptr;
4975	// Even if safety is off in this block, if the union type has the safety field, we have to populate it	4987	// Even if safety is off in this block, if the union type has the safety field, we have to populate it
...	@@ -5224,7 +5236,7 @@ static LLVMValueRef get_coro_alloc_helper_fn_val(CodeGen *g, LLVMTypeRef alloc_f	...	@@ -5224,7 +5236,7 @@ static LLVMValueRef get_coro_alloc_helper_fn_val(CodeGen *g, LLVMTypeRef alloc_f
5224	LLVMPositionBuilderAtEnd(g->builder, ok_block);	5236	LLVMPositionBuilderAtEnd(g->builder, ok_block);
5225	LLVMValueRef payload_ptr = LLVMBuildStructGEP(g->builder, sret_ptr, err_union_payload_index, "");	5237	LLVMValueRef payload_ptr = LLVMBuildStructGEP(g->builder, sret_ptr, err_union_payload_index, "");
5226	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,	5238	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, false, false,
5227	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);	5239	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0, false);
5228	ZigType *slice_type = get_slice_type(g, u8_ptr_type);	5240	ZigType *slice_type = get_slice_type(g, u8_ptr_type);
5229	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;	5241	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
5230	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, payload_ptr, ptr_field_index, "");	5242	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, payload_ptr, ptr_field_index, "");
...	@@ -6470,7 +6482,7 @@ static void generate_error_name_table(CodeGen *g) {	...	@@ -6470,7 +6482,7 @@ static void generate_error_name_table(CodeGen *g) {
6470	assert(g->errors_by_index.length > 0);	6482	assert(g->errors_by_index.length > 0);
6471		6483
6472	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,	6484	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
6473	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);	6485	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0, false);
6474	ZigType *str_type = get_slice_type(g, u8_ptr_type);	6486	ZigType *str_type = get_slice_type(g, u8_ptr_type);
6475		6487
6476	LLVMValueRef *values = allocate<LLVMValueRef>(g->errors_by_index.length);	6488	LLVMValueRef *values = allocate<LLVMValueRef>(g->errors_by_index.length);
...	@@ -7551,6 +7563,7 @@ Buf codegen_generate_builtin_source(CodeGen g) {	...	@@ -7551,6 +7563,7 @@ Buf codegen_generate_builtin_source(CodeGen g) {
7551	" is_volatile: bool,\n"	7563	" is_volatile: bool,\n"
7552	" alignment: comptime_int,\n"	7564	" alignment: comptime_int,\n"
7553	" child: type,\n"	7565	" child: type,\n"
		7566	" is_allowzero: bool,\n"
7554	"\n"	7567	"\n"
7555	" pub const Size = enum {\n"	7568	" pub const Size = enum {\n"
7556	" One,\n"	7569	" One,\n"
...	@@ -8158,7 +8171,7 @@ static void create_test_compile_var_and_add_test_runner(CodeGen *g) {	...	@@ -8158,7 +8171,7 @@ static void create_test_compile_var_and_add_test_runner(CodeGen *g) {
8158	}	8171	}
8159		8172
8160	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,	8173	ZigType *u8_ptr_type = get_pointer_to_type_extra(g, g->builtin_types.entry_u8, true, false,
8161	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0);	8174	PtrLenUnknown, get_abi_alignment(g, g->builtin_types.entry_u8), 0, 0, false);
8162	ZigType *str_type = get_slice_type(g, u8_ptr_type);	8175	ZigType *str_type = get_slice_type(g, u8_ptr_type);
8163	ZigType *fn_type = get_test_fn_type(g);	8176	ZigType *fn_type = get_test_fn_type(g);
8164		8177

...	@@ -107,6 +107,7 @@ struct ZigKeyword {	...	@@ -107,6 +107,7 @@ struct ZigKeyword {
107		107
108	static const struct ZigKeyword zig_keywords[] = {	108	static const struct ZigKeyword zig_keywords[] = {
109	{"align", TokenIdKeywordAlign},	109	{"align", TokenIdKeywordAlign},
		110	{"allowzero", TokenIdKeywordAllowZero},
110	{"and", TokenIdKeywordAnd},	111	{"and", TokenIdKeywordAnd},
111	{"anyerror", TokenIdKeywordAnyerror},	112	{"anyerror", TokenIdKeywordAnyerror},
112	{"asm", TokenIdKeywordAsm},	113	{"asm", TokenIdKeywordAsm},
...	@@ -1495,6 +1496,7 @@ const char * token_name(TokenId id) {	...	@@ -1495,6 +1496,7 @@ const char * token_name(TokenId id) {
1495	case TokenIdIntLiteral: return "IntLiteral";	1496	case TokenIdIntLiteral: return "IntLiteral";
1496	case TokenIdKeywordAsync: return "async";	1497	case TokenIdKeywordAsync: return "async";
1497	case TokenIdKeywordAnyerror: return "anyerror";	1498	case TokenIdKeywordAnyerror: return "anyerror";
		1499	case TokenIdKeywordAllowZero: return "allowzero";
1498	case TokenIdKeywordAwait: return "await";	1500	case TokenIdKeywordAwait: return "await";
1499	case TokenIdKeywordResume: return "resume";	1501	case TokenIdKeywordResume: return "resume";
1500	case TokenIdKeywordSuspend: return "suspend";	1502	case TokenIdKeywordSuspend: return "suspend";

...	@@ -125,6 +125,7 @@ pub const Error = union(enum) {	...	@@ -125,6 +125,7 @@ pub const Error = union(enum) {
125	ExtraAlignQualifier: ExtraAlignQualifier,	125	ExtraAlignQualifier: ExtraAlignQualifier,
126	ExtraConstQualifier: ExtraConstQualifier,	126	ExtraConstQualifier: ExtraConstQualifier,
127	ExtraVolatileQualifier: ExtraVolatileQualifier,	127	ExtraVolatileQualifier: ExtraVolatileQualifier,
		128	ExtraAllowZeroQualifier: ExtraAllowZeroQualifier,
128	ExpectedPrimaryExpr: ExpectedPrimaryExpr,	129	ExpectedPrimaryExpr: ExpectedPrimaryExpr,
129	ExpectedToken: ExpectedToken,	130	ExpectedToken: ExpectedToken,
130	ExpectedCommaOrEnd: ExpectedCommaOrEnd,	131	ExpectedCommaOrEnd: ExpectedCommaOrEnd,
...	@@ -149,6 +150,7 @@ pub const Error = union(enum) {	...	@@ -149,6 +150,7 @@ pub const Error = union(enum) {
149	@TagType(Error).ExtraAlignQualifier => \|*x\| return x.render(tokens, stream),	150	@TagType(Error).ExtraAlignQualifier => \|*x\| return x.render(tokens, stream),
150	@TagType(Error).ExtraConstQualifier => \|*x\| return x.render(tokens, stream),	151	@TagType(Error).ExtraConstQualifier => \|*x\| return x.render(tokens, stream),
151	@TagType(Error).ExtraVolatileQualifier => \|*x\| return x.render(tokens, stream),	152	@TagType(Error).ExtraVolatileQualifier => \|*x\| return x.render(tokens, stream),
		153	@TagType(Error).ExtraAllowZeroQualifier => \|*x\| return x.render(tokens, stream),
152	@TagType(Error).ExpectedPrimaryExpr => \|*x\| return x.render(tokens, stream),	154	@TagType(Error).ExpectedPrimaryExpr => \|*x\| return x.render(tokens, stream),
153	@TagType(Error).ExpectedToken => \|*x\| return x.render(tokens, stream),	155	@TagType(Error).ExpectedToken => \|*x\| return x.render(tokens, stream),
154	@TagType(Error).ExpectedCommaOrEnd => \|*x\| return x.render(tokens, stream),	156	@TagType(Error).ExpectedCommaOrEnd => \|*x\| return x.render(tokens, stream),
...	@@ -175,6 +177,7 @@ pub const Error = union(enum) {	...	@@ -175,6 +177,7 @@ pub const Error = union(enum) {
175	@TagType(Error).ExtraAlignQualifier => \|x\| return x.token,	177	@TagType(Error).ExtraAlignQualifier => \|x\| return x.token,
176	@TagType(Error).ExtraConstQualifier => \|x\| return x.token,	178	@TagType(Error).ExtraConstQualifier => \|x\| return x.token,
177	@TagType(Error).ExtraVolatileQualifier => \|x\| return x.token,	179	@TagType(Error).ExtraVolatileQualifier => \|x\| return x.token,
		180	@TagType(Error).ExtraAllowZeroQualifier => \|x\| return x.token,
178	@TagType(Error).ExpectedPrimaryExpr => \|x\| return x.token,	181	@TagType(Error).ExpectedPrimaryExpr => \|x\| return x.token,
179	@TagType(Error).ExpectedToken => \|x\| return x.token,	182	@TagType(Error).ExpectedToken => \|x\| return x.token,
180	@TagType(Error).ExpectedCommaOrEnd => \|x\| return x.token,	183	@TagType(Error).ExpectedCommaOrEnd => \|x\| return x.token,
...	@@ -198,6 +201,7 @@ pub const Error = union(enum) {	...	@@ -198,6 +201,7 @@ pub const Error = union(enum) {
198	pub const ExtraAlignQualifier = SimpleError("Extra align qualifier");	201	pub const ExtraAlignQualifier = SimpleError("Extra align qualifier");
199	pub const ExtraConstQualifier = SimpleError("Extra const qualifier");	202	pub const ExtraConstQualifier = SimpleError("Extra const qualifier");
200	pub const ExtraVolatileQualifier = SimpleError("Extra volatile qualifier");	203	pub const ExtraVolatileQualifier = SimpleError("Extra volatile qualifier");
		204	pub const ExtraAllowZeroQualifier = SimpleError("Extra allowzero qualifier");
201		205
202	pub const ExpectedCall = struct {	206	pub const ExpectedCall = struct {
203	node: *Node,	207	node: *Node,
...	@@ -1540,6 +1544,7 @@ pub const Node = struct {	...	@@ -1540,6 +1544,7 @@ pub const Node = struct {
1540	};	1544	};
1541		1545
1542	pub const PtrInfo = struct {	1546	pub const PtrInfo = struct {
		1547	allowzero_token: ?TokenIndex,
1543	align_info: ?Align,	1548	align_info: ?Align,
1544	const_token: ?TokenIndex,	1549	const_token: ?TokenIndex,
1545	volatile_token: ?TokenIndex,	1550	volatile_token: ?TokenIndex,

...	@@ -1348,7 +1348,7 @@ static IrInstruction ir_build_br(IrBuilder irb, Scope scope, AstNode source_	...	@@ -1348,7 +1348,7 @@ static IrInstruction ir_build_br(IrBuilder irb, Scope scope, AstNode source_
1348		1348
1349	static IrInstruction ir_build_ptr_type(IrBuilder irb, Scope scope, AstNode source_node,	1349	static IrInstruction ir_build_ptr_type(IrBuilder irb, Scope scope, AstNode source_node,
1350	IrInstruction *child_type, bool is_const, bool is_volatile, PtrLen ptr_len,	1350	IrInstruction *child_type, bool is_const, bool is_volatile, PtrLen ptr_len,
1351	IrInstruction *align_value, uint32_t bit_offset_start, uint32_t host_int_bytes)	1351	IrInstruction *align_value, uint32_t bit_offset_start, uint32_t host_int_bytes, bool is_allow_zero)
1352	{	1352	{
1353	IrInstructionPtrType *ptr_type_of_instruction = ir_build_instruction<IrInstructionPtrType>(irb, scope, source_node);	1353	IrInstructionPtrType *ptr_type_of_instruction = ir_build_instruction<IrInstructionPtrType>(irb, scope, source_node);
1354	ptr_type_of_instruction->align_value = align_value;	1354	ptr_type_of_instruction->align_value = align_value;
...	@@ -1358,6 +1358,7 @@ static IrInstruction ir_build_ptr_type(IrBuilder irb, Scope scope, AstNode s	...	@@ -1358,6 +1358,7 @@ static IrInstruction ir_build_ptr_type(IrBuilder irb, Scope scope, AstNode s
1358	ptr_type_of_instruction->ptr_len = ptr_len;	1358	ptr_type_of_instruction->ptr_len = ptr_len;
1359	ptr_type_of_instruction->bit_offset_start = bit_offset_start;	1359	ptr_type_of_instruction->bit_offset_start = bit_offset_start;
1360	ptr_type_of_instruction->host_int_bytes = host_int_bytes;	1360	ptr_type_of_instruction->host_int_bytes = host_int_bytes;
		1361	ptr_type_of_instruction->is_allow_zero = is_allow_zero;
1361		1362
1362	if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);	1363	if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);
1363	ir_ref_instruction(child_type, irb->current_basic_block);	1364	ir_ref_instruction(child_type, irb->current_basic_block);
...	@@ -1627,13 +1628,14 @@ static IrInstruction ir_build_promise_type(IrBuilder irb, Scope *scope, AstNod	...	@@ -1627,13 +1628,14 @@ static IrInstruction ir_build_promise_type(IrBuilder irb, Scope *scope, AstNod
1627	}	1628	}
1628		1629
1629	static IrInstruction ir_build_slice_type(IrBuilder irb, Scope scope, AstNode source_node,	1630	static IrInstruction ir_build_slice_type(IrBuilder irb, Scope scope, AstNode source_node,
1630	IrInstruction child_type, bool is_const, bool is_volatile, IrInstruction align_value)	1631	IrInstruction child_type, bool is_const, bool is_volatile, IrInstruction align_value, bool is_allow_zero)
1631	{	1632	{
1632	IrInstructionSliceType *instruction = ir_build_instruction<IrInstructionSliceType>(irb, scope, source_node);	1633	IrInstructionSliceType *instruction = ir_build_instruction<IrInstructionSliceType>(irb, scope, source_node);
1633	instruction->is_const = is_const;	1634	instruction->is_const = is_const;
1634	instruction->is_volatile = is_volatile;	1635	instruction->is_volatile = is_volatile;
1635	instruction->child_type = child_type;	1636	instruction->child_type = child_type;
1636	instruction->align_value = align_value;	1637	instruction->align_value = align_value;
		1638	instruction->is_allow_zero = is_allow_zero;
1637		1639
1638	ir_ref_instruction(child_type, irb->current_basic_block);	1640	ir_ref_instruction(child_type, irb->current_basic_block);
1639	if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);	1641	if (align_value) ir_ref_instruction(align_value, irb->current_basic_block);
...	@@ -5192,6 +5194,7 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode	...	@@ -5192,6 +5194,7 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode
5192	PtrLen ptr_len = star_token_to_ptr_len(node->data.pointer_type.star_token->id);	5194	PtrLen ptr_len = star_token_to_ptr_len(node->data.pointer_type.star_token->id);
5193	bool is_const = node->data.pointer_type.is_const;	5195	bool is_const = node->data.pointer_type.is_const;
5194	bool is_volatile = node->data.pointer_type.is_volatile;	5196	bool is_volatile = node->data.pointer_type.is_volatile;
		5197	bool is_allow_zero = node->data.pointer_type.allow_zero_token != nullptr;
5195	AstNode *expr_node = node->data.pointer_type.op_expr;	5198	AstNode *expr_node = node->data.pointer_type.op_expr;
5196	AstNode *align_expr = node->data.pointer_type.align_expr;	5199	AstNode *align_expr = node->data.pointer_type.align_expr;
5197		5200
...	@@ -5239,7 +5242,7 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode	...	@@ -5239,7 +5242,7 @@ static IrInstruction ir_gen_pointer_type(IrBuilder irb, Scope *scope, AstNode