Commit de49a9a17352a36a0888b03905f207b0584fc269 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2024-08-18 17:57:28+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2024-08-18 18:10:59+01:00
log	de49a9a17352a36a0888b03905f207b0584fc269
tree	ebda829424b7df833084bc0f8275815d42a6eeec
parent	a239d8d4e2c0e5a7f3eb4b9973f869afdb3bbe05
signature	Commit is signed but in an unrecognized format.

Zir: add instructions to fetch std.builtin types

This replaces the constant `Zir.Inst.Ref` tags (and the analagous tags
in `Air.Inst.Ref`, `InternPool.Index`) referring to types in
`std.builtin` with a ZIR instruction `extended(builtin_type(...))` which
instructs Sema to fetch such a type, effectively as if it were a
shorthand for the ZIR for `@import("std").builtin.xyz`.

Previously, this was achieved through constant tags in `Ref`. The
analagous `InternPool` indices began as `simple_type` values, and were
later rewritten to the correct type information. This system was kind of
brittle, and more importantly, isn't compatible with incremental
compilation of std, since incremental compilation relies on the ability
to recreate types at different indices when they change. Replacing the
old system with this instruction slightly increases the size of ZIR, but
it simplifies logic and allows incremental compilation to work correctly
on the standard library.

This shouldn't have a significant impact on ZIR size or compiler
performance, but I will take measurements in the PR to confirm this.

11 files changed, 152 insertions(+), 492 deletions(-)

lib
- std
  - zig
    AstGen.zig
    Zir.zig
src
- Air.zig
- InternPool.zig
- Sema.zig
- Type.zig
- Zcu
  - PerThread.zig
- codegen
  - c
    Type.zig
  - llvm.zig
- link
  - Dwarf.zig
- print_zir.zig

lib/std/zig/AstGen.zig+57-46

 @@ -366,7 +366,6 @@ const ResultInfo = struct {
 };
 const coerced_align_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .u29_type } };
-const coerced_addrspace_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .address_space_type } };
 const coerced_linksection_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .slice_const_u8_type } };
 const coerced_type_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .type_type } };
 const coerced_bool_ri: ResultInfo = .{ .rl = .{ .coerced_ty = .bool_type } };
 @@ -1387,7 +1386,7 @@ fn fnProtoExpr(
         try expr(
             &block_scope,
             scope,
-            .{ .rl = .{ .coerced_ty = .calling_convention_type } },
+            .{ .rl = .{ .coerced_ty = try block_scope.addBuiltinValue(fn_proto.ast.callconv_expr, .calling_convention) } },
             fn_proto.ast.callconv_expr,
         )
     else
 @@ -3804,7 +3803,8 @@ fn ptrType(
         gz.astgen.source_line = source_line;
         gz.astgen.source_column = source_column;
-        addrspace_ref = try expr(gz, scope, coerced_addrspace_ri, ptr_info.ast.addrspace_node);
+        const addrspace_ty = try gz.addBuiltinValue(ptr_info.ast.addrspace_node, .address_space);
+        addrspace_ref = try expr(gz, scope, .{ .rl = .{ .coerced_ty = addrspace_ty } }, ptr_info.ast.addrspace_node);
         trailing_count += 1;
     }
     if (ptr_info.ast.align_node != 0) {
 @@ -4202,7 +4202,8 @@ fn fnDecl(
     var addrspace_gz = decl_gz.makeSubBlock(params_scope);
     defer addrspace_gz.unstack();
     const addrspace_ref: Zir.Inst.Ref = if (fn_proto.ast.addrspace_expr == 0) .none else inst: {
-        const inst = try expr(&decl_gz, params_scope, coerced_addrspace_ri, fn_proto.ast.addrspace_expr);
+        const addrspace_ty = try decl_gz.addBuiltinValue(fn_proto.ast.addrspace_expr, .address_space);
+        const inst = try expr(&decl_gz, params_scope, .{ .rl = .{ .coerced_ty = addrspace_ty } }, fn_proto.ast.addrspace_expr);
         if (addrspace_gz.instructionsSlice().len == 0) {
             // In this case we will send a len=0 body which can be encoded more efficiently.
             break :inst inst;
 @@ -4235,9 +4236,9 @@ fn fnDecl(
                 );
             }
             const inst = try expr(
-                &decl_gz,
+                &cc_gz,
                 params_scope,
-                .{ .rl = .{ .coerced_ty = .calling_convention_type } },
+                .{ .rl = .{ .coerced_ty = try cc_gz.addBuiltinValue(fn_proto.ast.callconv_expr, .calling_convention) } },
                 fn_proto.ast.callconv_expr,
             );
             if (cc_gz.instructionsSlice().len == 0) {
 @@ -4247,10 +4248,13 @@ fn fnDecl(
             _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst);
             break :blk inst;
         } else if (is_extern) {
-            // note: https://github.com/ziglang/zig/issues/5269
+            const inst = try cc_gz.addBuiltinValue(decl_node, .calling_convention_c);
-            break :blk .calling_convention_c;
+            _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst);
+            break :blk inst;
         } else if (has_inline_keyword) {
-            break :blk .calling_convention_inline;
+            const inst = try cc_gz.addBuiltinValue(decl_node, .calling_convention_inline);
+            _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst);
+            break :blk inst;
         } else {
             break :blk .none;
         }
 @@ -4525,7 +4529,8 @@ fn globalVarDecl(
     var addrspace_gz = linksection_gz.makeSubBlock(scope);
     if (var_decl.ast.addrspace_node != 0) {
-        const addrspace_inst = try fullBodyExpr(&addrspace_gz, &addrspace_gz.base, coerced_addrspace_ri, var_decl.ast.addrspace_node);
+        const addrspace_ty = try addrspace_gz.addBuiltinValue(var_decl.ast.addrspace_node, .address_space);
+        const addrspace_inst = try fullBodyExpr(&addrspace_gz, &addrspace_gz.base, .{ .rl = .{ .coerced_ty = addrspace_ty } }, var_decl.ast.addrspace_node);
         _ = try addrspace_gz.addBreakWithSrcNode(.break_inline, decl_inst, addrspace_inst, node);
     }
 @@ -9169,6 +9174,7 @@ fn builtinCall(
         // zig fmt: on
         .@"export" => {
+            const export_options_ty = try gz.addBuiltinValue(node, .export_options);
             const node_tags = tree.nodes.items(.tag);
             const node_datas = tree.nodes.items(.data);
             // This function causes a Decl to be exported. The first parameter is not an expression,
 @@ -9192,7 +9198,7 @@ fn builtinCall(
                                 local_val.used = ident_token;
                                 _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
                                     .operand = local_val.inst,
-                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
+                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = export_options_ty } }, params[1]),
                                 });
                                 return rvalue(gz, ri, .void_value, node);
                             }
 @@ -9207,7 +9213,7 @@ fn builtinCall(
                                 const loaded = try gz.addUnNode(.load, local_ptr.ptr, node);
                                 _ = try gz.addPlNode(.export_value, node, Zir.Inst.ExportValue{
                                     .operand = loaded,
-                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]),
+                                    .options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = export_options_ty } }, params[1]),
                                 });
                                 return rvalue(gz, ri, .void_value, node);
                             }
 @@ -9245,7 +9251,7 @@ fn builtinCall(
                 },
                 else => return astgen.failNode(params[0], "symbol to export must identify a declaration", .{}),
             }
-            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .export_options_type } }, params[1]);
+            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = export_options_ty } }, params[1]);
             _ = try gz.addPlNode(.@"export", node, Zir.Inst.Export{
                 .namespace = namespace,
                 .decl_name = decl_name,
 @@ -9255,7 +9261,8 @@ fn builtinCall(
         },
         .@"extern" => {
             const type_inst = try typeExpr(gz, scope, params[0]);
-            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .extern_options_type } }, params[1]);
+            const extern_options_ty = try gz.addBuiltinValue(node, .extern_options);
+            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = extern_options_ty } }, params[1]);
             const result = try gz.addExtendedPayload(.builtin_extern, Zir.Inst.BinNode{
                 .node = gz.nodeIndexToRelative(node),
                 .lhs = type_inst,
 @@ -9264,7 +9271,8 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .fence => {
-            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[0]);
+            const atomic_order_ty = try gz.addBuiltinValue(node, .atomic_order);
+            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_ty } }, params[0]);
             _ = try gz.addExtendedPayload(.fence, Zir.Inst.UnNode{
                 .node = gz.nodeIndexToRelative(node),
                 .operand = order,
 @@ -9272,7 +9280,8 @@ fn builtinCall(
             return rvalue(gz, ri, .void_value, node);
         },
         .set_float_mode => {
-            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .float_mode_type } }, params[0]);
+            const float_mode_ty = try gz.addBuiltinValue(node, .float_mode);
+            const order = try expr(gz, scope, .{ .rl = .{ .coerced_ty = float_mode_ty } }, params[0]);
             _ = try gz.addExtendedPayload(.set_float_mode, Zir.Inst.UnNode{
                 .node = gz.nodeIndexToRelative(node),
                 .operand = order,
 @@ -9365,7 +9374,8 @@ fn builtinCall(
         },
         .Type => {
-            const operand = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .type_info_type } }, params[0]);
+            const type_info_ty = try gz.addBuiltinValue(node, .type_info);
+            const operand = try expr(gz, scope, .{ .rl = .{ .coerced_ty = type_info_ty } }, params[0]);
             const gpa = gz.astgen.gpa;
 @@ -9502,7 +9512,8 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .reduce => {
-            const op = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .reduce_op_type } }, params[0]);
+            const reduce_op_ty = try gz.addBuiltinValue(node, .reduce_op);
+            const op = try expr(gz, scope, .{ .rl = .{ .coerced_ty = reduce_op_ty } }, params[0]);
             const scalar = try expr(gz, scope, .{ .rl = .none }, params[1]);
             const result = try gz.addPlNode(.reduce, node, Zir.Inst.Bin{
                 .lhs = op,
 @@ -9517,34 +9528,38 @@ fn builtinCall(
         .shl_with_overflow => return overflowArithmetic(gz, scope, ri, node, params, .shl_with_overflow),
         .atomic_load => {
+            const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
             const result = try gz.addPlNode(.atomic_load, node, Zir.Inst.AtomicLoad{
                 // zig fmt: off
-                .elem_type = try typeExpr(gz, scope,                                                   params[0]),
+                .elem_type = try typeExpr(gz, scope,                                                  params[0]),
-                .ptr       = try expr    (gz, scope, .{ .rl = .none },                                 params[1]),
+                .ptr       = try expr    (gz, scope, .{ .rl = .none },                                params[1]),
-                .ordering  = try expr    (gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[2]),
+                .ordering  = try expr    (gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[2]),
                 // zig fmt: on
             });
             return rvalue(gz, ri, result, node);
         },
         .atomic_rmw => {
+            const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
+            const atomic_rmw_op_type = try gz.addBuiltinValue(node, .atomic_rmw_op);
             const int_type = try typeExpr(gz, scope, params[0]);
             const result = try gz.addPlNode(.atomic_rmw, node, Zir.Inst.AtomicRmw{
                 // zig fmt: off
-                .ptr       = try expr(gz, scope, .{ .rl = .none },                                  params[1]),
+                .ptr       = try expr(gz, scope, .{ .rl = .none },                                 params[1]),
-                .operation = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_rmw_op_type } }, params[2]),
+                .operation = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_rmw_op_type } }, params[2]),
-                .operand   = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                    params[3]),
+                .operand   = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                   params[3]),
-                .ordering  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } },  params[4]),
+                .ordering  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } },  params[4]),
                 // zig fmt: on
             });
             return rvalue(gz, ri, result, node);
         },
         .atomic_store => {
+            const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
             const int_type = try typeExpr(gz, scope, params[0]);
             _ = try gz.addPlNode(.atomic_store, node, Zir.Inst.AtomicStore{
                 // zig fmt: off
-                .ptr      = try expr(gz, scope, .{ .rl = .none },                                 params[1]),
+                .ptr      = try expr(gz, scope, .{ .rl = .none },                                params[1]),
-                .operand  = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                   params[2]),
+                .operand  = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                  params[2]),
-                .ordering = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[3]),
+                .ordering = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[3]),
                 // zig fmt: on
             });
             return rvalue(gz, ri, .void_value, node);
 @@ -9562,7 +9577,8 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .call => {
-            const modifier = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .call_modifier_type } }, params[0]);
+            const call_modifier_ty = try gz.addBuiltinValue(node, .call_modifier);
+            const modifier = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = call_modifier_ty } }, params[0]);
             const callee = try expr(gz, scope, .{ .rl = .none }, params[1]);
             const args = try expr(gz, scope, .{ .rl = .none }, params[2]);
             const result = try gz.addPlNode(.builtin_call, node, Zir.Inst.BuiltinCall{
 @@ -9641,8 +9657,9 @@ fn builtinCall(
             return rvalue(gz, ri, result, node);
         },
         .prefetch => {
+            const prefetch_options_ty = try gz.addBuiltinValue(node, .prefetch_options);
             const ptr = try expr(gz, scope, .{ .rl = .none }, params[0]);
-            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .prefetch_options_type } }, params[1]);
+            const options = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = prefetch_options_ty } }, params[1]);
             _ = try gz.addExtendedPayload(.prefetch, Zir.Inst.BinNode{
                 .node = gz.nodeIndexToRelative(node),
                 .lhs = ptr,
 @@ -9812,14 +9829,15 @@ fn cmpxchg(
     small: u16,
 ) InnerError!Zir.Inst.Ref {
     const int_type = try typeExpr(gz, scope, params[0]);
+    const atomic_order_type = try gz.addBuiltinValue(node, .atomic_order);
     const result = try gz.addExtendedPayloadSmall(.cmpxchg, small, Zir.Inst.Cmpxchg{
         // zig fmt: off
         .node           = gz.nodeIndexToRelative(node),
-        .ptr            = try expr(gz, scope, .{ .rl = .none },                                 params[1]),
+        .ptr            = try expr(gz, scope, .{ .rl = .none },                                params[1]),
-        .expected_value = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                   params[2]),
+        .expected_value = try expr(gz, scope, .{ .rl = .{ .ty = int_type } },                  params[2]),
-        .new_value      = try expr(gz, scope, .{ .rl = .{ .coerced_ty = int_type } },           params[3]),
+        .new_value      = try expr(gz, scope, .{ .rl = .{ .coerced_ty = int_type } },          params[3]),
-        .success_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[4]),
+        .success_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[4]),
-        .failure_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = .atomic_order_type } }, params[5]),
+        .failure_order  = try expr(gz, scope, .{ .rl = .{ .coerced_ty = atomic_order_type } }, params[5]),
         // zig fmt: on
     });
     return rvalue(gz, ri, result, node);
 @@ -11106,17 +11124,6 @@ fn rvalueInner(
                 as_ty | @intFromEnum(Zir.Inst.Ref.null_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.undefined_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.enum_literal_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.atomic_order_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.atomic_rmw_op_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.calling_convention_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.address_space_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.float_mode_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.reduce_op_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.call_modifier_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.prefetch_options_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.export_options_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.extern_options_type),
-                as_ty | @intFromEnum(Zir.Inst.Ref.type_info_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.manyptr_u8_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.manyptr_const_u8_type),
                 as_ty | @intFromEnum(Zir.Inst.Ref.manyptr_const_u8_sentinel_0_type),
 @@ -12572,6 +12579,10 @@ const GenZir = struct {
         return new_index;
     }
+    fn addBuiltinValue(gz: *GenZir, src_node: Ast.Node.Index, val: Zir.Inst.BuiltinValue) !Zir.Inst.Ref {
+        return addExtendedNodeSmall(gz, .builtin_value, src_node, @intFromEnum(val));
+    }
     fn addExtendedPayload(gz: *GenZir, opcode: Zir.Inst.Extended, extra: anytype) !Zir.Inst.Ref {
         return addExtendedPayloadSmall(gz, opcode, undefined, extra);
     }

lib/std/zig/Zir.zig+24-14

 @@ -2055,6 +2055,10 @@ pub const Inst = struct {
         /// Guaranteed to not have the `ptr_cast` flag.
         /// Uses the `pl_node` union field with payload `FieldParentPtr`.
         field_parent_ptr,
+        /// Get a type or value from `std.builtin`.
+        /// `operand` is `src_node: i32`.
+        /// `small` is an `Inst.BuiltinValue`.
+        builtin_value,
         pub const InstData = struct {
             opcode: Extended,
 @@ -2071,7 +2075,7 @@ pub const Inst = struct {
         ref_start_index = static_len,
         _,
-        pub const static_len = 84;
+        pub const static_len = 71;
         pub fn toRef(i: Index) Inst.Ref {
             return @enumFromInt(@intFromEnum(Index.ref_start_index) + @intFromEnum(i));
 @@ -2148,17 +2152,6 @@ pub const Inst = struct {
         null_type,
         undefined_type,
         enum_literal_type,
-        atomic_order_type,
-        atomic_rmw_op_type,
-        calling_convention_type,
-        address_space_type,
-        float_mode_type,
-        reduce_op_type,
-        call_modifier_type,
-        prefetch_options_type,
-        export_options_type,
-        extern_options_type,
-        type_info_type,
         manyptr_u8_type,
         manyptr_const_u8_type,
         manyptr_const_u8_sentinel_0_type,
 @@ -2179,8 +2172,6 @@ pub const Inst = struct {
         one_u8,
         four_u8,
         negative_one,
-        calling_convention_c,
-        calling_convention_inline,
         void_value,
         unreachable_value,
         null_value,
 @@ -3146,6 +3137,24 @@ pub const Inst = struct {
         }
     };
+    pub const BuiltinValue = enum(u16) {
+        // Types
+        atomic_order,
+        atomic_rmw_op,
+        calling_convention,
+        address_space,
+        float_mode,
+        reduce_op,
+        call_modifier,
+        prefetch_options,
+        export_options,
+        extern_options,
+        type_info,
+        // Values
+        calling_convention_c,
+        calling_convention_inline,
+    };
     /// Trailing:
     /// 0. tag_type: Ref, // if has_tag_type
     /// 1. captures_len: u32, // if has_captures_len
 @@ -3977,6 +3986,7 @@ fn findDeclsInner(
                 .restore_err_ret_index,
                 .closure_get,
                 .field_parent_ptr,
+                .builtin_value,
                 => return,
                 // `@TypeOf` has a body.

src/Air.zig-13

...	@@ -938,17 +938,6 @@ pub const Inst = struct {	...	@@ -938,17 +938,6 @@ pub const Inst = struct {
938	null_type = @intFromEnum(InternPool.Index.null_type),	938	null_type = @intFromEnum(InternPool.Index.null_type),
939	undefined_type = @intFromEnum(InternPool.Index.undefined_type),	939	undefined_type = @intFromEnum(InternPool.Index.undefined_type),
940	enum_literal_type = @intFromEnum(InternPool.Index.enum_literal_type),	940	enum_literal_type = @intFromEnum(InternPool.Index.enum_literal_type),
941	atomic_order_type = @intFromEnum(InternPool.Index.atomic_order_type),
942	atomic_rmw_op_type = @intFromEnum(InternPool.Index.atomic_rmw_op_type),
943	calling_convention_type = @intFromEnum(InternPool.Index.calling_convention_type),
944	address_space_type = @intFromEnum(InternPool.Index.address_space_type),
945	float_mode_type = @intFromEnum(InternPool.Index.float_mode_type),
946	reduce_op_type = @intFromEnum(InternPool.Index.reduce_op_type),
947	call_modifier_type = @intFromEnum(InternPool.Index.call_modifier_type),
948	prefetch_options_type = @intFromEnum(InternPool.Index.prefetch_options_type),
949	export_options_type = @intFromEnum(InternPool.Index.export_options_type),
950	extern_options_type = @intFromEnum(InternPool.Index.extern_options_type),
951	type_info_type = @intFromEnum(InternPool.Index.type_info_type),
952	manyptr_u8_type = @intFromEnum(InternPool.Index.manyptr_u8_type),	941	manyptr_u8_type = @intFromEnum(InternPool.Index.manyptr_u8_type),
953	manyptr_const_u8_type = @intFromEnum(InternPool.Index.manyptr_const_u8_type),	942	manyptr_const_u8_type = @intFromEnum(InternPool.Index.manyptr_const_u8_type),
954	manyptr_const_u8_sentinel_0_type = @intFromEnum(InternPool.Index.manyptr_const_u8_sentinel_0_type),	943	manyptr_const_u8_sentinel_0_type = @intFromEnum(InternPool.Index.manyptr_const_u8_sentinel_0_type),
...	@@ -969,8 +958,6 @@ pub const Inst = struct {	...	@@ -969,8 +958,6 @@ pub const Inst = struct {
969	one_u8 = @intFromEnum(InternPool.Index.one_u8),	958	one_u8 = @intFromEnum(InternPool.Index.one_u8),
970	four_u8 = @intFromEnum(InternPool.Index.four_u8),	959	four_u8 = @intFromEnum(InternPool.Index.four_u8),
971	negative_one = @intFromEnum(InternPool.Index.negative_one),	960	negative_one = @intFromEnum(InternPool.Index.negative_one),
972	calling_convention_c = @intFromEnum(InternPool.Index.calling_convention_c),
973	calling_convention_inline = @intFromEnum(InternPool.Index.calling_convention_inline),
974	void_value = @intFromEnum(InternPool.Index.void_value),	961	void_value = @intFromEnum(InternPool.Index.void_value),
975	unreachable_value = @intFromEnum(InternPool.Index.unreachable_value),	962	unreachable_value = @intFromEnum(InternPool.Index.unreachable_value),
976	null_value = @intFromEnum(InternPool.Index.null_value),	963	null_value = @intFromEnum(InternPool.Index.null_value),

src/InternPool.zig+2-138

...	@@ -4411,17 +4411,6 @@ pub const Index = enum(u32) {	...	@@ -4411,17 +4411,6 @@ pub const Index = enum(u32) {
4411	null_type,	4411	null_type,
4412	undefined_type,	4412	undefined_type,
4413	enum_literal_type,	4413	enum_literal_type,
4414	atomic_order_type,
4415	atomic_rmw_op_type,
4416	calling_convention_type,
4417	address_space_type,
4418	float_mode_type,
4419	reduce_op_type,
4420	call_modifier_type,
4421	prefetch_options_type,
4422	export_options_type,
4423	extern_options_type,
4424	type_info_type,
4425	manyptr_u8_type,	4414	manyptr_u8_type,
4426	manyptr_const_u8_type,	4415	manyptr_const_u8_type,
4427	manyptr_const_u8_sentinel_0_type,	4416	manyptr_const_u8_sentinel_0_type,
...	@@ -4454,10 +4443,6 @@ pub const Index = enum(u32) {	...	@@ -4454,10 +4443,6 @@ pub const Index = enum(u32) {
4454	four_u8,	4443	four_u8,
4455	/// `-1` (comptime_int)	4444	/// `-1` (comptime_int)
4456	negative_one,	4445	negative_one,
4457	/// `std.builtin.CallingConvention.C`
4458	calling_convention_c,
4459	/// `std.builtin.CallingConvention.Inline`
4460	calling_convention_inline,
4461	/// `{}`	4446	/// `{}`
4462	void_value,	4447	void_value,
4463	/// `unreachable` (noreturn type)	4448	/// `unreachable` (noreturn type)
...	@@ -4837,17 +4822,6 @@ pub const static_keys = [_]Key{	...	@@ -4837,17 +4822,6 @@ pub const static_keys = [_]Key{
4837	.{ .simple_type = .null },	4822	.{ .simple_type = .null },
4838	.{ .simple_type = .undefined },	4823	.{ .simple_type = .undefined },
4839	.{ .simple_type = .enum_literal },	4824	.{ .simple_type = .enum_literal },
4840	.{ .simple_type = .atomic_order },
4841	.{ .simple_type = .atomic_rmw_op },
4842	.{ .simple_type = .calling_convention },
4843	.{ .simple_type = .address_space },
4844	.{ .simple_type = .float_mode },
4845	.{ .simple_type = .reduce_op },
4846	.{ .simple_type = .call_modifier },
4847	.{ .simple_type = .prefetch_options },
4848	.{ .simple_type = .export_options },
4849	.{ .simple_type = .extern_options },
4850	.{ .simple_type = .type_info },
4851		4825
4852	// [*]u8	4826	// [*]u8
4853	.{ .ptr_type = .{	4827	.{ .ptr_type = .{
...	@@ -4876,7 +4850,7 @@ pub const static_keys = [_]Key{	...	@@ -4876,7 +4850,7 @@ pub const static_keys = [_]Key{
4876	},	4850	},
4877	} },	4851	} },
4878		4852
4879	// comptime_int	4853	// *const comptime_int
4880	.{ .ptr_type = .{	4854	.{ .ptr_type = .{
4881	.child = .comptime_int_type,	4855	.child = .comptime_int_type,
4882	.flags = .{	4856	.flags = .{
...	@@ -4967,16 +4941,6 @@ pub const static_keys = [_]Key{	...	@@ -4967,16 +4941,6 @@ pub const static_keys = [_]Key{
4967	.ty = .comptime_int_type,	4941	.ty = .comptime_int_type,
4968	.storage = .{ .i64 = -1 },	4942	.storage = .{ .i64 = -1 },
4969	} },	4943	} },
4970	// calling_convention_c
4971	.{ .enum_tag = .{
4972	.ty = .calling_convention_type,
4973	.int = .one_u8,
4974	} },
4975	// calling_convention_inline
4976	.{ .enum_tag = .{
4977	.ty = .calling_convention_type,
4978	.int = .four_u8,
4979	} },
4980		4944
4981	.{ .simple_value = .void },	4945	.{ .simple_value = .void },
4982	.{ .simple_value = .@"unreachable" },	4946	.{ .simple_value = .@"unreachable" },
...	@@ -5690,18 +5654,6 @@ pub const SimpleType = enum(u32) {	...	@@ -5690,18 +5654,6 @@ pub const SimpleType = enum(u32) {
5690	undefined = @intFromEnum(Index.undefined_type),	5654	undefined = @intFromEnum(Index.undefined_type),
5691	enum_literal = @intFromEnum(Index.enum_literal_type),	5655	enum_literal = @intFromEnum(Index.enum_literal_type),
5692		5656
5693	atomic_order = @intFromEnum(Index.atomic_order_type),
5694	atomic_rmw_op = @intFromEnum(Index.atomic_rmw_op_type),
5695	calling_convention = @intFromEnum(Index.calling_convention_type),
5696	address_space = @intFromEnum(Index.address_space_type),
5697	float_mode = @intFromEnum(Index.float_mode_type),
5698	reduce_op = @intFromEnum(Index.reduce_op_type),
5699	call_modifier = @intFromEnum(Index.call_modifier_type),
5700	prefetch_options = @intFromEnum(Index.prefetch_options_type),
5701	export_options = @intFromEnum(Index.export_options_type),
5702	extern_options = @intFromEnum(Index.extern_options_type),
5703	type_info = @intFromEnum(Index.type_info_type),
5704
5705	adhoc_inferred_error_set = @intFromEnum(Index.adhoc_inferred_error_set_type),	5657	adhoc_inferred_error_set = @intFromEnum(Index.adhoc_inferred_error_set_type),
5706	generic_poison = @intFromEnum(Index.generic_poison_type),	5658	generic_poison = @intFromEnum(Index.generic_poison_type),
5707	};	5659	};
...	@@ -6281,18 +6233,6 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {	...	@@ -6281,18 +6233,6 @@ pub fn init(ip: *InternPool, gpa: Allocator, available_threads: usize) !void {
6281	// Sanity check.	6233	// Sanity check.
6282	assert(ip.indexToKey(.bool_true).simple_value == .true);	6234	assert(ip.indexToKey(.bool_true).simple_value == .true);
6283	assert(ip.indexToKey(.bool_false).simple_value == .false);	6235	assert(ip.indexToKey(.bool_false).simple_value == .false);
6284
6285	const cc_inline = ip.indexToKey(.calling_convention_inline).enum_tag.int;
6286	const cc_c = ip.indexToKey(.calling_convention_c).enum_tag.int;
6287
6288	assert(ip.indexToKey(cc_inline).int.storage.u64 ==
6289	@intFromEnum(std.builtin.CallingConvention.Inline));
6290
6291	assert(ip.indexToKey(cc_c).int.storage.u64 ==
6292	@intFromEnum(std.builtin.CallingConvention.C));
6293
6294	assert(ip.indexToKey(ip.typeOf(cc_inline)).int_type.bits ==
6295	@typeInfo(@typeInfo(std.builtin.CallingConvention).Enum.tag_type).Int.bits);
6296	}	6236	}
6297	}	6237	}
6298		6238
...	@@ -9743,14 +9683,6 @@ fn addMap(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, cap: usize) Al	...	@@ -9743,14 +9683,6 @@ fn addMap(ip: *InternPool, gpa: Allocator, tid: Zcu.PerThread.Id, cap: usize) Al
9743	/// Invalidates all references to this index.	9683	/// Invalidates all references to this index.
9744	pub fn remove(ip: *InternPool, tid: Zcu.PerThread.Id, index: Index) void {	9684	pub fn remove(ip: *InternPool, tid: Zcu.PerThread.Id, index: Index) void {
9745	const unwrapped_index = index.unwrap(ip);	9685	const unwrapped_index = index.unwrap(ip);
9746	if (@intFromEnum(index) < static_keys.len) {
9747	// The item being removed replaced a special index via `InternPool.resolveBuiltinType`.
9748	// Restore the original item at this index.
9749	assert(static_keys[@intFromEnum(index)] == .simple_type);
9750	const items = ip.getLocalShared(unwrapped_index.tid).items.acquire().view();
9751	@atomicStore(Tag, &items.items(.tag)[unwrapped_index.index], .simple_type, .unordered);
9752	return;
9753	}
9754		9686
9755	if (unwrapped_index.tid == tid) {	9687	if (unwrapped_index.tid == tid) {
9756	const items_len = &ip.getLocal(unwrapped_index.tid).mutate.items.len;	9688	const items_len = &ip.getLocal(unwrapped_index.tid).mutate.items.len;
...	@@ -10390,17 +10322,7 @@ pub fn isIntegerType(ip: *const InternPool, ty: Index) bool {	...	@@ -10390,17 +10322,7 @@ pub fn isIntegerType(ip: *const InternPool, ty: Index) bool {
10390		10322
10391	/// does not include .enum_literal_type	10323	/// does not include .enum_literal_type
10392	pub fn isEnumType(ip: *const InternPool, ty: Index) bool {	10324	pub fn isEnumType(ip: *const InternPool, ty: Index) bool {
10393	return switch (ty) {	10325	return ip.indexToKey(ty) == .enum_type;
10394	.atomic_order_type,
10395	.atomic_rmw_op_type,
10396	.calling_convention_type,
10397	.address_space_type,
10398	.float_mode_type,
10399	.reduce_op_type,
10400	.call_modifier_type,
10401	=> true,
10402	else => ip.indexToKey(ty) == .enum_type,
10403	};
10404	}	10326	}
10405		10327
10406	pub fn isUnion(ip: *const InternPool, ty: Index) bool {	10328	pub fn isUnion(ip: *const InternPool, ty: Index) bool {
...	@@ -11401,17 +11323,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {	...	@@ -11401,17 +11323,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
11401	.null_type,	11323	.null_type,
11402	.undefined_type,	11324	.undefined_type,
11403	.enum_literal_type,	11325	.enum_literal_type,
11404	.atomic_order_type,
11405	.atomic_rmw_op_type,
11406	.calling_convention_type,
11407	.address_space_type,
11408	.float_mode_type,
11409	.reduce_op_type,
11410	.call_modifier_type,
11411	.prefetch_options_type,
11412	.export_options_type,
11413	.extern_options_type,
11414	.type_info_type,
11415	.manyptr_u8_type,	11326	.manyptr_u8_type,
11416	.manyptr_const_u8_type,	11327	.manyptr_const_u8_type,
11417	.manyptr_const_u8_sentinel_0_type,	11328	.manyptr_const_u8_sentinel_0_type,
...	@@ -11429,7 +11340,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {	...	@@ -11429,7 +11340,6 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
11429	.zero, .one, .negative_one => .comptime_int_type,	11340	.zero, .one, .negative_one => .comptime_int_type,
11430	.zero_usize, .one_usize => .usize_type,	11341	.zero_usize, .one_usize => .usize_type,
11431	.zero_u8, .one_u8, .four_u8 => .u8_type,	11342	.zero_u8, .one_u8, .four_u8 => .u8_type,
11432	.calling_convention_c, .calling_convention_inline => .calling_convention_type,
11433	.void_value => .void_type,	11343	.void_value => .void_type,
11434	.unreachable_value => .noreturn_type,	11344	.unreachable_value => .noreturn_type,
11435	.null_value => .null_type,	11345	.null_value => .null_type,
...	@@ -11725,22 +11635,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois	...	@@ -11725,22 +11635,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois
11725	.undefined_type => .Undefined,	11635	.undefined_type => .Undefined,
11726	.enum_literal_type => .EnumLiteral,	11636	.enum_literal_type => .EnumLiteral,
11727		11637
11728	.atomic_order_type,
11729	.atomic_rmw_op_type,
11730	.calling_convention_type,
11731	.address_space_type,
11732	.float_mode_type,
11733	.reduce_op_type,
11734	.call_modifier_type,
11735	=> .Enum,
11736
11737	.prefetch_options_type,
11738	.export_options_type,
11739	.extern_options_type,
11740	=> .Struct,
11741
11742	.type_info_type => .Union,
11743
11744	.manyptr_u8_type,	11638	.manyptr_u8_type,
11745	.manyptr_const_u8_type,	11639	.manyptr_const_u8_type,
11746	.manyptr_const_u8_sentinel_0_type,	11640	.manyptr_const_u8_sentinel_0_type,
...	@@ -11765,8 +11659,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois	...	@@ -11765,8 +11659,6 @@ pub fn zigTypeTagOrPoison(ip: *const InternPool, index: Index) error{GenericPois
11765	.one_u8 => unreachable,	11659	.one_u8 => unreachable,
11766	.four_u8 => unreachable,	11660	.four_u8 => unreachable,
11767	.negative_one => unreachable,	11661	.negative_one => unreachable,
11768	.calling_convention_c => unreachable,
11769	.calling_convention_inline => unreachable,
11770	.void_value => unreachable,	11662	.void_value => unreachable,
11771	.unreachable_value => unreachable,	11663	.unreachable_value => unreachable,
11772	.null_value => unreachable,	11664	.null_value => unreachable,
...	@@ -12085,34 +11977,6 @@ pub fn unwrapCoercedFunc(ip: *const InternPool, index: Index) Index {	...	@@ -12085,34 +11977,6 @@ pub fn unwrapCoercedFunc(ip: *const InternPool, index: Index) Index {
12085	};	11977	};
12086	}	11978	}
12087		11979
12088	/// Having resolved a builtin type to a real struct/union/enum (which is now at `resolverd_index`),
12089	/// make `want_index` refer to this type instead. This invalidates `resolved_index`, so must be
12090	/// called only when it is guaranteed that no reference to `resolved_index` exists.
12091	pub fn resolveBuiltinType(
12092	ip: *InternPool,
12093	tid: Zcu.PerThread.Id,
12094	want_index: Index,
12095	resolved_index: Index,
12096	) void {
12097	assert(@intFromEnum(want_index) >= @intFromEnum(Index.first_type));
12098	assert(@intFromEnum(want_index) <= @intFromEnum(Index.last_type));
12099
12100	// Make sure the type isn't already resolved!
12101	assert(ip.indexToKey(want_index) == .simple_type);
12102
12103	// Make sure it's the same kind of type
12104	assert((ip.zigTypeTagOrPoison(want_index) catch unreachable) ==
12105	(ip.zigTypeTagOrPoison(resolved_index) catch unreachable));
12106
12107	// Copy the data
12108	const item = resolved_index.unwrap(ip).getItem(ip);
12109	const unwrapped_index = want_index.unwrap(ip);
12110	var items = ip.getLocalShared(unwrapped_index.tid).items.acquire().view().slice();
12111	items.items(.data)[unwrapped_index.index] = item.data;
12112	@atomicStore(Tag, &items.items(.tag)[unwrapped_index.index], item.tag, .release);
12113	ip.remove(tid, resolved_index);
12114	}
12115
12116	pub fn anonStructFieldTypes(ip: *const InternPool, i: Index) []const Index {	11980	pub fn anonStructFieldTypes(ip: *const InternPool, i: Index) []const Index {
12117	return ip.indexToKey(i).anon_struct_type.types;	11981	return ip.indexToKey(i).anon_struct_type.types;
12118	}	11982	}

src/Sema.zig+52-39

 @@ -76,10 +76,6 @@ no_partial_func_ty: bool = false,
 /// here so the values can be dropped without any cleanup.
 unresolved_inferred_allocs: std.AutoArrayHashMapUnmanaged(Air.Inst.Index, InferredAlloc) = .{},
-/// While analyzing a type which has a special InternPool index, this is set to the index at which
-/// the struct/enum/union type created should be placed. Otherwise, it is `.none`.
-builtin_type_target_index: InternPool.Index = .none,
 /// Links every pointer derived from a base `alloc` back to that `alloc`. Used
 /// to detect comptime-known `const`s.
 /// TODO: ZIR liveness analysis would allow us to remove elements from this map.
 @@ -1327,6 +1323,7 @@ fn analyzeBodyInner(
                     },
                     .value_placeholder => unreachable, // never appears in a body
                     .field_parent_ptr => try sema.zirFieldParentPtr(block, extended),
+                    .builtin_value => try sema.zirBuiltinValue(extended),
                 };
             },
 @@ -2712,17 +2709,6 @@ fn getCaptures(sema: *Sema, block: *Block, type_src: LazySrcLoc, extra_index: us
     return captures;
 }
-/// Given an `InternPool.WipNamespaceType` or `InternPool.WipEnumType`, apply
-/// `sema.builtin_type_target_index` to it if necessary.
-fn wrapWipTy(sema: *Sema, wip_ty: anytype) @TypeOf(wip_ty) {
-    const pt = sema.pt;
-    if (sema.builtin_type_target_index == .none) return wip_ty;
-    var new = wip_ty;
-    new.index = sema.builtin_type_target_index;
-    pt.zcu.intern_pool.resolveBuiltinType(pt.tid, new.index, wip_ty.index);
-    return new;
-}
 fn zirStructDecl(
     sema: *Sema,
     block: *Block,
 @@ -2788,7 +2774,7 @@ fn zirStructDecl(
             .captures = captures,
         } },
     };
-    const wip_ty = sema.wrapWipTy(switch (try ip.getStructType(gpa, pt.tid, struct_init, false)) {
+    const wip_ty = switch (try ip.getStructType(gpa, pt.tid, struct_init, false)) {
         .existing => |ty| {
             const new_ty = try pt.ensureTypeUpToDate(ty, false);
 @@ -2801,7 +2787,7 @@ fn zirStructDecl(
             return Air.internedToRef(new_ty);
         },
         .wip => |wip| wip,
-    });
+    };
     errdefer wip_ty.cancel(ip, pt.tid);
     wip_ty.setName(ip, try sema.createTypeName(
 @@ -3017,7 +3003,7 @@ fn zirEnumDecl(
             .captures = captures,
         } },
     };
-    const wip_ty = sema.wrapWipTy(switch (try ip.getEnumType(gpa, pt.tid, enum_init, false)) {
+    const wip_ty = switch (try ip.getEnumType(gpa, pt.tid, enum_init, false)) {
         .existing => |ty| {
             const new_ty = try pt.ensureTypeUpToDate(ty, false);
 @@ -3030,7 +3016,7 @@ fn zirEnumDecl(
             return Air.internedToRef(new_ty);
         },
         .wip => |wip| wip,
-    });
+    };
     // Once this is `true`, we will not delete the decl or type even upon failure, since we
     // have finished constructing the type and are in the process of analyzing it.
 @@ -3161,7 +3147,7 @@ fn zirUnionDecl(
             .captures = captures,
         } },
     };
-    const wip_ty = sema.wrapWipTy(switch (try ip.getUnionType(gpa, pt.tid, union_init, false)) {
+    const wip_ty = switch (try ip.getUnionType(gpa, pt.tid, union_init, false)) {
         .existing => |ty| {
             const new_ty = try pt.ensureTypeUpToDate(ty, false);
 @@ -3174,7 +3160,7 @@ fn zirUnionDecl(
             return Air.internedToRef(new_ty);
         },
         .wip => |wip| wip,
-    });
+    };
     errdefer wip_ty.cancel(ip, pt.tid);
     wip_ty.setName(ip, try sema.createTypeName(
 @@ -3259,7 +3245,6 @@ fn zirOpaqueDecl(
             .captures = captures,
         } },
     };
-    // No `wrapWipTy` needed as no std.builtin types are opaque.
     const wip_ty = switch (try ip.getOpaqueType(gpa, pt.tid, opaque_init)) {
         .existing => |ty| {
             // Make sure we update the namespace if the declaration is re-analyzed, to pick
 @@ -26179,7 +26164,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
         const body = sema.code.bodySlice(extra_index, body_len);
         extra_index += body.len;
-        const addrspace_ty = Type.fromInterned(.address_space_type);
+        const addrspace_ty = try pt.getBuiltinType("AddressSpace");
         const val = try sema.resolveGenericBody(block, addrspace_src, body, inst, addrspace_ty, .{
             .needed_comptime_reason = "addrspace must be comptime-known",
         });
 @@ -26190,7 +26175,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     } else if (extra.data.bits.has_addrspace_ref) blk: {
         const addrspace_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
-        const addrspace_ty = Type.fromInterned(.address_space_type);
+        const addrspace_ty = try pt.getBuiltinType("AddressSpace");
         const uncoerced_addrspace = sema.resolveInst(addrspace_ref) catch |err| switch (err) {
             error.GenericPoison => break :blk null,
             else => |e| return e,
 @@ -26255,7 +26240,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A
     } else if (extra.data.bits.has_cc_ref) blk: {
         const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]);
         extra_index += 1;
-        const cc_ty = Type.fromInterned(.calling_convention_type);
+        const cc_ty = try pt.getBuiltinType("CallingConvention");
         const uncoerced_cc = sema.resolveInst(cc_ref) catch |err| switch (err) {
             error.GenericPoison => break :blk null,
             else => |e| return e,
 @@ -26713,6 +26698,46 @@ fn zirInComptime(
     return if (block.is_comptime) .bool_true else .bool_false;
 }
+fn zirBuiltinValue(sema: *Sema, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref {
+    const pt = sema.pt;
+    const value: Zir.Inst.BuiltinValue = @enumFromInt(extended.small);
+    const type_name = switch (value) {
+        .atomic_order => "AtomicOrder",
+        .atomic_rmw_op => "AtomicRmwOp",
+        .calling_convention => "CallingConvention",
+        .address_space => "AddressSpace",
+        .float_mode => "FloatMode",
+        .reduce_op => "ReduceOp",
+        .call_modifier => "CallModifier",
+        .prefetch_options => "PrefetchOptions",
+        .export_options => "ExportOptions",
+        .extern_options => "ExternOptions",
+        .type_info => "Type",
+        // Values are handled here.
+        .calling_convention_c => {
+            const callconv_ty = try pt.getBuiltinType("CallingConvention");
+            comptime assert(@intFromEnum(std.builtin.CallingConvention.C) == 1);
+            const val = try pt.intern(.{ .enum_tag = .{
+                .ty = callconv_ty.toIntern(),
+                .int = .one_u8,
+            } });
+            return Air.internedToRef(val);
+        },
+        .calling_convention_inline => {
+            const callconv_ty = try pt.getBuiltinType("CallingConvention");
+            comptime assert(@intFromEnum(std.builtin.CallingConvention.Inline) == 4);
+            const val = try pt.intern(.{ .enum_tag = .{
+                .ty = callconv_ty.toIntern(),
+                .int = .four_u8,
+            } });
+            return Air.internedToRef(val);
+        },
+    };
+    const ty = try pt.getBuiltinType(type_name);
+    return Air.internedToRef(ty.toIntern());
+}
 fn requireRuntimeBlock(sema: *Sema, block: *Block, src: LazySrcLoc, runtime_src: ?LazySrcLoc) !void {
     if (block.is_comptime) {
         const msg = msg: {
 @@ -36899,17 +36924,6 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .comptime_int_type,
         .comptime_float_type,
         .enum_literal_type,
-        .atomic_order_type,
-        .atomic_rmw_op_type,
-        .calling_convention_type,
-        .address_space_type,
-        .float_mode_type,
-        .reduce_op_type,
-        .call_modifier_type,
-        .prefetch_options_type,
-        .export_options_type,
-        .extern_options_type,
-        .type_info_type,
         .manyptr_u8_type,
         .manyptr_const_u8_type,
         .manyptr_const_u8_sentinel_0_type,
 @@ -36936,8 +36950,6 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
         .one_u8,
         .four_u8,
         .negative_one,
-        .calling_convention_c,
-        .calling_convention_inline,
         .void_value,
         .unreachable_value,
         .null_value,
 @@ -37291,7 +37303,8 @@ pub fn analyzeAsAddressSpace(
 ) !std.builtin.AddressSpace {
     const pt = sema.pt;
     const mod = pt.zcu;
-    const coerced = try sema.coerce(block, Type.fromInterned(.address_space_type), air_ref, src);
+    const addrspace_ty = try pt.getBuiltinType("AddressSpace");
+    const coerced = try sema.coerce(block, addrspace_ty, air_ref, src);
     const addrspace_val = try sema.resolveConstDefinedValue(block, src, coerced, .{
         .needed_comptime_reason = "address space must be comptime-known",
     });

src/Type.zig+1-129

...	@@ -316,17 +316,6 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error	...	@@ -316,17 +316,6 @@ pub fn print(ty: Type, writer: anytype, pt: Zcu.PerThread) @TypeOf(writer).Error
316	=> try writer.print("@TypeOf({s})", .{@tagName(s)}),	316	=> try writer.print("@TypeOf({s})", .{@tagName(s)}),
317		317
318	.enum_literal => try writer.print("@TypeOf(.{s})", .{@tagName(s)}),	318	.enum_literal => try writer.print("@TypeOf(.{s})", .{@tagName(s)}),
319	.atomic_order => try writer.writeAll("std.builtin.AtomicOrder"),
320	.atomic_rmw_op => try writer.writeAll("std.builtin.AtomicRmwOp"),
321	.calling_convention => try writer.writeAll("std.builtin.CallingConvention"),
322	.address_space => try writer.writeAll("std.builtin.AddressSpace"),
323	.float_mode => try writer.writeAll("std.builtin.FloatMode"),
324	.reduce_op => try writer.writeAll("std.builtin.ReduceOp"),
325	.call_modifier => try writer.writeAll("std.builtin.CallModifier"),
326	.prefetch_options => try writer.writeAll("std.builtin.PrefetchOptions"),
327	.export_options => try writer.writeAll("std.builtin.ExportOptions"),
328	.extern_options => try writer.writeAll("std.builtin.ExternOptions"),
329	.type_info => try writer.writeAll("std.builtin.Type"),
330		319
331	.generic_poison => unreachable,	320	.generic_poison => unreachable,
332	},	321	},
...	@@ -544,16 +533,6 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -544,16 +533,6 @@ pub fn hasRuntimeBitsAdvanced(
544	.anyerror,	533	.anyerror,
545	.adhoc_inferred_error_set,	534	.adhoc_inferred_error_set,
546	.anyopaque,	535	.anyopaque,
547	.atomic_order,
548	.atomic_rmw_op,
549	.calling_convention,
550	.address_space,
551	.float_mode,
552	.reduce_op,
553	.call_modifier,
554	.prefetch_options,
555	.export_options,
556	.extern_options,
557	=> true,	536	=> true,
558		537
559	// These are false because they are comptime-only types.	538	// These are false because they are comptime-only types.
...	@@ -565,7 +544,6 @@ pub fn hasRuntimeBitsAdvanced(	...	@@ -565,7 +544,6 @@ pub fn hasRuntimeBitsAdvanced(
565	.null,	544	.null,
566	.undefined,	545	.undefined,
567	.enum_literal,	546	.enum_literal,
568	.type_info,
569	=> false,	547	=> false,
570		548
571	.generic_poison => unreachable,	549	.generic_poison => unreachable,
...	@@ -711,16 +689,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {	...	@@ -711,16 +689,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {
711	.anyerror,	689	.anyerror,
712	.adhoc_inferred_error_set,	690	.adhoc_inferred_error_set,
713	.anyopaque,	691	.anyopaque,
714	.atomic_order,
715	.atomic_rmw_op,
716	.calling_convention,
717	.address_space,
718	.float_mode,
719	.reduce_op,
720	.call_modifier,
721	.prefetch_options,
722	.export_options,
723	.extern_options,
724	.type,	692	.type,
725	.comptime_int,	693	.comptime_int,
726	.comptime_float,	694	.comptime_float,
...	@@ -728,7 +696,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {	...	@@ -728,7 +696,6 @@ pub fn hasWellDefinedLayout(ty: Type, mod: *Module) bool {
728	.null,	696	.null,
729	.undefined,	697	.undefined,
730	.enum_literal,	698	.enum_literal,
731	.type_info,
732	.generic_poison,	699	.generic_poison,
733	=> false,	700	=> false,
734	},	701	},
...	@@ -972,14 +939,6 @@ pub fn abiAlignmentAdvanced(	...	@@ -972,14 +939,6 @@ pub fn abiAlignmentAdvanced(
972		939
973	.simple_type => \|t\| switch (t) {	940	.simple_type => \|t\| switch (t) {
974	.bool,	941	.bool,
975	.atomic_order,
976	.atomic_rmw_op,
977	.calling_convention,
978	.address_space,
979	.float_mode,
980	.reduce_op,
981	.call_modifier,
982	.prefetch_options,
983	.anyopaque,	942	.anyopaque,
984	=> return .{ .scalar = .@"1" },	943	=> return .{ .scalar = .@"1" },
985		944
...	@@ -987,11 +946,6 @@ pub fn abiAlignmentAdvanced(	...	@@ -987,11 +946,6 @@ pub fn abiAlignmentAdvanced(
987	.isize,	946	.isize,
988	=> return .{ .scalar = intAbiAlignment(target.ptrBitWidth(), target, use_llvm) },	947	=> return .{ .scalar = intAbiAlignment(target.ptrBitWidth(), target, use_llvm) },
989		948
990	.export_options,
991	.extern_options,
992	.type_info,
993	=> return .{ .scalar = ptrAbiAlignment(target) },
994
995	.c_char => return .{ .scalar = cTypeAlign(target, .char) },	949	.c_char => return .{ .scalar = cTypeAlign(target, .char) },
996	.c_short => return .{ .scalar = cTypeAlign(target, .short) },	950	.c_short => return .{ .scalar = cTypeAlign(target, .short) },
997	.c_ushort => return .{ .scalar = cTypeAlign(target, .ushort) },	951	.c_ushort => return .{ .scalar = cTypeAlign(target, .ushort) },
...	@@ -1352,15 +1306,7 @@ pub fn abiSizeAdvanced(	...	@@ -1352,15 +1306,7 @@ pub fn abiSizeAdvanced(
1352	},	1306	},
1353	.func_type => unreachable, // represents machine code; not a pointer	1307	.func_type => unreachable, // represents machine code; not a pointer
1354	.simple_type => \|t\| switch (t) {	1308	.simple_type => \|t\| switch (t) {
1355	.bool,	1309	.bool => return .{ .scalar = 1 },
1356	.atomic_order,
1357	.atomic_rmw_op,
1358	.calling_convention,
1359	.address_space,
1360	.float_mode,
1361	.reduce_op,
1362	.call_modifier,
1363	=> return .{ .scalar = 1 },
1364		1310
1365	.f16 => return .{ .scalar = 2 },	1311	.f16 => return .{ .scalar = 2 },
1366	.f32 => return .{ .scalar = 4 },	1312	.f32 => return .{ .scalar = 4 },
...	@@ -1402,11 +1348,6 @@ pub fn abiSizeAdvanced(	...	@@ -1402,11 +1348,6 @@ pub fn abiSizeAdvanced(
1402	return .{ .scalar = intAbiSize(bits, target, use_llvm) };	1348	return .{ .scalar = intAbiSize(bits, target, use_llvm) };
1403	},	1349	},
1404		1350
1405	.prefetch_options => unreachable, // missing call to resolveTypeFields
1406	.export_options => unreachable, // missing call to resolveTypeFields
1407	.extern_options => unreachable, // missing call to resolveTypeFields
1408
1409	.type_info => unreachable,
1410	.noreturn => unreachable,	1351	.noreturn => unreachable,
1411	.generic_poison => unreachable,	1352	.generic_poison => unreachable,
1412	},	1353	},
...	@@ -1751,18 +1692,6 @@ pub fn bitSizeAdvanced(	...	@@ -1751,18 +1692,6 @@ pub fn bitSizeAdvanced(
1751	.undefined => unreachable,	1692	.undefined => unreachable,
1752	.enum_literal => unreachable,	1693	.enum_literal => unreachable,
1753	.generic_poison => unreachable,	1694	.generic_poison => unreachable,
1754
1755	.atomic_order => unreachable,
1756	.atomic_rmw_op => unreachable,
1757	.calling_convention => unreachable,
1758	.address_space => unreachable,
1759	.float_mode => unreachable,
1760	.reduce_op => unreachable,
1761	.call_modifier => unreachable,
1762	.prefetch_options => unreachable,
1763	.export_options => unreachable,
1764	.extern_options => unreachable,
1765	.type_info => unreachable,
1766	},	1695	},
1767	.struct_type => {	1696	.struct_type => {
1768	const struct_type = ip.loadStructType(ty.toIntern());	1697	const struct_type = ip.loadStructType(ty.toIntern());
...	@@ -2565,17 +2494,6 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {	...	@@ -2565,17 +2494,6 @@ pub fn onePossibleValue(starting_type: Type, pt: Zcu.PerThread) !?Value {
2565	.comptime_int,	2494	.comptime_int,
2566	.comptime_float,	2495	.comptime_float,
2567	.enum_literal,	2496	.enum_literal,
2568	.atomic_order,
2569	.atomic_rmw_op,
2570	.calling_convention,
2571	.address_space,
2572	.float_mode,
2573	.reduce_op,
2574	.call_modifier,
2575	.prefetch_options,
2576	.export_options,
2577	.extern_options,
2578	.type_info,
2579	.adhoc_inferred_error_set,	2497	.adhoc_inferred_error_set,
2580	=> return null,	2498	=> return null,
2581		2499
...	@@ -2782,16 +2700,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2782,16 +2700,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2782	.adhoc_inferred_error_set,	2700	.adhoc_inferred_error_set,
2783	.noreturn,	2701	.noreturn,
2784	.generic_poison,	2702	.generic_poison,
2785	.atomic_order,
2786	.atomic_rmw_op,
2787	.calling_convention,
2788	.address_space,
2789	.float_mode,
2790	.reduce_op,
2791	.call_modifier,
2792	.prefetch_options,
2793	.export_options,
2794	.extern_options,
2795	=> false,	2703	=> false,
2796		2704
2797	.type,	2705	.type,
...	@@ -2800,7 +2708,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve	...	@@ -2800,7 +2708,6 @@ pub fn comptimeOnlyAdvanced(ty: Type, pt: Zcu.PerThread, comptime strat: Resolve
2800	.null,	2708	.null,
2801	.undefined,	2709	.undefined,
2802	.enum_literal,	2710	.enum_literal,
2803	.type_info,
2804	=> true,	2711	=> true,
2805	},	2712	},
2806	.struct_type => {	2713	.struct_type => {
...	@@ -3534,10 +3441,6 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:	...	@@ -3534,10 +3441,6 @@ pub fn packedStructFieldPtrInfo(struct_ty: Type, parent_ptr_ty: Type, field_idx:
3534	pub fn resolveLayout(ty: Type, pt: Zcu.PerThread) SemaError!void {	3441	pub fn resolveLayout(ty: Type, pt: Zcu.PerThread) SemaError!void {
3535	const zcu = pt.zcu;	3442	const zcu = pt.zcu;
3536	const ip = &zcu.intern_pool;	3443	const ip = &zcu.intern_pool;
3537	switch (ip.indexToKey(ty.toIntern())) {
3538	.simple_type => \|simple_type\| return resolveSimpleType(simple_type, pt),
3539	else => {},
3540	}
3541	switch (ty.zigTypeTag(zcu)) {	3444	switch (ty.zigTypeTag(zcu)) {
3542	.Struct => switch (ip.indexToKey(ty.toIntern())) {	3445	.Struct => switch (ip.indexToKey(ty.toIntern())) {
3543	.anon_struct_type => \|anon_struct_type\| for (0..anon_struct_type.types.len) \|i\| {	3446	.anon_struct_type => \|anon_struct_type\| for (0..anon_struct_type.types.len) \|i\| {
...	@@ -3651,8 +3554,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {	...	@@ -3651,8 +3554,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {
3651	.one_u8 => unreachable,	3554	.one_u8 => unreachable,
3652	.four_u8 => unreachable,	3555	.four_u8 => unreachable,
3653	.negative_one => unreachable,	3556	.negative_one => unreachable,
3654	.calling_convention_c => unreachable,
3655	.calling_convention_inline => unreachable,
3656	.void_value => unreachable,	3557	.void_value => unreachable,
3657	.unreachable_value => unreachable,	3558	.unreachable_value => unreachable,
3658	.null_value => unreachable,	3559	.null_value => unreachable,
...	@@ -3669,8 +3570,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {	...	@@ -3669,8 +3570,6 @@ pub fn resolveFields(ty: Type, pt: Zcu.PerThread) SemaError!void {
3669		3570
3670	.type_union => return ty.resolveUnionInner(pt, .fields),	3571	.type_union => return ty.resolveUnionInner(pt, .fields),
3671		3572
3672	.simple_type => return resolveSimpleType(ip.indexToKey(ty_ip).simple_type, pt),
3673
3674	else => {},	3573	else => {},
3675	},	3574	},
3676	}	3575	}
...	@@ -3680,11 +3579,6 @@ pub fn resolveFully(ty: Type, pt: Zcu.PerThread) SemaError!void {	...	@@ -3680,11 +3579,6 @@ pub fn resolveFully(ty: Type, pt: Zcu.PerThread) SemaError!void {
3680	const zcu = pt.zcu;	3579	const zcu = pt.zcu;
3681	const ip = &zcu.intern_pool;	3580	const ip = &zcu.intern_pool;
3682		3581
3683	switch (ip.indexToKey(ty.toIntern())) {
3684	.simple_type => \|simple_type\| return resolveSimpleType(simple_type, pt),
3685	else => {},
3686	}
3687
3688	switch (ty.zigTypeTag(zcu)) {	3582	switch (ty.zigTypeTag(zcu)) {
3689	.Type,	3583	.Type,
3690	.Void,	3584	.Void,
...	@@ -3850,28 +3744,6 @@ fn resolveUnionInner(	...	@@ -3850,28 +3744,6 @@ fn resolveUnionInner(
3850	};	3744	};
3851	}	3745	}
3852		3746
3853	/// Fully resolves a simple type. This is usually a nop, but for builtin types with
3854	/// special InternPool indices (such as std.builtin.Type) it will analyze and fully
3855	/// resolve the type.
3856	fn resolveSimpleType(simple_type: InternPool.SimpleType, pt: Zcu.PerThread) Allocator.Error!void {
3857	const builtin_type_name: []const u8 = switch (simple_type) {
3858	.atomic_order => "AtomicOrder",
3859	.atomic_rmw_op => "AtomicRmwOp",
3860	.calling_convention => "CallingConvention",
3861	.address_space => "AddressSpace",
3862	.float_mode => "FloatMode",
3863	.reduce_op => "ReduceOp",
3864	.call_modifier => "CallModifer",
3865	.prefetch_options => "PrefetchOptions",
3866	.export_options => "ExportOptions",
3867	.extern_options => "ExternOptions",
3868	.type_info => "Type",
3869	else => return,
3870	};
3871	// This will fully resolve the type.
3872	_ = try pt.getBuiltinType(builtin_type_name);
3873	}
3874
3875	/// Returns the type of a pointer to an element.	3747	/// Returns the type of a pointer to an element.
3876	/// Asserts that the type is a pointer, and that the element type is indexable.	3748	/// Asserts that the type is a pointer, and that the element type is indexable.
3877	/// If the element index is comptime-known, it must be passed in `offset`.	3749	/// If the element index is comptime-known, it must be passed in `offset`.

src/Zcu/PerThread.zig+7-75

 @@ -1102,12 +1102,9 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
     // We are about to re-analyze this `Cau`; drop its depenndencies.
     zcu.intern_pool.removeDependenciesForDepender(gpa, anal_unit);
-    const builtin_type_target_index: InternPool.Index = switch (cau.owner.unwrap()) {
+    switch (cau.owner.unwrap()) {
-        .none => ip_index: {
+        .none => {}, // `comptime` decl -- we will re-analyze its body.
-            // `comptime` decl -- we will re-analyze its body.
+        .nav => {}, // Other decl -- we will re-analyze its value.
-            // This declaration has no value so is definitely not a std.builtin type.
-            break :ip_index .none;
-        },
         .type => |ty| {
             // This is an incremental update, and this type is being re-analyzed because it is outdated.
             // Create a new type in its place, and mark the old one as outdated so that use sites will
 @@ -1119,53 +1116,7 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
                 .invalidate_decl_ref = true,
             };
         },
-        .nav => |nav| ip_index: {
+    }
-            // Other decl -- we will re-analyze its value.
-            // This might be a type in `builtin.zig` -- check.
-            if (file.mod != zcu.std_mod) break :ip_index .none;
-            // We're in the std module.
-            const nav_name = ip.getNav(nav).name;
-            const std_file_imported = try pt.importPkg(zcu.std_mod);
-            const std_type = Type.fromInterned(zcu.fileRootType(std_file_imported.file_index));
-            const std_namespace = zcu.namespacePtr(std_type.getNamespace(zcu).unwrap().?);
-            const builtin_str = try ip.getOrPutString(gpa, pt.tid, "builtin", .no_embedded_nulls);
-            const builtin_nav = ip.getNav(std_namespace.pub_decls.getKeyAdapted(builtin_str, Zcu.Namespace.NameAdapter{ .zcu = zcu }) orelse break :ip_index .none);
-            const builtin_namespace = switch (builtin_nav.status) {
-                .unresolved => break :ip_index .none,
-                .resolved => |r| Type.fromInterned(r.val).getNamespace(zcu).unwrap().?,
-            };
-            if (cau.namespace != builtin_namespace) break :ip_index .none;
-            // We're in builtin.zig. This could be a builtin we need to add to a specific InternPool index.
-            for ([_][]const u8{
-                "AtomicOrder",
-                "AtomicRmwOp",
-                "CallingConvention",
-                "AddressSpace",
-                "FloatMode",
-                "ReduceOp",
-                "CallModifier",
-                "PrefetchOptions",
-                "ExportOptions",
-                "ExternOptions",
-                "Type",
-            }, [_]InternPool.Index{
-                .atomic_order_type,
-                .atomic_rmw_op_type,
-                .calling_convention_type,
-                .address_space_type,
-                .float_mode_type,
-                .reduce_op_type,
-                .call_modifier_type,
-                .prefetch_options_type,
-                .export_options_type,
-                .extern_options_type,
-                .type_info_type,
-            }) |type_name, type_ip| {
-                if (nav_name.eqlSlice(type_name, ip)) break :ip_index type_ip;
-            }
-            break :ip_index .none;
-        },
-    };
     const is_usingnamespace = switch (cau.owner.unwrap()) {
         .nav => |nav| ip.getNav(nav).is_usingnamespace,
 @@ -1194,7 +1145,6 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
         .fn_ret_ty = Type.void,
         .fn_ret_ty_ies = null,
         .comptime_err_ret_trace = &comptime_err_ret_trace,
-        .builtin_type_target_index = builtin_type_target_index,
     };
     defer sema.deinit();
 @@ -1249,9 +1199,6 @@ fn semaCau(pt: Zcu.PerThread, cau_index: InternPool.Cau.Index) !SemaCauResult {
         .type => unreachable, // Handled at top of function.
     };
-    // We'll do more work with the Sema. Clear the target type index just in case we analyze any type.
-    sema.builtin_type_target_index = .none;
     const align_src = block.src(.{ .node_offset_var_decl_align = 0 });
     const section_src = block.src(.{ .node_offset_var_decl_section = 0 });
     const addrspace_src = block.src(.{ .node_offset_var_decl_addrspace = 0 });
 @@ -3349,7 +3296,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
                 break :o o;
             };
             if (!outdated) return ty;
-            return pt.recreateStructType(ty, key, struct_obj);
+            return pt.recreateStructType(key, struct_obj);
         },
         .union_type => |key| {
             const union_obj = ip.loadUnionType(ty);
 @@ -3364,7 +3311,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
                 break :o o;
             };
             if (!outdated) return ty;
-            return pt.recreateUnionType(ty, key, union_obj);
+            return pt.recreateUnionType(key, union_obj);
         },
         .enum_type => |key| {
             const enum_obj = ip.loadEnumType(ty);
 @@ -3379,7 +3326,7 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
                 break :o o;
             };
             if (!outdated) return ty;
-            return pt.recreateEnumType(ty, key, enum_obj);
+            return pt.recreateEnumType(key, enum_obj);
         },
         .opaque_type => {
             assert(!already_updating);
 @@ -3391,7 +3338,6 @@ pub fn ensureTypeUpToDate(pt: Zcu.PerThread, ty: InternPool.Index, already_updat
 fn recreateStructType(
     pt: Zcu.PerThread,
-    ty: InternPool.Index,
     full_key: InternPool.Key.NamespaceType,
     struct_obj: InternPool.LoadedStructType,
 ) Zcu.SemaError!InternPool.Index {
 @@ -3406,10 +3352,6 @@ fn recreateStructType(
         .declared => |d| d,
     };
-    if (@intFromEnum(ty) <= InternPool.static_len) {
-        @panic("TODO: recreate resolved builtin type");
-    }
     const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
     const file = zcu.fileByIndex(inst_info.file);
     if (file.status != .success_zir) return error.AnalysisFail;
 @@ -3482,7 +3424,6 @@ fn recreateStructType(
 fn recreateUnionType(
     pt: Zcu.PerThread,
-    ty: InternPool.Index,
     full_key: InternPool.Key.NamespaceType,
     union_obj: InternPool.LoadedUnionType,
 ) Zcu.SemaError!InternPool.Index {
 @@ -3497,10 +3438,6 @@ fn recreateUnionType(
         .declared => |d| d,
     };
-    if (@intFromEnum(ty) <= InternPool.static_len) {
-        @panic("TODO: recreate resolved builtin type");
-    }
     const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
     const file = zcu.fileByIndex(inst_info.file);
     if (file.status != .success_zir) return error.AnalysisFail;
 @@ -3581,7 +3518,6 @@ fn recreateUnionType(
 fn recreateEnumType(
     pt: Zcu.PerThread,
-    ty: InternPool.Index,
     full_key: InternPool.Key.NamespaceType,
     enum_obj: InternPool.LoadedEnumType,
 ) Zcu.SemaError!InternPool.Index {
 @@ -3596,10 +3532,6 @@ fn recreateEnumType(
         .declared => |d| d,
     };
-    if (@intFromEnum(ty) <= InternPool.static_len) {
-        @panic("TODO: recreate resolved builtin type");
-    }
     const inst_info = key.zir_index.resolveFull(ip) orelse return error.AnalysisFail;
     const file = zcu.fileByIndex(inst_info.file);
     if (file.status != .success_zir) return error.AnalysisFail;

src/codegen/c/Type.zig+1-23

...	@@ -1389,21 +1389,6 @@ pub const Pool = struct {	...	@@ -1389,21 +1389,6 @@ pub const Pool = struct {
1389	.anyframe_type,	1389	.anyframe_type,
1390	.generic_poison_type,	1390	.generic_poison_type,
1391	=> unreachable,	1391	=> unreachable,
1392	.atomic_order_type,
1393	.atomic_rmw_op_type,
1394	.calling_convention_type,
1395	.address_space_type,
1396	.float_mode_type,
1397	.reduce_op_type,
1398	.call_modifier_type,
1399	=> \|ip_index\| return pool.fromType(
1400	allocator,
1401	scratch,
1402	Type.fromInterned(ip.loadEnumType(ip_index).tag_ty),
1403	pt,
1404	mod,
1405	kind,
1406	),
1407	.anyerror_type,	1392	.anyerror_type,
1408	.anyerror_void_error_union_type,	1393	.anyerror_void_error_union_type,
1409	.adhoc_inferred_error_set_type,	1394	.adhoc_inferred_error_set_type,
...	@@ -1459,8 +1444,6 @@ pub const Pool = struct {	...	@@ -1459,8 +1444,6 @@ pub const Pool = struct {
1459	.one_u8,	1444	.one_u8,
1460	.four_u8,	1445	.four_u8,
1461	.negative_one,	1446	.negative_one,
1462	.calling_convention_c,
1463	.calling_convention_inline,
1464	.void_value,	1447	.void_value,
1465	.unreachable_value,	1448	.unreachable_value,
1466	.null_value,	1449	.null_value,
...	@@ -1471,12 +1454,7 @@ pub const Pool = struct {	...	@@ -1471,12 +1454,7 @@ pub const Pool = struct {
1471	.none,	1454	.none,
1472	=> unreachable,	1455	=> unreachable,
1473		1456
1474	//.prefetch_options_type,	1457	_ => \|ip_index\| switch (ip.indexToKey(ip_index)) {
1475	//.export_options_type,
1476	//.extern_options_type,
1477	//.type_info_type,
1478	//_,
1479	else => \|ip_index\| switch (ip.indexToKey(ip_index)) {
1480	.int_type => \|int_info\| return pool.fromIntInfo(allocator, int_info, mod, kind),	1458	.int_type => \|int_info\| return pool.fromIntInfo(allocator, int_info, mod, kind),
1481	.ptr_type => \|ptr_info\| switch (ptr_info.flags.size) {	1459	.ptr_type => \|ptr_info\| switch (ptr_info.flags.size) {
1482	.One, .Many, .C => {	1460	.One, .Many, .C => {

src/codegen/llvm.zig-2

...	@@ -3194,8 +3194,6 @@ pub const Object = struct {	...	@@ -3194,8 +3194,6 @@ pub const Object = struct {
3194	.one_u8,	3194	.one_u8,
3195	.four_u8,	3195	.four_u8,
3196	.negative_one,	3196	.negative_one,
3197	.calling_convention_c,
3198	.calling_convention_inline,
3199	.void_value,	3197	.void_value,
3200	.unreachable_value,	3198	.unreachable_value,
3201	.null_value,	3199	.null_value,

src/link/Dwarf.zig+1-13

...	@@ -2565,19 +2565,7 @@ fn updateType(	...	@@ -2565,19 +2565,7 @@ fn updateType(
2565	try wip_nav.strp(if (type_index == .generic_poison_type) "anytype" else name);	2565	try wip_nav.strp(if (type_index == .generic_poison_type) "anytype" else name);
2566	},	2566	},
2567	.anyerror => return, // delay until flush	2567	.anyerror => return, // delay until flush
2568	.atomic_order,	2568	.adhoc_inferred_error_set => unreachable,
2569	.atomic_rmw_op,
2570	.calling_convention,
2571	.address_space,
2572	.float_mode,
2573	.reduce_op,
2574	.call_modifier,
2575	.prefetch_options,
2576	.export_options,
2577	.extern_options,
2578	.type_info,
2579	.adhoc_inferred_error_set,
2580	=> unreachable,
2581	},	2569	},
2582	.struct_type,	2570	.struct_type,
2583	.union_type,	2571	.union_type,

src/print_zir.zig+7

 @@ -615,6 +615,7 @@ const Writer = struct {
             .restore_err_ret_index => try self.writeRestoreErrRetIndex(stream, extended),
             .closure_get => try self.writeClosureGet(stream, extended),
             .field_parent_ptr => try self.writeFieldParentPtr(stream, extended),
+            .builtin_value => try self.writeBuiltinValue(stream, extended),
         }
     }
 @@ -2782,6 +2783,12 @@ const Writer = struct {
         try self.writeSrcNode(stream, @bitCast(extended.operand));
     }
+    fn writeBuiltinValue(self: *Writer, stream: anytype, extended: Zir.Inst.Extended.InstData) !void {
+        const val: Zir.Inst.BuiltinValue = @enumFromInt(extended.small);
+        try stream.print("{s})) ", .{@tagName(val)});
+        try self.writeSrcNode(stream, @bitCast(extended.operand));
+    }
     fn writeInstRef(self: *Writer, stream: anytype, ref: Zir.Inst.Ref) !void {
         if (ref == .none) {
             return stream.writeAll(".none");