Commit c5945467acfd580cb3413250ef52f13dc412a8cf | zig

author	Robin Voetter <robin@voetter.nl> 2021-08-30 02:54:03+02:00
committer	Robin Voetter <robin@voetter.nl> 2021-09-20 02:29:04+02:00
log	c5945467acfd580cb3413250ef52f13dc412a8cf
tree	cd56aa35c06a65ec51a3ade3a3bbb90eb33cb8a1
parent	7a5d0cdf45f861f63d89666607dc86b3a2810826

Address Spaces: Pointer and function info in @Type

11 files changed, 121 insertions(+), 48 deletions(-)

lib
- std
src
- Sema.zig
- stage1
test
- behavior
  - type.zig
- compile_errors.zig

lib/std/builtin.zig+2

...	@@ -235,6 +235,7 @@ pub const TypeInfo = union(enum) {	...	@@ -235,6 +235,7 @@ pub const TypeInfo = union(enum) {
235	is_const: bool,	235	is_const: bool,
236	is_volatile: bool,	236	is_volatile: bool,
237	alignment: comptime_int,	237	alignment: comptime_int,
		238	address_space: AddressSpace,
238	child: type,	239	child: type,
239	is_allowzero: bool,	240	is_allowzero: bool,
240		241
...	@@ -364,6 +365,7 @@ pub const TypeInfo = union(enum) {	...	@@ -364,6 +365,7 @@ pub const TypeInfo = union(enum) {
364	pub const Fn = struct {	365	pub const Fn = struct {
365	calling_convention: CallingConvention,	366	calling_convention: CallingConvention,
366	alignment: comptime_int,	367	alignment: comptime_int,
		368	address_space: AddressSpace,
367	is_generic: bool,	369	is_generic: bool,
368	is_var_args: bool,	370	is_var_args: bool,
369	return_type: ?type,	371	return_type: ?type,

lib/std/mem.zig+2

...	@@ -2472,6 +2472,7 @@ fn CopyPtrAttrs(comptime source: type, comptime size: std.builtin.TypeInfo.Point	...	@@ -2472,6 +2472,7 @@ fn CopyPtrAttrs(comptime source: type, comptime size: std.builtin.TypeInfo.Point
2472	.is_volatile = info.is_volatile,	2472	.is_volatile = info.is_volatile,
2473	.is_allowzero = info.is_allowzero,	2473	.is_allowzero = info.is_allowzero,
2474	.alignment = info.alignment,	2474	.alignment = info.alignment,
		2475	.address_space = info.address_space,
2475	.child = child,	2476	.child = child,
2476	.sentinel = null,	2477	.sentinel = null,
2477	},	2478	},
...	@@ -2960,6 +2961,7 @@ fn AlignedSlice(comptime AttributeSource: type, comptime new_alignment: u29) typ	...	@@ -2960,6 +2961,7 @@ fn AlignedSlice(comptime AttributeSource: type, comptime new_alignment: u29) typ
2960	.is_volatile = info.is_volatile,	2961	.is_volatile = info.is_volatile,
2961	.is_allowzero = info.is_allowzero,	2962	.is_allowzero = info.is_allowzero,
2962	.alignment = new_alignment,	2963	.alignment = new_alignment,
		2964	.address_space = info.address_space,
2963	.child = info.child,	2965	.child = info.child,
2964	.sentinel = null,	2966	.sentinel = null,
2965	},	2967	},

lib/std/meta.zig+3

...	@@ -235,6 +235,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {	...	@@ -235,6 +235,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
235	.is_const = info.is_const,	235	.is_const = info.is_const,
236	.is_volatile = info.is_volatile,	236	.is_volatile = info.is_volatile,
237	.alignment = info.alignment,	237	.alignment = info.alignment,
		238	.address_space = info.address_space,
238	.child = @Type(.{	239	.child = @Type(.{
239	.Array = .{	240	.Array = .{
240	.len = array_info.len,	241	.len = array_info.len,
...	@@ -254,6 +255,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {	...	@@ -254,6 +255,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
254	.is_const = info.is_const,	255	.is_const = info.is_const,
255	.is_volatile = info.is_volatile,	256	.is_volatile = info.is_volatile,
256	.alignment = info.alignment,	257	.alignment = info.alignment,
		258	.address_space = info.address_space,
257	.child = info.child,	259	.child = info.child,
258	.is_allowzero = info.is_allowzero,	260	.is_allowzero = info.is_allowzero,
259	.sentinel = sentinel_val,	261	.sentinel = sentinel_val,
...	@@ -271,6 +273,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {	...	@@ -271,6 +273,7 @@ pub fn Sentinel(comptime T: type, comptime sentinel_val: Elem(T)) type {
271	.is_const = ptr_info.is_const,	273	.is_const = ptr_info.is_const,
272	.is_volatile = ptr_info.is_volatile,	274	.is_volatile = ptr_info.is_volatile,
273	.alignment = ptr_info.alignment,	275	.alignment = ptr_info.alignment,
		276	.address_space = ptr_info.address_space,
274	.child = ptr_info.child,	277	.child = ptr_info.child,
275	.is_allowzero = ptr_info.is_allowzero,	278	.is_allowzero = ptr_info.is_allowzero,
276	.sentinel = sentinel_val,	279	.sentinel = sentinel_val,

lib/std/zig/c_translation.zig+1

...	@@ -325,6 +325,7 @@ pub fn FlexibleArrayType(comptime SelfType: type, ElementType: type) type {	...	@@ -325,6 +325,7 @@ pub fn FlexibleArrayType(comptime SelfType: type, ElementType: type) type {
325	.is_const = ptr.is_const,	325	.is_const = ptr.is_const,
326	.is_volatile = ptr.is_volatile,	326	.is_volatile = ptr.is_volatile,
327	.alignment = @alignOf(ElementType),	327	.alignment = @alignOf(ElementType),
		328	.address_space = .generic,
328	.child = ElementType,	329	.child = ElementType,
329	.is_allowzero = true,	330	.is_allowzero = true,
330	.sentinel = null,	331	.sentinel = null,

src/Sema.zig+10-5

 @@ -6413,7 +6413,7 @@ fn zirTypeInfo(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileEr
     switch (ty.zigTypeTag()) {
         .Fn => {
-            const field_values = try sema.arena.alloc(Value, 6);
+            const field_values = try sema.arena.alloc(Value, 7);
             // calling_convention: CallingConvention,
             field_values[0] = try Value.Tag.enum_field_index.create(
                 sema.arena,
 @@ -6421,14 +6421,19 @@ fn zirTypeInfo(sema: *Sema, block: *Scope.Block, inst: Zir.Inst.Index) CompileEr
             );
             // alignment: comptime_int,
             field_values[1] = try Value.Tag.int_u64.create(sema.arena, ty.abiAlignment(target));
+            // address_space: AddressSpace,
+            field_values[2] = try Value.Tag.enum_field_index.create(
+                sema.arena,
+                @enumToInt(ty.fnAddressSpace()),
+            );
             // is_generic: bool,
-            field_values[2] = Value.initTag(.bool_false); // TODO
-            // is_var_args: bool,
             field_values[3] = Value.initTag(.bool_false); // TODO
+            // is_var_args: bool,
+            field_values[4] = Value.initTag(.bool_false); // TODO
             // return_type: ?type,
-            field_values[4] = try Value.Tag.ty.create(sema.arena, ty.fnReturnType());
+            field_values[5] = try Value.Tag.ty.create(sema.arena, ty.fnReturnType());
             // args: []const FnArg,
-            field_values[5] = Value.initTag(.null_value); // TODO
+            field_values[6] = Value.initTag(.null_value); // TODO
             return sema.addConstant(
                 type_info_ty,

src/stage1/all_types.hpp+8

...	@@ -86,6 +86,14 @@ enum CallingConvention {	...	@@ -86,6 +86,14 @@ enum CallingConvention {
86	CallingConventionSysV	86	CallingConventionSysV
87	};	87	};
88		88
		89	// Stage 1 supports only the generic address space
		90	enum AddressSpace {
		91	AddressSpaceGeneric,
		92	AddressSpaceGS,
		93	AddressSpaceFS,
		94	AddressSpaceSS,
		95	};
		96
89	// This one corresponds to the builtin.zig enum.	97	// This one corresponds to the builtin.zig enum.
90	enum BuiltinPtrSize {	98	enum BuiltinPtrSize {
91	BuiltinPtrSizeOne,	99	BuiltinPtrSizeOne,

src/stage1/analyze.cpp+10

...	@@ -1019,6 +1019,16 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {	...	@@ -1019,6 +1019,16 @@ bool calling_convention_allows_zig_types(CallingConvention cc) {
1019	zig_unreachable();	1019	zig_unreachable();
1020	}	1020	}
1021		1021
		1022	const char *address_space_name(AddressSpace as) {
		1023	switch (as) {
		1024	case AddressSpaceGeneric: return "generic";
		1025	case AddressSpaceGS: return "gs";
		1026	case AddressSpaceFS: return "fs";
		1027	case AddressSpaceSS: return "ss";
		1028	}
		1029	zig_unreachable();
		1030	}
		1031
1022	ZigType get_stack_trace_type(CodeGen g) {	1032	ZigType get_stack_trace_type(CodeGen g) {
1023	if (g->stack_trace_type == nullptr) {	1033	if (g->stack_trace_type == nullptr) {
1024	g->stack_trace_type = get_builtin_type(g, "StackTrace");	1034	g->stack_trace_type = get_builtin_type(g, "StackTrace");

src/stage1/analyze.hpp+2

...	@@ -242,6 +242,8 @@ Error get_primitive_type(CodeGen g, Buf name, ZigType **result);	...	@@ -242,6 +242,8 @@ Error get_primitive_type(CodeGen g, Buf name, ZigType **result);
242	bool calling_convention_allows_zig_types(CallingConvention cc);	242	bool calling_convention_allows_zig_types(CallingConvention cc);
243	const char *calling_convention_name(CallingConvention cc);	243	const char *calling_convention_name(CallingConvention cc);
244		244
		245	const char *address_space_name(AddressSpace as);
		246
245	Error ATTRIBUTE_MUST_USE file_fetch(CodeGen g, Buf resolved_path, Buf *contents);	247	Error ATTRIBUTE_MUST_USE file_fetch(CodeGen g, Buf resolved_path, Buf *contents);
246		248
247	void walk_function_params(CodeGen g, ZigType fn_type, FnWalk *fn_walk);	249	void walk_function_params(CodeGen g, ZigType fn_type, FnWalk *fn_walk);

src/stage1/ir.cpp+78-43

 @@ -16124,7 +16124,7 @@ static Stage1AirInst *ir_analyze_instruction_optional_unwrap_ptr(IrAnalyze *ira,
 static Stage1AirInst *ir_analyze_instruction_ctz(IrAnalyze *ira, Stage1ZirInstCtz *instruction) {
     Error err;
     ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
     if (type_is_invalid(int_type))
         return ira->codegen->invalid_inst_gen;
 @@ -16166,7 +16166,7 @@ static Stage1AirInst *ir_analyze_instruction_ctz(IrAnalyze *ira, Stage1ZirInstCt
             return ira->codegen->invalid_inst_gen;
         if (val->special == ConstValSpecialUndef)
             return ir_const_undef(ira, instruction->base.scope, instruction->base.source_node, ira->codegen->builtin_types.entry_num_lit_int);
         if (is_vector) {
             ZigType *smallest_vec_type = get_vector_type(ira->codegen, vector_len, smallest_type);
             Stage1AirInst *result = ir_const(ira, instruction->base.scope, instruction->base.source_node, smallest_vec_type);
 @@ -16200,7 +16200,7 @@ static Stage1AirInst *ir_analyze_instruction_ctz(IrAnalyze *ira, Stage1ZirInstCt
 static Stage1AirInst *ir_analyze_instruction_clz(IrAnalyze *ira, Stage1ZirInstClz *instruction) {
     Error err;
     ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
     if (type_is_invalid(int_type))
         return ira->codegen->invalid_inst_gen;
 @@ -16242,7 +16242,7 @@ static Stage1AirInst *ir_analyze_instruction_clz(IrAnalyze *ira, Stage1ZirInstCl
             return ira->codegen->invalid_inst_gen;
         if (val->special == ConstValSpecialUndef)
             return ir_const_undef(ira, instruction->base.scope, instruction->base.source_node, ira->codegen->builtin_types.entry_num_lit_int);
         if (is_vector) {
             ZigType *smallest_vec_type = get_vector_type(ira->codegen, vector_len, smallest_type);
             Stage1AirInst *result = ir_const(ira, instruction->base.scope, instruction->base.source_node, smallest_vec_type);
 @@ -16276,7 +16276,7 @@ static Stage1AirInst *ir_analyze_instruction_clz(IrAnalyze *ira, Stage1ZirInstCl
 static Stage1AirInst *ir_analyze_instruction_pop_count(IrAnalyze *ira, Stage1ZirInstPopCount *instruction) {
     Error err;
     ZigType *int_type = ir_resolve_int_type(ira, instruction->type->child);
     if (type_is_invalid(int_type))
         return ira->codegen->invalid_inst_gen;
 @@ -16318,7 +16318,7 @@ static Stage1AirInst *ir_analyze_instruction_pop_count(IrAnalyze *ira, Stage1Zir
             return ira->codegen->invalid_inst_gen;
         if (val->special == ConstValSpecialUndef)
             return ir_const_undef(ira, instruction->base.scope, instruction->base.source_node, ira->codegen->builtin_types.entry_num_lit_int);
         if (is_vector) {
             ZigType *smallest_vec_type = get_vector_type(ira->codegen, vector_len, smallest_type);
             Stage1AirInst *result = ir_const(ira, instruction->base.scope, instruction->base.source_node, smallest_vec_type);
 @@ -17904,7 +17904,7 @@ static ZigValue *create_ptr_like_type_info(IrAnalyze *ira, Scope *scope, AstNode
     result->special = ConstValSpecialStatic;
     result->type = type_info_pointer_type;
-    ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 7);
+    ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 8);
     result->data.x_struct.fields = fields;
     // size: Size
 @@ -17939,24 +17939,29 @@ static ZigValue *create_ptr_like_type_info(IrAnalyze *ira, Scope *scope, AstNode
         lazy_align_of->base.id = LazyValueIdAlignOf;
         lazy_align_of->target_type = ir_const_type(ira, scope, source_node, attrs_type->data.pointer.child_type);
     }
-    // child: type
+    // address_space: AddressSpace,
-    ensure_field_index(result->type, "child", 4);
+    ensure_field_index(result->type, "address_space", 4);
     fields[4]->special = ConstValSpecialStatic;
-    fields[4]->type = ira->codegen->builtin_types.entry_type;
+    fields[4]->type = get_builtin_type(ira->codegen, "AddressSpace");
-    fields[4]->data.x_type = attrs_type->data.pointer.child_type;
+    bigint_init_unsigned(&fields[4]->data.x_enum_tag, AddressSpaceGeneric);
-    // is_allowzero: bool
+    // child: type
-    ensure_field_index(result->type, "is_allowzero", 5);
+    ensure_field_index(result->type, "child", 5);
     fields[5]->special = ConstValSpecialStatic;
-    fields[5]->type = ira->codegen->builtin_types.entry_bool;
+    fields[5]->type = ira->codegen->builtin_types.entry_type;
-    fields[5]->data.x_bool = attrs_type->data.pointer.allow_zero;
+    fields[5]->data.x_type = attrs_type->data.pointer.child_type;
-    // sentinel: anytype
+    // is_allowzero: bool
-    ensure_field_index(result->type, "sentinel", 6);
+    ensure_field_index(result->type, "is_allowzero", 6);
     fields[6]->special = ConstValSpecialStatic;
+    fields[6]->type = ira->codegen->builtin_types.entry_bool;
+    fields[6]->data.x_bool = attrs_type->data.pointer.allow_zero;
+    // sentinel: anytype
+    ensure_field_index(result->type, "sentinel", 7);
+    fields[7]->special = ConstValSpecialStatic;
     if (attrs_type->data.pointer.sentinel != nullptr) {
-        fields[6]->type = get_optional_type(ira->codegen, attrs_type->data.pointer.child_type);
+        fields[7]->type = get_optional_type(ira->codegen, attrs_type->data.pointer.child_type);
-        set_optional_payload(fields[6], attrs_type->data.pointer.sentinel);
+        set_optional_payload(fields[7], attrs_type->data.pointer.sentinel);
     } else {
-        fields[6]->type = ira->codegen->builtin_types.entry_null;
+        fields[7]->type = ira->codegen->builtin_types.entry_null;
     }
     return result;
 @@ -18465,7 +18470,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, Scope *scope, AstNode *sour
                 result->special = ConstValSpecialStatic;
                 result->type = ir_type_info_get_type(ira, "Fn", nullptr);
-                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 6);
+                ZigValue **fields = alloc_const_vals_ptrs(ira->codegen, 7);
                 result->data.x_struct.fields = fields;
                 // calling_convention: TypeInfo.CallingConvention
 @@ -18478,30 +18483,35 @@ static Error ir_make_type_info_value(IrAnalyze *ira, Scope *scope, AstNode *sour
                 fields[1]->special = ConstValSpecialStatic;
                 fields[1]->type = ira->codegen->builtin_types.entry_num_lit_int;
                 bigint_init_unsigned(&fields[1]->data.x_bigint, get_ptr_align(ira->codegen, type_entry));
+                // address_space: AddressSpace
+                ensure_field_index(result->type, "address_space", 2);
+                fields[2]->special = ConstValSpecialStatic;
+                fields[2]->type = get_builtin_type(ira->codegen, "AddressSpace");
+                bigint_init_unsigned(&fields[2]->data.x_enum_tag, AddressSpaceGeneric);
                 // is_generic: bool
-                ensure_field_index(result->type, "is_generic", 2);
+                ensure_field_index(result->type, "is_generic", 3);
                 bool is_generic = type_entry->data.fn.is_generic;
-                fields[2]->special = ConstValSpecialStatic;
-                fields[2]->type = ira->codegen->builtin_types.entry_bool;
-                fields[2]->data.x_bool = is_generic;
-                // is_varargs: bool
-                ensure_field_index(result->type, "is_var_args", 3);
-                bool is_varargs = type_entry->data.fn.fn_type_id.is_var_args;
                 fields[3]->special = ConstValSpecialStatic;
                 fields[3]->type = ira->codegen->builtin_types.entry_bool;
-                fields[3]->data.x_bool = is_varargs;
+                fields[3]->data.x_bool = is_generic;
-                // return_type: ?type
+                // is_varargs: bool
-                ensure_field_index(result->type, "return_type", 4);
+                ensure_field_index(result->type, "is_var_args", 4);
+                bool is_varargs = type_entry->data.fn.fn_type_id.is_var_args;
                 fields[4]->special = ConstValSpecialStatic;
-                fields[4]->type = get_optional_type(ira->codegen, ira->codegen->builtin_types.entry_type);
+                fields[4]->type = ira->codegen->builtin_types.entry_bool;
+                fields[4]->data.x_bool = is_varargs;
+                // return_type: ?type
+                ensure_field_index(result->type, "return_type", 5);
+                fields[5]->special = ConstValSpecialStatic;
+                fields[5]->type = get_optional_type(ira->codegen, ira->codegen->builtin_types.entry_type);
                 if (type_entry->data.fn.fn_type_id.return_type == nullptr)
-                    fields[4]->data.x_optional = nullptr;
+                    fields[5]->data.x_optional = nullptr;
                 else {
                     ZigValue *return_type = ira->codegen->pass1_arena->create<ZigValue>();
                     return_type->special = ConstValSpecialStatic;
                     return_type->type = ira->codegen->builtin_types.entry_type;
                     return_type->data.x_type = type_entry->data.fn.fn_type_id.return_type;
-                    fields[4]->data.x_optional = return_type;
+                    fields[5]->data.x_optional = return_type;
                 }
                 // args: []TypeInfo.FnArg
                 ZigType *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg", nullptr);
 @@ -18516,7 +18526,7 @@ static Error ir_make_type_info_value(IrAnalyze *ira, Scope *scope, AstNode *sour
                 fn_arg_array->data.x_array.special = ConstArraySpecialNone;
                 fn_arg_array->data.x_array.data.s_none.elements = ira->codegen->pass1_arena->allocate<ZigValue>(fn_arg_count);
-                init_const_slice(ira->codegen, fields[5], fn_arg_array, 0, fn_arg_count, false, nullptr);
+                init_const_slice(ira->codegen, fields[6], fn_arg_array, 0, fn_arg_count, false, nullptr);
                 for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++) {
                     FnTypeParamInfo *fn_param_info = &type_entry->data.fn.fn_type_id.param_info[fn_arg_index];
 @@ -18826,11 +18836,11 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
                 assert(size_value->type == ir_type_info_get_type(ira, "Size", type_info_pointer_type));
                 BuiltinPtrSize size_enum_index = (BuiltinPtrSize)bigint_as_u32(&size_value->data.x_enum_tag);
                 PtrLen ptr_len = size_enum_index_to_ptr_len(size_enum_index);
-                ZigType *elem_type = get_const_field_meta_type(ira, source_node, payload, "child", 4);
+                ZigType *elem_type = get_const_field_meta_type(ira, source_node, payload, "child", 5);
                 if (type_is_invalid(elem_type))
                     return ira->codegen->invalid_inst_gen->value->type;
                 ZigValue *sentinel;
-                if ((err = get_const_field_sentinel(ira, scope, source_node, payload, "sentinel", 6,
+                if ((err = get_const_field_sentinel(ira, scope, source_node, payload, "sentinel", 7,
                                 elem_type, &sentinel)))
                 {
                     return ira->codegen->invalid_inst_gen->value->type;
 @@ -18845,6 +18855,19 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
                 if (alignment == nullptr)
                     return ira->codegen->invalid_inst_gen->value->type;
+                ZigValue *as_value = get_const_field(ira, source_node, payload, "address_space", 4);
+                if (as_value == nullptr)
+                    return ira->codegen->invalid_inst_gen->value->type;
+                assert(as_value->special == ConstValSpecialStatic);
+                assert(as_value->type == get_builtin_type(ira->codegen, "AddressSpace"));
+                AddressSpace as = (AddressSpace)bigint_as_u32(&as_value->data.x_enum_tag);
+                if (as != AddressSpaceGeneric) {
+                    ir_add_error_node(ira, source_node, buf_sprintf(
+                        "address space '%s' not available in stage 1 compiler, must be .generic",
+                        address_space_name(as)));
+                    return ira->codegen->invalid_inst_gen->value->type;
+                }
                 bool is_const;
                 if ((err = get_const_field_bool(ira, source_node, payload, "is_const", 1, &is_const)))
                     return ira->codegen->invalid_inst_gen->value->type;
 @@ -18857,13 +18880,12 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
                 }
                 bool is_allowzero;
-                if ((err = get_const_field_bool(ira, source_node, payload, "is_allowzero", 5,
+                if ((err = get_const_field_bool(ira, source_node, payload, "is_allowzero", 6,
                                 &is_allowzero)))
                 {
                     return ira->codegen->invalid_inst_gen->value->type;
                 }
                 ZigType *ptr_type = get_pointer_to_type_extra2(ira->codegen,
                     elem_type,
                     is_const,
 @@ -19308,9 +19330,22 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
             if (alignment == nullptr)
                 return ira->codegen->invalid_inst_gen->value->type;
+            ZigValue *as_value = get_const_field(ira, source_node, payload, "address_space", 2);
+            if (as_value == nullptr)
+                return ira->codegen->invalid_inst_gen->value->type;
+            assert(as_value->special == ConstValSpecialStatic);
+            assert(as_value->type == get_builtin_type(ira->codegen, "AddressSpace"));
+            AddressSpace as = (AddressSpace)bigint_as_u32(&as_value->data.x_enum_tag);
+            if (as != AddressSpaceGeneric) {
+                ir_add_error_node(ira, source_node, buf_sprintf(
+                    "address space '%s' not available in stage 1 compiler, must be .generic",
+                    address_space_name(as)));
+                return ira->codegen->invalid_inst_gen->value->type;
+            }
             Error err;
             bool is_generic;
-            if ((err = get_const_field_bool(ira, source_node, payload, "is_generic", 2, &is_generic)))
+            if ((err = get_const_field_bool(ira, source_node, payload, "is_generic", 3, &is_generic)))
                 return ira->codegen->invalid_inst_gen->value->type;
             if (is_generic) {
                 ir_add_error_node(ira, source_node, buf_sprintf("TypeInfo.Fn.is_generic must be false for @Type"));
 @@ -19318,20 +19353,20 @@ static ZigType *type_info_to_type(IrAnalyze *ira, Scope *scope, AstNode *source_
             }
             bool is_var_args;
-            if ((err = get_const_field_bool(ira, source_node, payload, "is_var_args", 3, &is_var_args)))
+            if ((err = get_const_field_bool(ira, source_node, payload, "is_var_args", 4, &is_var_args)))
                 return ira->codegen->invalid_inst_gen->value->type;
             if (is_var_args && cc != CallingConventionC) {
                 ir_add_error_node(ira, source_node, buf_sprintf("varargs functions must have C calling convention"));
                 return ira->codegen->invalid_inst_gen->value->type;
             }
-            ZigType *return_type = get_const_field_meta_type_optional(ira, source_node, payload, "return_type", 4);
+            ZigType *return_type = get_const_field_meta_type_optional(ira, source_node, payload, "return_type", 5);
             if (return_type == nullptr) {
                 ir_add_error_node(ira, source_node, buf_sprintf("TypeInfo.Fn.return_type must be non-null for @Type"));
                 return ira->codegen->invalid_inst_gen->value->type;
             }
-            ZigValue *args_value = get_const_field(ira, source_node, payload, "args", 5);
+            ZigValue *args_value = get_const_field(ira, source_node, payload, "args", 6);
             if (args_value == nullptr)
                 return ira->codegen->invalid_inst_gen->value->type;
             assert(args_value->special == ConstValSpecialStatic);

test/behavior/type.zig+1

...	@@ -137,6 +137,7 @@ test "@Type create slice with null sentinel" {	...	@@ -137,6 +137,7 @@ test "@Type create slice with null sentinel" {
137	.is_volatile = false,	137	.is_volatile = false,
138	.is_allowzero = false,	138	.is_allowzero = false,
139	.alignment = 8,	139	.alignment = 8,
		140	.address_space = .generic,
140	.child = *i32,	141	.child = *i32,
141	.sentinel = null,	142	.sentinel = null,
142	},	143	},

test/compile_errors.zig+4

...	@@ -410,6 +410,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -410,6 +410,7 @@ pub fn addCases(ctx: *TestContext) !void {
410	\\ .Fn = .{	410	\\ .Fn = .{
411	\\ .calling_convention = .Unspecified,	411	\\ .calling_convention = .Unspecified,
412	\\ .alignment = 0,	412	\\ .alignment = 0,
		413	\\ .address_space = 0,
413	\\ .is_generic = true,	414	\\ .is_generic = true,
414	\\ .is_var_args = false,	415	\\ .is_var_args = false,
415	\\ .return_type = u0,	416	\\ .return_type = u0,
...	@@ -426,6 +427,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -426,6 +427,7 @@ pub fn addCases(ctx: *TestContext) !void {
426	\\ .Fn = .{	427	\\ .Fn = .{
427	\\ .calling_convention = .Unspecified,	428	\\ .calling_convention = .Unspecified,
428	\\ .alignment = 0,	429	\\ .alignment = 0,
		430	\\ .address_space = 0,
429	\\ .is_generic = false,	431	\\ .is_generic = false,
430	\\ .is_var_args = true,	432	\\ .is_var_args = true,
431	\\ .return_type = u0,	433	\\ .return_type = u0,
...	@@ -442,6 +444,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -442,6 +444,7 @@ pub fn addCases(ctx: *TestContext) !void {
442	\\ .Fn = .{	444	\\ .Fn = .{
443	\\ .calling_convention = .Unspecified,	445	\\ .calling_convention = .Unspecified,
444	\\ .alignment = 0,	446	\\ .alignment = 0,
		447	\\ .address_space = 0,
445	\\ .is_generic = false,	448	\\ .is_generic = false,
446	\\ .is_var_args = false,	449	\\ .is_var_args = false,
447	\\ .return_type = null,	450	\\ .return_type = null,
...	@@ -711,6 +714,7 @@ pub fn addCases(ctx: *TestContext) !void {	...	@@ -711,6 +714,7 @@ pub fn addCases(ctx: *TestContext) !void {
711	\\ .is_const = false,	714	\\ .is_const = false,
712	\\ .is_volatile = false,	715	\\ .is_volatile = false,
713	\\ .alignment = 1,	716	\\ .alignment = 1,
		717	\\ .address_space = .generic,
714	\\ .child = u8,	718	\\ .child = u8,
715	\\ .is_allowzero = false,	719	\\ .is_allowzero = false,
716	\\ .sentinel = 0,	720	\\ .sentinel = 0,