From 69a26976ed2b624d99d364b642f78ca6bb59e5b6 Mon Sep 17 00:00:00 2001 From: Justus Klausecker Date: Fri, 17 Jul 2026 23:30:26 +0200 Subject: [PATCH] zig fmt Converts usages of `@intFromEnum` and `@enumFromInt` to instead use the new `@backingInt` and `@fromBackingInt` builtins. --- lib/build-web/fuzz.zig | 18 +- lib/build-web/main.zig | 6 +- lib/c/malloc.zig | 6 +- lib/c/pthread.zig | 6 +- lib/c/stdlib.zig | 8 +- lib/c/sys/reboot.zig | 2 +- lib/c/unistd.zig | 12 +- lib/compiler/Maker.zig | 16 +- lib/compiler/Maker/Fetch.zig | 12 +- lib/compiler/Maker/Fetch/git.zig | 2 +- lib/compiler/Maker/ScannedConfig.zig | 8 +- lib/compiler/Maker/Step.zig | 2 +- lib/compiler/Maker/Step/Compile.zig | 4 +- lib/compiler/Maker/Step/Run.zig | 6 +- lib/compiler/Maker/Watch.zig | 2 +- lib/compiler/Maker/WebServer.zig | 20 +- lib/compiler/aro/aro/Attribute.zig | 6 +- lib/compiler/aro/aro/Builtins.zig | 4 +- lib/compiler/aro/aro/CodeGen.zig | 6 +- lib/compiler/aro/aro/Compilation.zig | 18 +- lib/compiler/aro/aro/Diagnostics.zig | 2 +- lib/compiler/aro/aro/Hideset.zig | 12 +- lib/compiler/aro/aro/LangOpts.zig | 2 +- lib/compiler/aro/aro/Parser.zig | 78 +- lib/compiler/aro/aro/Preprocessor.zig | 4 +- lib/compiler/aro/aro/StringInterner.zig | 6 +- lib/compiler/aro/aro/Target.zig | 12 +- lib/compiler/aro/aro/Tokenizer.zig | 4 +- lib/compiler/aro/aro/Tree.zig | 538 +++++------ lib/compiler/aro/aro/TypeStore.zig | 88 +- lib/compiler/aro/aro/Value.zig | 10 +- lib/compiler/aro/aro/text_literal.zig | 2 +- lib/compiler/aro/assembly_backend/x86_64.zig | 2 +- lib/compiler/aro/backend/Interner.zig | 12 +- lib/compiler/aro/backend/Ir.zig | 28 +- lib/compiler/objcopy.zig | 4 +- lib/compiler/objdump.zig | 24 +- lib/compiler/reduce.zig | 2 +- lib/compiler/resinator/bmp.zig | 2 +- lib/compiler/resinator/cli.zig | 2 +- lib/compiler/resinator/code_pages.zig | 4 +- lib/compiler/resinator/compile.zig | 16 +- lib/compiler/resinator/cvtres.zig | 30 +- lib/compiler/resinator/ico.zig | 2 +- lib/compiler/resinator/lang.zig | 2 +- lib/compiler/resinator/parse.zig | 8 +- lib/compiler/resinator/rc.zig | 16 +- lib/compiler/resinator/res.zig | 4 +- lib/compiler/test_runner.zig | 10 +- lib/compiler/translate-c/ast.zig | 20 +- lib/compiler/translate-c/main.zig | 2 +- lib/compiler_rt/cmpdf2.zig | 2 +- lib/compiler_rt/cmptf2.zig | 30 +- lib/compiler_rt/cmpxf2.zig | 2 +- lib/compiler_rt/comparef.zig | 4 +- lib/compiler_rt/gedf2.zig | 2 +- lib/compiler_rt/gehf2.zig | 2 +- lib/compiler_rt/gesf2.zig | 2 +- lib/compiler_rt/getf2.zig | 2 +- lib/compiler_rt/gexf2.zig | 2 +- lib/docs/wasm/Decl.zig | 4 +- lib/docs/wasm/Walk.zig | 10 +- lib/docs/wasm/main.zig | 18 +- lib/docs/wasm/markdown/Document.zig | 8 +- lib/docs/wasm/markdown/Parser.zig | 20 +- lib/docs/wasm/markdown/renderer.zig | 12 +- lib/fuzzer.zig | 58 +- lib/std/Build.zig | 4 +- lib/std/Build/Configuration.zig | 128 +-- lib/std/Build/Serialize.zig | 22 +- lib/std/Build/abi.zig | 2 +- lib/std/Io.zig | 30 +- lib/std/Io/Dispatch.zig | 22 +- lib/std/Io/File.zig | 12 +- lib/std/Io/File/Reader.zig | 8 +- lib/std/Io/Kqueue.zig | 6 +- lib/std/Io/Reader.zig | 22 +- lib/std/Io/Reader/Limited.zig | 4 +- lib/std/Io/Threaded.zig | 132 +-- lib/std/Io/Uring.zig | 62 +- lib/std/Io/Writer.zig | 30 +- lib/std/Io/net/HostName.zig | 2 +- lib/std/Progress.zig | 82 +- lib/std/Target.zig | 28 +- lib/std/Target/aarch64.zig | 554 +++++------ lib/std/Target/alpha.zig | 8 +- lib/std/Target/amdgcn.zig | 508 +++++----- lib/std/Target/arc.zig | 2 +- lib/std/Target/arm.zig | 402 ++++---- lib/std/Target/avr.zig | 78 +- lib/std/Target/bpf.zig | 8 +- lib/std/Target/csky.zig | 126 +-- lib/std/Target/hexagon.zig | 94 +- lib/std/Target/hppa.zig | 10 +- lib/std/Target/kvx.zig | 6 +- lib/std/Target/loongarch.zig | 42 +- lib/std/Target/m68k.zig | 46 +- lib/std/Target/mips.zig | 114 +-- lib/std/Target/msp430.zig | 8 +- lib/std/Target/nvptx.zig | 142 +-- lib/std/Target/powerpc.zig | 160 ++-- lib/std/Target/propeller.zig | 2 +- lib/std/Target/riscv.zig | 694 +++++++------- lib/std/Target/s390x.zig | 98 +- lib/std/Target/sparc.zig | 118 +-- lib/std/Target/spirv.zig | 456 ++++----- lib/std/Target/ve.zig | 2 +- lib/std/Target/wasm.zig | 38 +- lib/std/Target/x86.zig | 404 ++++---- lib/std/Target/xtensa.zig | 74 +- lib/std/Thread.zig | 26 +- lib/std/c.zig | 40 +- lib/std/c/darwin.zig | 4 +- lib/std/c/illumos.zig | 2 +- lib/std/coff.zig | 26 +- lib/std/compress/flate/Compress.zig | 26 +- lib/std/compress/flate/Decompress.zig | 18 +- lib/std/compress/xz/Decompress.zig | 2 +- lib/std/compress/zstd/Decompress.zig | 30 +- lib/std/crypto/Certificate.zig | 4 +- lib/std/crypto/Certificate/Bundle/macos.zig | 2 +- lib/std/crypto/argon2.zig | 4 +- lib/std/crypto/codecs/asn1.zig | 12 +- lib/std/crypto/codecs/asn1/Oid.zig | 2 +- lib/std/crypto/codecs/asn1/der/Decoder.zig | 4 +- lib/std/crypto/codecs/asn1/der/Encoder.zig | 4 +- lib/std/crypto/tls.zig | 10 +- lib/std/crypto/tls/Client.zig | 72 +- lib/std/debug.zig | 2 +- lib/std/debug/Coverage.zig | 24 +- lib/std/debug/Dwarf.zig | 2 +- lib/std/debug/Dwarf/Unwind/VirtualMachine.zig | 2 +- lib/std/debug/ElfFile.zig | 2 +- lib/std/debug/MachOFile.zig | 8 +- lib/std/debug/Pdb.zig | 6 +- lib/std/dynamic_library.zig | 2 +- lib/std/elf.zig | 250 ++--- lib/std/enums.zig | 50 +- lib/std/fmt.zig | 6 +- lib/std/hash/auto_hash.zig | 2 +- lib/std/heap.zig | 4 +- lib/std/heap/ArenaAllocator.zig | 24 +- lib/std/heap/SafeAllocator.zig | 36 +- lib/std/heap/SmpAllocator.zig | 2 +- lib/std/heap/debug_allocator.zig | 22 +- lib/std/http.zig | 10 +- lib/std/http/Client.zig | 22 +- lib/std/http/Server.zig | 10 +- lib/std/json/Stringify.zig | 10 +- lib/std/lang.zig | 2 +- lib/std/log.zig | 4 +- lib/std/math.zig | 2 +- lib/std/math/float.zig | 4 +- lib/std/mem.zig | 26 +- lib/std/meta.zig | 4 +- lib/std/meta/trailer_flags.zig | 10 +- lib/std/multi_array_list.zig | 26 +- lib/std/os/emscripten.zig | 158 ++-- lib/std/os/linux.zig | 88 +- lib/std/os/linux/IoUring/test.zig | 18 +- lib/std/os/linux/aarch64.zig | 18 +- lib/std/os/linux/arc.zig | 18 +- lib/std/os/linux/arm.zig | 22 +- lib/std/os/linux/bpf.zig | 48 +- lib/std/os/linux/csky.zig | 14 +- lib/std/os/linux/hexagon.zig | 14 +- lib/std/os/linux/io_uring_sqe.zig | 4 +- lib/std/os/linux/loongarch32.zig | 14 +- lib/std/os/linux/loongarch64.zig | 14 +- lib/std/os/linux/m68k.zig | 16 +- lib/std/os/linux/microblaze.zig | 18 +- lib/std/os/linux/mips.zig | 18 +- lib/std/os/linux/mips64.zig | 16 +- lib/std/os/linux/mipsn32.zig | 18 +- lib/std/os/linux/or1k.zig | 14 +- lib/std/os/linux/powerpc.zig | 22 +- lib/std/os/linux/powerpc64.zig | 22 +- lib/std/os/linux/riscv32.zig | 14 +- lib/std/os/linux/riscv64.zig | 14 +- lib/std/os/linux/s390x.zig | 18 +- lib/std/os/linux/sh.zig | 18 +- lib/std/os/linux/sparc.zig | 20 +- lib/std/os/linux/sparc64.zig | 20 +- lib/std/os/linux/test.zig | 6 +- lib/std/os/linux/thumb.zig | 14 +- lib/std/os/linux/vdso.zig | 2 +- lib/std/os/linux/x32.zig | 20 +- lib/std/os/linux/x86.zig | 24 +- lib/std/os/linux/x86_64.zig | 18 +- lib/std/os/linux/xtensa.zig | 18 +- lib/std/os/plan9.zig | 2 +- lib/std/os/plan9/x86_64.zig | 8 +- lib/std/os/uefi.zig | 2 +- lib/std/os/uefi/pool_allocator.zig | 6 +- lib/std/os/uefi/protocol/device_path.zig | 4 +- lib/std/os/uefi/tables.zig | 28 +- lib/std/os/windows.zig | 24 +- lib/std/os/windows/crypt32.zig | 6 +- lib/std/posix.zig | 12 +- lib/std/posix/test.zig | 2 +- lib/std/process.zig | 4 +- lib/std/simd.zig | 2 +- lib/std/spirv.zig | 6 +- lib/std/start.zig | 4 +- lib/std/static_string_map.zig | 2 +- lib/std/tar.zig | 2 +- lib/std/testing/Smith.zig | 18 +- lib/std/time/epoch.zig | 4 +- lib/std/valgrind.zig | 2 +- lib/std/valgrind/cachegrind.zig | 2 +- lib/std/valgrind/callgrind.zig | 2 +- lib/std/valgrind/memcheck.zig | 2 +- lib/std/wasm.zig | 2 +- lib/std/zig.zig | 4 +- lib/std/zig/Ast.zig | 80 +- lib/std/zig/Ast/Render.zig | 6 +- lib/std/zig/AstGen.zig | 464 +++++----- lib/std/zig/ErrorBundle.zig | 42 +- lib/std/zig/Parse.zig | 30 +- lib/std/zig/TokenSmith.zig | 4 +- lib/std/zig/Zir.zig | 140 +-- lib/std/zig/Zoir.zig | 18 +- lib/std/zig/ZonGen.zig | 34 +- lib/std/zig/llvm/BitcodeReader.zig | 24 +- lib/std/zig/llvm/Builder.zig | 758 +++++++-------- lib/std/zig/llvm/bitcode_writer.zig | 2 +- lib/std/zig/llvm/ir.zig | 216 ++--- lib/std/zig/number_literal.zig | 6 +- lib/std/zig/parser_generated_oracle.zig | 544 +++++------ lib/std/zig/system.zig | 14 +- lib/std/zig/system/arm.zig | 2 +- lib/std/zig/system/loongarch.zig | 4 +- lib/std/zig/system/windows.zig | 4 +- lib/std/zig/system/x86.zig | 2 +- lib/std/zip.zig | 4 +- lib/std/zon/parse.zig | 4 +- src/Air.zig | 392 ++++---- src/Air/Legalize.zig | 158 ++-- src/Air/Liveness.zig | 72 +- src/Air/Liveness/Verify.zig | 48 +- src/Air/Verify.zig | 26 +- src/Air/print.zig | 66 +- src/Compilation.zig | 78 +- src/IncrementalDebugServer.zig | 38 +- src/InternPool.zig | 636 ++++++------- src/Module.zig | 6 +- src/Sema.zig | 866 +++++++++--------- src/Sema/comptime_ptr_access.zig | 10 +- src/Sema/type_resolution.zig | 6 +- src/Type.zig | 4 +- src/Value.zig | 2 +- src/Zcu.zig | 98 +- src/Zcu/PerThread.zig | 36 +- src/codegen.zig | 12 +- src/codegen/aarch64.zig | 22 +- src/codegen/aarch64/Disassemble.zig | 46 +- src/codegen/aarch64/Mir.zig | 46 +- src/codegen/aarch64/Select.zig | 222 ++--- src/codegen/aarch64/encoding.zig | 136 +-- src/codegen/c.zig | 196 ++-- src/codegen/c/type.zig | 4 +- src/codegen/llvm.zig | 18 +- src/codegen/llvm/FuncGen.zig | 258 +++--- src/codegen/llvm/bindings.zig | 2 +- src/codegen/riscv64/CodeGen.zig | 260 +++--- src/codegen/riscv64/Emit.zig | 26 +- src/codegen/riscv64/Lower.zig | 2 +- src/codegen/riscv64/bits.zig | 12 +- src/codegen/riscv64/encoding.zig | 24 +- src/codegen/sparc64/CodeGen.zig | 156 ++-- src/codegen/sparc64/bits.zig | 62 +- src/codegen/spirv/Assembler.zig | 20 +- src/codegen/spirv/CodeGen.zig | 178 ++-- src/codegen/spirv/Section.zig | 18 +- src/codegen/spirv/spec.zig | 4 +- src/codegen/wasm/CodeGen.zig | 208 ++--- src/codegen/wasm/Emit.zig | 78 +- src/codegen/wasm/Mir.zig | 28 +- src/codegen/x86_64/CodeGen.zig | 500 +++++----- src/codegen/x86_64/Disassembler.zig | 2 +- src/codegen/x86_64/Emit.zig | 82 +- src/codegen/x86_64/Encoding.zig | 10 +- src/codegen/x86_64/Lower.zig | 6 +- src/codegen/x86_64/Mir.zig | 40 +- src/codegen/x86_64/bits.zig | 60 +- src/codegen/x86_64/encoder.zig | 14 +- src/libs/mingw/Preprocessor.zig | 4 +- src/libs/mingw/implib.zig | 34 +- src/link.zig | 4 +- src/link/C.zig | 28 +- src/link/Coff.zig | 296 +++--- src/link/ConstPool.zig | 12 +- src/link/Dwarf.zig | 258 +++--- src/link/Elf.zig | 24 +- src/link/Elf/Atom.zig | 28 +- src/link/Elf/LinkerDefined.zig | 2 +- src/link/Elf/Object.zig | 4 +- src/link/Elf/SharedObject.zig | 8 +- src/link/Elf/Symbol.zig | 4 +- src/link/Elf/ZigObject.zig | 38 +- src/link/Elf/eh_frame.zig | 6 +- src/link/Elf/relocation.zig | 22 +- src/link/Elf2.zig | 344 +++---- src/link/MachO.zig | 8 +- src/link/MachO/Atom.zig | 10 +- src/link/MachO/Object.zig | 22 +- src/link/MachO/UnwindInfo.zig | 10 +- src/link/MachO/ZigObject.zig | 30 +- src/link/MachO/eh_frame.zig | 4 +- src/link/MappedFile.zig | 4 +- src/link/SpirV.zig | 42 +- src/link/SpirV/BinaryModule.zig | 24 +- src/link/SpirV/dedup_types.zig | 20 +- src/link/SpirV/lower_invocation_globals.zig | 66 +- src/link/SpirV/prune_unused.zig | 14 +- src/link/Wasm.zig | 322 +++---- src/link/Wasm/Flush.zig | 262 +++--- src/link/Wasm/Object.zig | 68 +- src/main.zig | 10 +- src/print_zir.zig | 198 ++-- src/print_zoir.zig | 2 +- src/register_manager.zig | 12 +- src/target.zig | 6 +- test/behavior/call.zig | 4 +- test/behavior/cast.zig | 14 +- test/behavior/enum.zig | 108 +-- test/behavior/generics.zig | 4 +- test/behavior/inline_switch.zig | 2 +- test/behavior/struct.zig | 2 +- test/behavior/switch.zig | 16 +- test/behavior/switch_loop.zig | 6 +- test/behavior/type.zig | 10 +- test/behavior/union.zig | 16 +- test/c.zig | 10 +- test/c/pthread.zig | 8 +- test/c/stdlib.zig | 12 +- test/src/StackTrace.zig | 2 +- test/standalone/windows_argv/fuzz.zig | 2 +- tools/fetch_them_macos_headers.zig | 4 +- tools/gen_outline_atomics.zig | 6 +- tools/gen_parser_oracle.zig | 4 +- tools/gen_stubs.zig | 18 +- tools/generate_c_size_and_align_checks.zig | 2 +- tools/update-linux-headers.zig | 2 +- tools/update_clang_options.zig | 2 +- tools/update_cpu_features.zig | 2 +- 346 files changed, 9037 insertions(+), 9037 deletions(-) diff --git a/lib/build-web/fuzz.zig b/lib/build-web/fuzz.zig index 3f9d692169e04b620e3f9368242b49c72a49ee92..4dcaa9029fff86fcd9a8d65221d4cec52ac432c2 100644 --- a/lib/build-web/fuzz.zig +++ b/lib/build-web/fuzz.zig @@ -94,11 +94,11 @@ const SourceLocationIndex = enum(u32) { _, fn haveCoverage(sli: SourceLocationIndex) bool { - return @intFromEnum(sli) < coverage_source_locations.items.len; + return @backingInt(sli) < coverage_source_locations.items.len; } fn ptr(sli: SourceLocationIndex) *Coverage.SourceLocation { - return &coverage_source_locations.items[@intFromEnum(sli)]; + return &coverage_source_locations.items[@backingInt(sli)]; } fn sourceLocationLinkHtml( @@ -114,7 +114,7 @@ const SourceLocationIndex = enum(u32) { try out.print(gpa, ":{d}:{d} ", .{ sl.line, sl.column, - @intFromEnum(sli), + @backingInt(sli), }); } @@ -132,7 +132,7 @@ const SourceLocationIndex = enum(u32) { var buf: std.ArrayList(u8) = .empty; defer buf.deinit(gpa); sli.appendPath(&buf) catch @panic("OOM"); - return @enumFromInt(Walk.files.getIndex(buf.items) orelse return null); + return @fromBackingInt(@intCast(Walk.files.getIndex(buf.items) orelse return null)); } fn fileHtml( @@ -166,7 +166,7 @@ fn computeSourceAnnotations( for (source_locations, 0..) |sl, sli_usize| { if (sl.file != cov_file_index) continue; - const sli: SourceLocationIndex = @enumFromInt(sli_usize); + const sli: SourceLocationIndex = @fromBackingInt(@intCast(sli_usize)); try locs.append(gpa, sli); } @@ -199,7 +199,7 @@ fn computeSourceAnnotations( if (next_sl.line > line or (next_sl.line == line and next_sl.column >= column)) break; try annotations.append(gpa, .{ .file_byte_offset = offset, - .dom_id = @intFromEnum(next_sli), + .dom_id = @backingInt(next_sli), }); next_loc_index += 1; } @@ -240,7 +240,7 @@ fn unpackSourcesInner(tar_bytes: []u8) !void { break :p .{ "root", std.mem.endsWith(u8, file_name, "/root.zig") }; }; const gop = try Walk.modules.getOrPut(gpa, mod_name); - const file: Walk.File.Index = @enumFromInt(Walk.files.entries.len); + const file: Walk.File.Index = @fromBackingInt(@intCast(Walk.files.entries.len)); if (!gop.found_existing or is_module_root) gop.value_ptr.* = file; const file_bytes = tar_reader.take(@intCast(tar_file.size)) catch unreachable; it.unread_file_bytes = 0; // we have read the whole thing @@ -323,7 +323,7 @@ fn updateCoverage() error{OutOfMemory}!void { u64, recent_coverage_update.items[@sizeOf(abi.fuzz.CoverageUpdateHeader)..][0 .. n_bitset_elems * @sizeOf(u64)], ); - var sli: SourceLocationIndex = @enumFromInt(0); + var sli: SourceLocationIndex = @fromBackingInt(@intCast(0)); for (covered_bits) |elem| { try covered.ensureUnusedCapacity(gpa, 64); for (0..@bitSizeOf(u64)) |i| { @@ -332,7 +332,7 @@ fn updateCoverage() error{OutOfMemory}!void { covered.appendAssumeCapacity(sli); } } - sli = @enumFromInt(@intFromEnum(sli) + 1); + sli = @fromBackingInt(@intCast(@backingInt(sli) + 1)); } } diff --git a/lib/build-web/main.zig b/lib/build-web/main.zig index e71c47707b2a5fa6f93df8398ccf7778c1a81b9d..865404e3a41142b7011b09f1095c413e695a3c7b 100644 --- a/lib/build-web/main.zig +++ b/lib/build-web/main.zig @@ -80,7 +80,7 @@ export fn message_begin(len: usize) [*]u8 { export fn message_end() void { const msg_bytes = message_buffer.items; - const tag: abi.ToClientTag = @enumFromInt(msg_bytes[0]); + const tag: abi.ToClientTag = @fromBackingInt(@intCast(msg_bytes[0])); switch (tag) { _ => @panic("malformed message"), @@ -151,7 +151,7 @@ fn helloMessage(msg_bytes: []align(4) u8) Allocator.Error!void { for (steps, step_name_lens, 0..) |*step_out, name_len, step_idx| { step_out.* = .{ .name = duped_step_name_data[name_off..][0..name_len], - .status = @enumFromInt(@as(u2, @truncate(step_status_bits[step_idx / 4] >> @intCast((step_idx % 4) * 2)))), + .status = @fromBackingInt(@intCast(@as(u2, @truncate(step_status_bits[step_idx / 4] >> @intCast((step_idx % 4) * 2))))), }; name_off += name_len; } @@ -180,7 +180,7 @@ export fn stepName(idx: usize) String { return .init(step_list[idx].name); } export fn stepStatus(idx: usize) u8 { - return @intFromEnum(step_list[idx].status); + return @backingInt(step_list[idx].status); } export fn rebuild() void { diff --git a/lib/c/malloc.zig b/lib/c/malloc.zig index 083825e438a87d1eb894f028943f81f17d06e963..69f56641d0a26a9f4b68bbe75cc26de9203c6f1d 100644 --- a/lib/c/malloc.zig +++ b/lib/c/malloc.zig @@ -183,8 +183,8 @@ fn memalign(alloc_alignment: usize, n: usize) callconv(.c) ?[*]align(alignment_b } fn posix_memalign(result: *?[*]align(alignment_bytes) u8, alloc_alignment: usize, n: usize) callconv(.c) c_int { - if (alloc_alignment < @sizeOf(*anyopaque)) return @intFromEnum(std.c.E.INVAL); - result.* = aligned_alloc_inner(alloc_alignment, n) orelse return @intFromEnum(std.c.E.NOMEM); + if (alloc_alignment < @sizeOf(*anyopaque)) return @backingInt(std.c.E.INVAL); + result.* = aligned_alloc_inner(alloc_alignment, n) orelse return @backingInt(std.c.E.NOMEM); return 0; } @@ -192,6 +192,6 @@ fn posix_memalign(result: *?[*]align(alignment_bytes) u8, alloc_alignment: usize /// `null`. fn nomem() ?[*]align(alignment_bytes) u8 { @branchHint(.cold); - std.c._errno().* = @intFromEnum(std.c.E.NOMEM); + std.c._errno().* = @backingInt(std.c.E.NOMEM); return null; } diff --git a/lib/c/pthread.zig b/lib/c/pthread.zig index ca10ec7c3235f829c3b7e506d68176b39623ba92..b7131bd1eb38c33330eeab361da9e20eb2a3abea 100644 --- a/lib/c/pthread.zig +++ b/lib/c/pthread.zig @@ -17,7 +17,7 @@ comptime { const SpinLock = enum(c.pthread_spinlock_t) { unlocked = if (builtin.target.isMinGW()) -1 else 0, - locked = if (builtin.target.isMinGW()) 0 else @intFromEnum(c.E.BUSY), + locked = if (builtin.target.isMinGW()) 0 else @backingInt(c.E.BUSY), }; fn pthread_spin_init(s: *c.pthread_spinlock_t, pshared: c_int) callconv(.c) c_int { @@ -35,12 +35,12 @@ fn pthread_spin_destroy(s: *c.pthread_spinlock_t) callconv(.c) c_int { fn pthread_spin_trylock(s: *c.pthread_spinlock_t) callconv(.c) c_int { const spin: *SpinLock = @ptrCast(s); - return if (@cmpxchgStrong(SpinLock, spin, .unlocked, .locked, .acquire, .monotonic)) |_| @intFromEnum(c.E.BUSY) else 0; + return if (@cmpxchgStrong(SpinLock, spin, .unlocked, .locked, .acquire, .monotonic)) |_| @backingInt(c.E.BUSY) else 0; } fn pthread_spin_lock(s: *c.pthread_spinlock_t) callconv(.c) c_int { const spin: *SpinLock = @ptrCast(s); - if (builtin.single_threaded and @atomicLoad(SpinLock, spin, .monotonic) == .locked) return @intFromEnum(c.E.DEADLK); + if (builtin.single_threaded and @atomicLoad(SpinLock, spin, .monotonic) == .locked) return @backingInt(c.E.DEADLK); while (@cmpxchgWeak(SpinLock, spin, .unlocked, .locked, .acquire, .monotonic)) |_| { std.atomic.spinLoopHint(); diff --git a/lib/c/stdlib.zig b/lib/c/stdlib.zig index dabcff40b438d2a741181677d55255c71d3a9fff..4f3d6cf5869ee46ae7a54def9f597b33eb082d7e 100644 --- a/lib/c/stdlib.zig +++ b/lib/c/stdlib.zig @@ -138,7 +138,7 @@ fn stringToInteger(comptime T: type, noalias buf: [*:0]const u8, noalias maybe_e end.* = buf; } - std.c._errno().* = @intFromEnum(std.c.E.INVAL); + std.c._errno().* = @backingInt(std.c.E.INVAL); return 0; } @@ -192,7 +192,7 @@ fn stringToInteger(comptime T: type, noalias buf: [*:0]const u8, noalias maybe_e if (@typeInfo(T).int.signedness == .unsigned) { const result = parseDigitsWithSignGenericCharacter(T, u8, digits, maybe_end, real_base, .pos) catch { - std.c._errno().* = @intFromEnum(std.c.E.RANGE); + std.c._errno().* = @backingInt(std.c.E.RANGE); return std.math.maxInt(T); }; @@ -200,12 +200,12 @@ fn stringToInteger(comptime T: type, noalias buf: [*:0]const u8, noalias maybe_e } if (negative) return parseDigitsWithSignGenericCharacter(T, u8, digits, maybe_end, real_base, .neg) catch blk: { - std.c._errno().* = @intFromEnum(std.c.E.RANGE); + std.c._errno().* = @backingInt(std.c.E.RANGE); break :blk std.math.minInt(T); }; return parseDigitsWithSignGenericCharacter(T, u8, digits, maybe_end, real_base, .pos) catch blk: { - std.c._errno().* = @intFromEnum(std.c.E.RANGE); + std.c._errno().* = @backingInt(std.c.E.RANGE); break :blk std.math.maxInt(T); }; } diff --git a/lib/c/sys/reboot.zig b/lib/c/sys/reboot.zig index 8ec4210477e4dc22119a49c52c53a4763dd4e05d..5594f2b4e605eb965c59780c72e9323964fee79f 100644 --- a/lib/c/sys/reboot.zig +++ b/lib/c/sys/reboot.zig @@ -12,5 +12,5 @@ comptime { } fn rebootLinux(cmd: c_int) callconv(.c) c_int { - return errno(std.os.linux.reboot(.MAGIC1, .MAGIC2, @enumFromInt(cmd), null)); + return errno(std.os.linux.reboot(.MAGIC1, .MAGIC2, @fromBackingInt(@intCast(cmd)), null)); } diff --git a/lib/c/unistd.zig b/lib/c/unistd.zig index 3b4396e9ecbc0935099e5332845e05b9ddb0b097..44a80a95ab16a497e1d83149cd61bfb3a333e666 100644 --- a/lib/c/unistd.zig +++ b/lib/c/unistd.zig @@ -105,26 +105,26 @@ fn dupLinux(fd: c_int) callconv(.c) c_int { } fn dup2Linux(old: c_int, new: c_int) callconv(.c) c_int { - const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY))); + const busy: usize = @bitCast(-@as(isize, @backingInt(linux.E.BUSY))); var res = busy; while (res == busy) res = linux.dup2(old, new); return errno(res); } fn dup3Linux(old: c_int, new: c_int, flags: c_int) callconv(.c) c_int { - const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY))); + const busy: usize = @bitCast(-@as(isize, @backingInt(linux.E.BUSY))); var res = busy; if (@hasField(linux.SYS, "dup3")) { while (res == busy) res = linux.dup3(old, new, @intCast(flags)); } else if (@hasField(linux.SYS, "dup2")) { const cloexec: c_int = @bitCast(linux.O{ .CLOEXEC = true }); - const inval: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.INVAL))); + const inval: usize = @bitCast(-@as(isize, @backingInt(linux.E.INVAL))); if (old == new or (flags & ~cloexec != 0)) return errno(inval); while (res == busy) res = linux.dup2(old, new); _ = if (res >= 0 and (flags & cloexec == cloexec)) linux.fcntl(new, linux.F.SETFD, linux.FD_CLOEXEC); } else { - return errno(@bitCast(-@as(isize, @intFromEnum(linux.E.NOSYS)))); + return errno(@bitCast(-@as(isize, @backingInt(linux.E.NOSYS)))); } return errno(res); } @@ -238,7 +238,7 @@ fn close(fd: std.c.fd_t) callconv(.c) c_int { const signed: isize = @bitCast(linux.close(fd)); if (signed < 0) { @branchHint(.unlikely); - if (-signed == @intFromEnum(linux.E.INTR)) return 0; + if (-signed == @backingInt(linux.E.INTR)) return 0; std.c._errno().* = @intCast(-signed); return -1; } @@ -253,7 +253,7 @@ fn closeWasi(fd: std.c.fd_t) callconv(.c) c_int { switch (std.os.wasi.fd_close(fd)) { .SUCCESS => return 0, else => |e| { - std.c._errno().* = @intFromEnum(e); + std.c._errno().* = @backingInt(e); return -1; }, } diff --git a/lib/compiler/Maker.zig b/lib/compiler/Maker.zig index abc2973a778e113bed67ca516903e667671868e6..8b7c9a23edf2701ae1a84f45525d8bccf2a7a1f0 100644 --- a/lib/compiler/Maker.zig +++ b/lib/compiler/Maker.zig @@ -589,10 +589,10 @@ pub fn main(init: process.Init.Minimal) !void { graph.cache.addPrefix(graph.local_cache_root); graph.cache.addPrefix(global_cache_directory); graph.cache.addPrefix(graph.build_root_directory); - comptime assert(0 == @intFromEnum(std.zig.Server.Message.PathPrefix.cwd)); - comptime assert(1 == @intFromEnum(std.zig.Server.Message.PathPrefix.zig_lib)); - comptime assert(2 == @intFromEnum(std.zig.Server.Message.PathPrefix.local_cache)); - comptime assert(3 == @intFromEnum(std.zig.Server.Message.PathPrefix.global_cache)); + comptime assert(0 == @backingInt(std.zig.Server.Message.PathPrefix.cwd)); + comptime assert(1 == @backingInt(std.zig.Server.Message.PathPrefix.zig_lib)); + comptime assert(2 == @backingInt(std.zig.Server.Message.PathPrefix.local_cache)); + comptime assert(3 == @backingInt(std.zig.Server.Message.PathPrefix.global_cache)); graph.cache.hash.addBytes(builtin.zig_version_string); @@ -1406,7 +1406,7 @@ fn configure(graph: *Graph, options: ConfigureOptions) !ScannedConfig { var top_level_steps: std.array_hash_map.String(Configuration.Step.Index) = .empty; for (configuration.steps, 0..) |*conf_step, step_index_usize| { if (conf_step.owner != .root) continue; - const step_index: Configuration.Step.Index = @enumFromInt(step_index_usize); + const step_index: Configuration.Step.Index = @fromBackingInt(@intCast(step_index_usize)); const flags = conf_step.flags(c); switch (flags.tag) { .top_level => { @@ -2017,7 +2017,7 @@ fn countSubProcesses(maker: *Maker) usize { } pub fn stepByIndex(maker: *const Maker, i: Configuration.Step.Index) *Step { - return &maker.steps[@intFromEnum(i)]; + return &maker.steps[@backingInt(i)]; } fn prepare(maker: *Maker, step_names: []const []const u8) !void { @@ -2029,7 +2029,7 @@ fn prepare(maker: *Maker, step_names: []const []const u8) !void { const c = &maker.scanned_config.configuration; for (maker.steps, 0..) |*step, step_index_usize| { - const step_index: Configuration.Step.Index = @enumFromInt(step_index_usize); + const step_index: Configuration.Step.Index = @fromBackingInt(@intCast(step_index_usize)); step.* = .{ .extended = .init(step_index.ptr(c).flags(c).tag) }; } @@ -3060,7 +3060,7 @@ pub fn resolveLazyPathIndexAbs( } pub fn generatedPath(maker: *const Maker, index: Configuration.GeneratedFileIndex) *Path { - return &maker.generated_files[@intFromEnum(index)]; + return &maker.generated_files[@backingInt(index)]; } pub fn packagePath( diff --git a/lib/compiler/Maker/Fetch.zig b/lib/compiler/Maker/Fetch.zig index da5103b0a7ae410407f04c29c3a344bcf0f2f8a3..5b5c6f7ff4385ca7cb4d45adcd0233feb24e1bff 100644 --- a/lib/compiler/Maker/Fetch.zig +++ b/lib/compiler/Maker/Fetch.zig @@ -826,7 +826,7 @@ fn runResource( .notes_len = notes_len, }); const notes_start = try eb.reserveNotes(notes_len); - eb.extra.items[notes_start] = @intFromEnum(try eb.addErrorMessage(.{ + eb.extra.items[notes_start] = @backingInt(try eb.addErrorMessage(.{ .msg = try eb.printString("expected .hash = {q},", .{computed_package_hash.toSlice()}), })); return error.FetchFailed; @@ -1297,7 +1297,7 @@ fn initResource(f: *Fetch, uri: std.Uri, resource: *Resource, reader_buffer: []u .notes_len = notes_len, }); const notes_start = try eb.reserveNotes(notes_len); - eb.extra.items[notes_start] = @intFromEnum(try eb.addErrorMessage(.{ + eb.extra.items[notes_start] = @backingInt(try eb.addErrorMessage(.{ .msg = try eb.printString("try .url = \"{f}#{f}\",", .{ uri.fmt(.{ .scheme = true, .authority = true, .path = true }), want_oid, @@ -1472,7 +1472,7 @@ fn unpackTarball(f: *Fetch, out_dir: Io.Dir, reader: *Io.Reader) RunError!Unpack switch (item) { .unable_to_create_file => |i| res.unableToCreateFile(stripRoot(i.file_name, res.root_dir), i.code), .unable_to_create_sym_link => |i| res.unableToCreateSymLink(stripRoot(i.file_name, res.root_dir), i.link_name, i.code), - .unsupported_file_type => |i| res.unsupportedFileType(stripRoot(i.file_name, res.root_dir), @intFromEnum(i.file_type)), + .unsupported_file_type => |i| res.unsupportedFileType(stripRoot(i.file_name, res.root_dir), @backingInt(i.file_type)), .components_outside_stripped_prefix => unreachable, // unreachable with strip_components = 0 } } @@ -2205,21 +2205,21 @@ const UnpackResult = struct { if (item.excluded(filter)) continue; switch (item) { .unable_to_create_sym_link => |info| { - eb.extra.items[note_i] = @intFromEnum(try eb.addErrorMessage(.{ + eb.extra.items[note_i] = @backingInt(try eb.addErrorMessage(.{ .msg = try eb.printString("unable to create symlink from '{s}' to '{s}': {s}", .{ info.file_name, info.link_name, @errorName(info.code), }), })); }, .unable_to_create_file => |info| { - eb.extra.items[note_i] = @intFromEnum(try eb.addErrorMessage(.{ + eb.extra.items[note_i] = @backingInt(try eb.addErrorMessage(.{ .msg = try eb.printString("unable to create file '{s}': {s}", .{ info.file_name, @errorName(info.code), }), })); }, .unsupported_file_type => |info| { - eb.extra.items[note_i] = @intFromEnum(try eb.addErrorMessage(.{ + eb.extra.items[note_i] = @backingInt(try eb.addErrorMessage(.{ .msg = try eb.printString("file '{s}' has unsupported type '{c}'", .{ info.file_name, info.file_type, }), diff --git a/lib/compiler/Maker/Fetch/git.zig b/lib/compiler/Maker/Fetch/git.zig index d3bd1d701a618281355dba5e585d286cb3f9107f..2e040a81fe68c09eede82fac6ece736efe44cc60 100644 --- a/lib/compiler/Maker/Fetch/git.zig +++ b/lib/compiler/Maker/Fetch/git.zig @@ -1107,7 +1107,7 @@ pub const Session = struct { return error.ReadFailed; }) { .flush => return error.EndOfStream, - .data => |data| switch (@as(StreamCode, @enumFromInt(data[0]))) { + .data => |data| switch (@as(StreamCode, @fromBackingInt(@intCast(data[0])))) { .pack_data => { input.toss(1); fs.remaining_len = data.len - 1; diff --git a/lib/compiler/Maker/ScannedConfig.zig b/lib/compiler/Maker/ScannedConfig.zig index b137ee3a5325c8f811488bbc57e9222e9f9229b7..ead8acf064021af8ad3f4a344657189f4977fb14 100644 --- a/lib/compiler/Maker/ScannedConfig.zig +++ b/lib/compiler/Maker/ScannedConfig.zig @@ -26,11 +26,11 @@ pub fn print(sc: *const ScannedConfig, w: *Writer) Writer.Error!void { try tf.end(); } - try s.field("default_step", @intFromEnum(c.default_step), .{}); + try s.field("default_step", @backingInt(c.default_step), .{}); { var sf = try s.beginStructField("top_level_steps", .{}); for (sc.top_level_steps.keys(), sc.top_level_steps.values()) |name, step| { - try sf.field(name, @intFromEnum(step), .{}); + try sf.field(name, @backingInt(step), .{}); } try sf.end(); } @@ -122,7 +122,7 @@ fn printValue(sc: *const ScannedConfig, s: *Serializer, comptime Field: type, fi } else if (std.enums.tagName(Field, field_value)) |name| { try s.ident(name); } else { - try s.int(@intFromEnum(field_value)); + try s.int(@backingInt(field_value)); } }, .@"struct" => |info| switch (info.layout) { @@ -152,7 +152,7 @@ fn printValue(sc: *const ScannedConfig, s: *Serializer, comptime Field: type, fi inline else => |tag| { var sub_struct = try s.beginStruct(.{}); try sub_struct.fieldPrefix(@tagName(tag)); - try printValue(sc, s, @FieldType(Field.Union, @tagName(tag)), @enumFromInt(elem)); + try printValue(sc, s, @FieldType(Field.Union, @tagName(tag)), @fromBackingInt(@intCast(elem))); try sub_struct.end(); }, }; diff --git a/lib/compiler/Maker/Step.zig b/lib/compiler/Maker/Step.zig index 11f9095da07883568b5cb956f8b2b524ccb683b0..812613928eaa9134dd249e4fc2ece38065cad01c 100644 --- a/lib/compiler/Maker/Step.zig +++ b/lib/compiler/Maker/Step.zig @@ -610,7 +610,7 @@ fn zigProcessUpdate(step_index: Configuration.Step.Index, maker: *Maker, zp: *Zi const conf_step = step_index.ptr(conf); var it = std.mem.splitScalar(u8, body, 0); while (it.next()) |prefixed_path| { - const prefix_index: std.zig.Server.Message.PathPrefix = @enumFromInt(prefixed_path[0] - 1); + const prefix_index: std.zig.Server.Message.PathPrefix = @fromBackingInt(@intCast(prefixed_path[0] - 1)); const sub_path = try arena.dupe(u8, prefixed_path[1..]); const sub_path_dirname = Dir.path.dirname(sub_path) orelse ""; switch (prefix_index) { diff --git a/lib/compiler/Maker/Step/Compile.zig b/lib/compiler/Maker/Step/Compile.zig index 675dbc29258a6d8d203d652556cd5dc3eec7be8b..adf88b9f1baef3712b1d6ca707d4bed7db25e700 100644 --- a/lib/compiler/Maker/Step/Compile.zig +++ b/lib/compiler/Maker/Step/Compile.zig @@ -132,7 +132,7 @@ const ModuleListContext = struct { pub fn hash(ctx: @This(), key: ModuleList) u32 { _ = ctx; - return std.hash.int(@intFromEnum(key.keys()[0])); + return std.hash.int(@backingInt(key.keys()[0])); } const Adapter = struct { @@ -144,7 +144,7 @@ const ModuleListContext = struct { pub fn hash(ctx: @This(), key: Configuration.Module.Index) u32 { _ = ctx; - return std.hash.int(@intFromEnum(key)); + return std.hash.int(@backingInt(key)); } }; }; diff --git a/lib/compiler/Maker/Step/Run.zig b/lib/compiler/Maker/Step/Run.zig index b03f0336c0257dcdc9dcc0c0d323a07ca75a8eb0..b6fc911f01f8d25a27cf2f3829118accfe2f58ea 100644 --- a/lib/compiler/Maker/Step/Run.zig +++ b/lib/compiler/Maker/Step/Run.zig @@ -1380,7 +1380,7 @@ fn sendRunFuzzTestMessage( w.interface.writeStruct(header, .little) catch |err| switch (err) { error.WriteFailed => return w.err.?, }; - w.interface.writeByte(@intFromEnum(kind)) catch |err| switch (err) { + w.interface.writeByte(@backingInt(kind)) catch |err| switch (err) { error.WriteFailed => return w.err.?, }; w.interface.writeInt(u64, amount_or_instance, .little) catch |err| switch (err) { @@ -2106,8 +2106,8 @@ fn runCommand( if (conf_run.expect_term_value.value) |expected_term_value| { const expected_term: process.Child.Term = switch (conf_run.flags2.expect_term_status) { .exited => .{ .exited = @intCast(expected_term_value) }, - .signal => .{ .signal = @enumFromInt(expected_term_value) }, - .stopped => .{ .stopped = @enumFromInt(expected_term_value) }, + .signal => .{ .signal = @fromBackingInt(@intCast(expected_term_value)) }, + .stopped => .{ .stopped = @fromBackingInt(@intCast(expected_term_value)) }, .unknown => .{ .unknown = expected_term_value }, }; if (!termMatches(expected_term, generic_result.term)) { diff --git a/lib/compiler/Maker/Watch.zig b/lib/compiler/Maker/Watch.zig index fb8bca122804d0ba963f3827e29f38d69b40444e..4d40facdfc71076eb18f5958856fa3fce4f56741 100644 --- a/lib/compiler/Maker/Watch.zig +++ b/lib/compiler/Maker/Watch.zig @@ -903,7 +903,7 @@ pub const Match = struct { pub const Context = struct { pub fn hash(self: Context, a: Match) u32 { _ = self; - var hasher = Hash.init(@intFromEnum(a.step_index)); + var hasher = Hash.init(@backingInt(a.step_index)); hasher.update(a.basename); return @truncate(hasher.final()); } diff --git a/lib/compiler/Maker/WebServer.zig b/lib/compiler/Maker/WebServer.zig index 54527c805c35cfc4bdfbeadf27acee68fce8d691..e47f18bb5f786aba032d64dc37f806200f15636c 100644 --- a/lib/compiler/Maker/WebServer.zig +++ b/lib/compiler/Maker/WebServer.zig @@ -257,7 +257,7 @@ pub fn updateStepStatus( const ptr = &configured.step_status_bits[step_idx / 4]; const bit_offset: u3 = @intCast((step_idx % 4) * 2); const old_bits: u2 = @truncate(@atomicLoad(u8, ptr, .monotonic) >> bit_offset); - const mask = @as(u8, @intFromEnum(new_status) ^ old_bits) << bit_offset; + const mask = @as(u8, @backingInt(new_status) ^ old_bits) << bit_offset; _ = @atomicRmw(u8, ptr, .Xor, mask, .monotonic); ws.notifyUpdate(); } @@ -426,16 +426,16 @@ fn serveWebSocket(ws: *WebServer, sock: *http.Server.WebSocket) !noreturn { const cur_byte = @atomicLoad(u8, shared, .monotonic); if (prev_byte.* == cur_byte) continue; const cur: [4]abi.StepUpdate.Status = .{ - @enumFromInt(@as(u2, @truncate(cur_byte >> 0))), - @enumFromInt(@as(u2, @truncate(cur_byte >> 2))), - @enumFromInt(@as(u2, @truncate(cur_byte >> 4))), - @enumFromInt(@as(u2, @truncate(cur_byte >> 6))), + @fromBackingInt(@intCast(@as(u2, @truncate(cur_byte >> 0)))), + @fromBackingInt(@intCast(@as(u2, @truncate(cur_byte >> 2)))), + @fromBackingInt(@intCast(@as(u2, @truncate(cur_byte >> 4)))), + @fromBackingInt(@intCast(@as(u2, @truncate(cur_byte >> 6)))), }; const prev: [4]abi.StepUpdate.Status = .{ - @enumFromInt(@as(u2, @truncate(prev_byte.* >> 0))), - @enumFromInt(@as(u2, @truncate(prev_byte.* >> 2))), - @enumFromInt(@as(u2, @truncate(prev_byte.* >> 4))), - @enumFromInt(@as(u2, @truncate(prev_byte.* >> 6))), + @fromBackingInt(@intCast(@as(u2, @truncate(prev_byte.* >> 0)))), + @fromBackingInt(@intCast(@as(u2, @truncate(prev_byte.* >> 2)))), + @fromBackingInt(@intCast(@as(u2, @truncate(prev_byte.* >> 4)))), + @fromBackingInt(@intCast(@as(u2, @truncate(prev_byte.* >> 6)))), }; for (cur, prev, byte_idx * 4..) |cur_status, prev_status, step_idx| { const msg: abi.StepUpdate = .{ .step_idx = @intCast(step_idx), .bits = .{ .status = cur_status } }; @@ -469,7 +469,7 @@ fn recvWebSocketMessages(ws: *WebServer, sock: *http.Server.WebSocket) void { const msg = sock.readSmallMessage() catch return; if (msg.opcode != .binary) continue; if (msg.data.len == 0) continue; - const tag: abi.ToServerTag = @enumFromInt(msg.data[0]); + const tag: abi.ToServerTag = @fromBackingInt(@intCast(msg.data[0])); switch (tag) { _ => continue, .rebuild => while (true) { diff --git a/lib/compiler/aro/aro/Attribute.zig b/lib/compiler/aro/aro/Attribute.zig index b5177924988f98d20d92a7b0a69f580f9392599d..706eb65945223bd274ac8b3ee89e34127b896094 100644 --- a/lib/compiler/aro/aro/Attribute.zig +++ b/lib/compiler/aro/aro/Attribute.zig @@ -154,7 +154,7 @@ pub const Formatting = struct { if (@typeInfo(Unwrapped) != .@"enum") unreachable; const enum_field_names = @typeInfo(Unwrapped).@"enum".field_names; - const quote = comptime quoteChar(@enumFromInt(@intFromEnum(tag))); + const quote = comptime quoteChar(@fromBackingInt(@intCast(@backingInt(tag)))); comptime var values: []const u8 = quote ++ enum_field_names[0] ++ quote; inline for (enum_field_names[1..]) |enum_field_name| { values = values ++ ", "; @@ -344,7 +344,7 @@ fn diagnoseField( pub fn diagnose(attr: Tag, arguments: *Arguments, arg_idx: u32, res: Parser.Result, arg_start: TokenIndex, node: Tree.Node, p: *Parser) !bool { switch (attr) { inline else => |tag| { - const decl_name = @typeInfo(attributes).@"struct".decl_names[@intFromEnum(tag)]; + const decl_name = @typeInfo(attributes).@"struct".decl_names[@backingInt(tag)]; const max_arg_count = comptime maxArgCount(tag); if (arg_idx >= max_arg_count) { try p.err(arg_start, .attribute_too_many_args, .{ @tagName(attr), max_arg_count }); @@ -735,7 +735,7 @@ pub const Arguments = blk: { }; pub fn ArgumentsForTag(comptime tag: Tag) type { - const decl_name = @typeInfo(attributes).@"struct".decl_names[@intFromEnum(tag)]; + const decl_name = @typeInfo(attributes).@"struct".decl_names[@backingInt(tag)]; return @field(attributes, decl_name); } diff --git a/lib/compiler/aro/aro/Builtins.zig b/lib/compiler/aro/aro/Builtins.zig index b9a21bf7e3d1590ca07b53a4471b3c17cb78a336..1cefdab5f50a94eb1b07e8b5e8976a7737fd7031 100644 --- a/lib/compiler/aro/aro/Builtins.zig +++ b/lib/compiler/aro/aro/Builtins.zig @@ -360,7 +360,7 @@ pub fn fromName(comp: *Compilation, name: []const u8) ?FromName { fn fromNameExtra(name: []const u8, comptime arch: std.meta.Tag(Tag)) ?FromName { const list = @field(@This(), @tagName(arch)); const tag = list.tagFromName(name) orelse return null; - const builtin = list.data[@intFromEnum(tag)]; + const builtin = list.data[@backingInt(tag)]; return .{ .tag = @unionInit(Tag, @tagName(arch), tag), @@ -392,7 +392,7 @@ test "all builtins" { for (features) |valid_feature| { if (std.mem.eql(u8, feature, valid_feature.name)) continue :outer; } - std.debug.panic("unknown feature {s} on {t}\n", .{ feature, @as(list.Tag, @enumFromInt(index)) }); + std.debug.panic("unknown feature {s} on {t}\n", .{ feature, @as(list.Tag, @fromBackingInt(@intCast(index))) }); } } } diff --git a/lib/compiler/aro/aro/CodeGen.zig b/lib/compiler/aro/aro/CodeGen.zig index fdbcb9909e0d17fb3c08ded8ff4283a754d096f2..5e75031ebb2a9bb49a8873c2347750c6c8757ccb 100644 --- a/lib/compiler/aro/aro/CodeGen.zig +++ b/lib/compiler/aro/aro/CodeGen.zig @@ -718,7 +718,7 @@ fn genExpr(c: *CodeGen, node_index: Node.Index) Error!Ir.Ref { } try c.builder.startBlock(then_label); - if (c.builder.instructions.items(.ty)[@intFromEnum(c.cond_dummy_ref)] == .i1) { + if (c.builder.instructions.items(.ty)[@backingInt(c.cond_dummy_ref)] == .i1) { c.cond_dummy_ref = try c.addUn(.zext, c.cond_dummy_ref, cond_qt); } const then_val = try c.genExpr(conditional.then_expr); @@ -895,7 +895,7 @@ fn genLval(c: *CodeGen, node_index: Node.Index) Error!Ir.Ref { } const duped_name = try c.builder.arena.allocator().dupeSentinel(u8, slice, 0); - const ref: Ir.Ref = @enumFromInt(c.builder.instructions.len); + const ref: Ir.Ref = @fromBackingInt(@intCast(c.builder.instructions.len)); try c.builder.instructions.append(c.builder.gpa, .{ .tag = .symbol, .data = .{ .label = duped_name }, .ty = .ptr }); return ref; }, @@ -1113,7 +1113,7 @@ fn genCall(c: *CodeGen, call: Node.Call) Error!Ir.Ref { } const duped_name = try c.builder.arena.allocator().dupeSentinel(u8, slice, 0); - const ref: Ir.Ref = @enumFromInt(c.builder.instructions.len); + const ref: Ir.Ref = @fromBackingInt(@intCast(c.builder.instructions.len)); try c.builder.instructions.append(c.builder.gpa, .{ .tag = .symbol, .data = .{ .label = duped_name }, .ty = .ptr }); break :blk ref; }, diff --git a/lib/compiler/aro/aro/Compilation.zig b/lib/compiler/aro/aro/Compilation.zig index f1dc72ae86c5f15611e77cbdbf69a28339d2b275..d25154248e48cb68a2a07cca639d13942c61ec81 100644 --- a/lib/compiler/aro/aro/Compilation.zig +++ b/lib/compiler/aro/aro/Compilation.zig @@ -595,7 +595,7 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void { .{ .mmx, "__MMX__" }, }) |fs| { - if (features.isEnabled(@intFromEnum(fs[0]))) { + if (features.isEnabled(@backingInt(fs[0]))) { try define(w, fs[1]); } } @@ -808,7 +808,7 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void { .{ .d128, "SYSREG128" }, .{ .gcs, "GCS" }, }) |fs| { - if (features.isEnabled(@intFromEnum(fs[0]))) { + if (features.isEnabled(@backingInt(fs[0]))) { try w.print("#define __ARM_FEATURE_{s} 1\n", .{fs[1]}); } } @@ -1013,7 +1013,7 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void { // TODO: clang treats __FLT_EVAL_METHOD__ as a special-cased macro because evaluating it within a scope // where `#pragma clang fp eval_method(X)` has been called produces an error diagnostic. const flt_eval_method = comp.langopts.fp_eval_method orelse target.defaultFpEvalMethod(); - try w.print("#define __FLT_EVAL_METHOD__ {d}\n", .{@intFromEnum(flt_eval_method)}); + try w.print("#define __FLT_EVAL_METHOD__ {d}\n", .{@backingInt(flt_eval_method)}); try w.writeAll( \\#define __FLT_RADIX__ 2 @@ -1028,13 +1028,13 @@ fn generateSystemDefines(comp: *Compilation, w: *Io.Writer) !void { \\#define __pic__ {0d} \\#define __PIC__ {0d} \\ - , .{@intFromEnum(comp.code_gen_options.pic_level)}); + , .{@backingInt(comp.code_gen_options.pic_level)}); if (comp.code_gen_options.is_pie) { try w.print( \\#define __pie__ {0d} \\#define __PIE__ {0d} \\ - , .{@intFromEnum(comp.code_gen_options.pic_level)}); + , .{@backingInt(comp.code_gen_options.pic_level)}); } }, } @@ -1459,7 +1459,7 @@ pub fn hasClangStyleBoundsSafety(comp: *const Compilation) bool { pub fn getSource(comp: *const Compilation, id: Source.Id) Source { if (id.alias) { - return comp.source_aliases.items[@intFromEnum(id.index)]; + return comp.source_aliases.items[@backingInt(id.index)]; } if (id.index == .generated) return .{ .path = "", @@ -1468,7 +1468,7 @@ pub fn getSource(comp: *const Compilation, id: Source.Id) Source { .splice_locs = &.{}, .kind = .user, }; - return comp.sources.values()[@intFromEnum(id.index)]; + return comp.sources.values()[@backingInt(id.index)]; } /// Creates a Source from `buf` and adds it to the Compilation @@ -1488,7 +1488,7 @@ pub fn addSourceFromOwnedBuffer(comp: *Compilation, path: []const u8, buf: []u8, var splice_list: std.ArrayList(u32) = .empty; defer splice_list.deinit(comp.gpa); - const source_id: Source.Id = .{ .index = @enumFromInt(comp.sources.count()) }; + const source_id: Source.Id = .{ .index = @fromBackingInt(@intCast(comp.sources.count())) }; var i: u32 = 0; var backslash_loc: u32 = undefined; @@ -1690,7 +1690,7 @@ pub fn addSourceFromFile(comp: *Compilation, file: std.Io.File, path: []const u8 pub fn addSourceAlias(comp: *Compilation, source: Source.Id, new_path: []const u8, new_kind: Source.Kind) !Source.Id { var aliased_source = comp.getSource(source); aliased_source.path = new_path; - aliased_source.id = .{ .index = @enumFromInt(comp.source_aliases.items.len), .alias = true }; + aliased_source.id = .{ .index = @fromBackingInt(@intCast(comp.source_aliases.items.len)), .alias = true }; aliased_source.kind = new_kind; try comp.source_aliases.append(comp.gpa, aliased_source); return aliased_source.id; diff --git a/lib/compiler/aro/aro/Diagnostics.zig b/lib/compiler/aro/aro/Diagnostics.zig index 78284de14266d934c1773c798835aa54f22237e9..e2cd09c19f952da6c3e9507011443efea189cb5a 100644 --- a/lib/compiler/aro/aro/Diagnostics.zig +++ b/lib/compiler/aro/aro/Diagnostics.zig @@ -405,7 +405,7 @@ pub fn effectiveKind(d: *Diagnostics, message: anytype) Message.Kind { // Use extension diagnostic behavior if not set explicitly. if (message.extension and !set_explicit) { - kind = @enumFromInt(@max(@intFromEnum(kind), @intFromEnum(d.state.extensions))); + kind = @fromBackingInt(@intCast(@max(@backingInt(kind), @backingInt(d.state.extensions)))); } // Make diagnostic a warning if -Weverything is set. diff --git a/lib/compiler/aro/aro/Hideset.zig b/lib/compiler/aro/aro/Hideset.zig index 27641138dbdd42b635cb4539b2005f0917305e8e..9a1c75d3202270456089df19d232d79ba00d0500 100644 --- a/lib/compiler/aro/aro/Hideset.zig +++ b/lib/compiler/aro/aro/Hideset.zig @@ -67,8 +67,8 @@ const Iterator = struct { fn next(self: *Iterator) ?Identifier { if (self.i == .none) return null; - defer self.i = self.slice.items(.next)[@intFromEnum(self.i)]; - return self.slice.items(.identifier)[@intFromEnum(self.i)]; + defer self.i = self.slice.items(.next)[@backingInt(self.i)]; + return self.slice.items(.identifier)[@backingInt(self.i)]; } }; @@ -118,14 +118,14 @@ fn createNodeAssumeCapacity(self: *Hideset, identifier: Identifier) Index { fn createNodeAssumeCapacityExtra(self: *Hideset, identifier: Identifier, next: Index) Index { const next_idx = self.linked_list.len; self.linked_list.appendAssumeCapacity(.{ .identifier = identifier, .next = next }); - return @enumFromInt(next_idx); + return @fromBackingInt(@intCast(next_idx)); } /// Create a new list with `identifier` at the front followed by `tail` pub fn prepend(self: *Hideset, loc: Source.Location, tail: Index) !Index { const new_idx = self.linked_list.len; try self.linked_list.append(self.comp.gpa, .{ .identifier = Identifier.fromLocation(loc), .next = tail }); - return @enumFromInt(new_idx); + return @fromBackingInt(@intCast(new_idx)); } /// Attach elements of `b` to the front of `a` (if they're not in `a`) @@ -163,7 +163,7 @@ fn len(self: *const Hideset, list: Index) usize { var cur = list; var count: usize = 0; while (cur != .none) : (count += 1) { - cur = nexts[@intFromEnum(cur)]; + cur = nexts[@backingInt(cur)]; } return count; } @@ -189,7 +189,7 @@ pub fn intersection(self: *Hideset, a: Index, b: Index) !Index { head = new_idx; } if (cur != .none) { - self.linked_list.items(.next)[@intFromEnum(cur)] = new_idx; + self.linked_list.items(.next)[@backingInt(cur)] = new_idx; } cur = new_idx; } diff --git a/lib/compiler/aro/aro/LangOpts.zig b/lib/compiler/aro/aro/LangOpts.zig index a152607efe62b43001ae2fa03f942367db608298..abed5c8230ed5bcd877c2622e267294700dc558d 100644 --- a/lib/compiler/aro/aro/LangOpts.zig +++ b/lib/compiler/aro/aro/LangOpts.zig @@ -75,7 +75,7 @@ pub const Standard = enum { }); pub fn atLeast(self: Standard, other: Standard) bool { - return @intFromEnum(self) >= @intFromEnum(other); + return @backingInt(self) >= @backingInt(other); } pub fn isGNU(standard: Standard) bool { diff --git a/lib/compiler/aro/aro/Parser.zig b/lib/compiler/aro/aro/Parser.zig index 3388150e1fe995720dc557801b4204c8d6a36a2c..aaca37df1b1d02dc5d21f96bc10c49521e2d8c75 100644 --- a/lib/compiler/aro/aro/Parser.zig +++ b/lib/compiler/aro/aro/Parser.zig @@ -316,7 +316,7 @@ fn validateExtendedIdentifier(p: *Parser) !bool { // Check NFC normalization. if (!normalized) continue; const canonical_class = char_info.getCanonicalClass(codepoint); - if (@intFromEnum(last_canonical_class) > @intFromEnum(canonical_class) and + if (@backingInt(last_canonical_class) > @backingInt(canonical_class) and canonical_class != .not_reordered) { normalized = false; @@ -515,7 +515,7 @@ fn formatResult(p: *Parser, w: *std.Io.Writer, fmt: []const u8, res: Result) !us .null => try w.writeAll("nullptr_t"), else => if (try res.val.print(res.qt, p.comp, w)) |nested| switch (nested) { .pointer => |ptr| { - const ptr_node: Node.Index = @enumFromInt(ptr.node); + const ptr_node: Node.Index = @fromBackingInt(@intCast(ptr.node)); const decl_name = p.tree.tokSlice(ptr_node.tok(&p.tree)); try ptr.offset.printPointer(decl_name, p.comp, w); }, @@ -666,16 +666,16 @@ fn addList(p: *Parser, nodes: []const Node.Index) Allocator.Error!Tree.Node.Rang /// Recursively sets the defintion field of `tentative_decl` to `definition`. pub fn setTentativeDeclDefinition(p: *Parser, tentative_decl: Node.Index, definition: Node.Index) void { - const node_data = &p.tree.nodes.items(.data)[@intFromEnum(tentative_decl)]; - switch (p.tree.nodes.items(.tag)[@intFromEnum(tentative_decl)]) { + const node_data = &p.tree.nodes.items(.data)[@backingInt(tentative_decl)]; + switch (p.tree.nodes.items(.tag)[@backingInt(tentative_decl)]) { .fn_proto => {}, .variable => {}, else => return, } - const prev: Node.OptIndex = @enumFromInt(node_data[2]); + const prev: Node.OptIndex = @fromBackingInt(@intCast(node_data[2])); - node_data[2] = @intFromEnum(definition); + node_data[2] = @backingInt(definition); if (prev.unpack()) |some| { p.setTentativeDeclDefinition(some, definition); } @@ -687,20 +687,20 @@ fn clearNonTentativeDefinitions(p: *Parser) void { const tags = p.tree.nodes.items(.tag); const data = p.tree.nodes.items(.data); for (p.tree.root_decls.items) |root_decl| { - switch (tags[@intFromEnum(root_decl)]) { + switch (tags[@backingInt(root_decl)]) { .fn_proto => { - const node_data = &data[@intFromEnum(root_decl)]; - if (node_data[2] != @intFromEnum(Node.OptIndex.null)) { + const node_data = &data[@backingInt(root_decl)]; + if (node_data[2] != @backingInt(Node.OptIndex.null)) { if (tags[node_data[2]] != .fn_def) { - node_data[2] = @intFromEnum(Node.OptIndex.null); + node_data[2] = @backingInt(Node.OptIndex.null); } } }, .variable => { - const node_data = &data[@intFromEnum(root_decl)]; - if (node_data[2] != @intFromEnum(Node.OptIndex.null)) { + const node_data = &data[@backingInt(root_decl)]; + if (node_data[2] != @backingInt(Node.OptIndex.null)) { if (tags[node_data[2]] != .variable_def) { - node_data[2] = @intFromEnum(Node.OptIndex.null); + node_data[2] = @backingInt(Node.OptIndex.null); } } }, @@ -1326,7 +1326,7 @@ fn decl(p: *Parser) Error!bool { .qt = p.func.qt.?, .body = body, .definition = null, - } }, @intFromEnum(decl_node)); + } }, @backingInt(decl_node)); try p.decl_buf.append(gpa, decl_node); @@ -1358,7 +1358,7 @@ fn decl(p: *Parser) Error!bool { .name_tok = init_d.d.name, .qt = init_d.d.qt, .implicit = false, - } }, @intFromEnum(decl_node)); + } }, @backingInt(decl_node)); } else if (init_d.d.declarator_type == .func or init_d.d.qt.is(p.comp, .func)) { try decl_spec.validateFnDecl(p); try p.tree.setNode(.{ .function = .{ @@ -1368,7 +1368,7 @@ fn decl(p: *Parser) Error!bool { .@"inline" = decl_spec.@"inline" != null, .body = null, .definition = null, - } }, @intFromEnum(decl_node)); + } }, @backingInt(decl_node)); } else { try decl_spec.validateDecl(p, init_d.asm_label); var node_qt = init_d.d.qt; @@ -1400,7 +1400,7 @@ fn decl(p: *Parser) Error!bool { .initializer = if (init_d.initializer) |some| some.node else null, .definition = null, }, - }, @intFromEnum(decl_node)); + }, @backingInt(decl_node)); } try p.decl_buf.append(gpa, decl_node); @@ -2425,7 +2425,7 @@ fn recordSpec(p: *Parser) Error!QualType { const record_ty: Type.Record = .{ .name = interned_name, .layout = null, - .decl_node = @enumFromInt(reserved_index), + .decl_node = @fromBackingInt(@intCast(reserved_index)), .fields = &.{}, }; const record_qt = try p.comp.type_store.put(gpa, if (is_struct) @@ -2451,7 +2451,7 @@ fn recordSpec(p: *Parser) Error!QualType { .{ .struct_forward_decl = fw } else .{ .union_forward_decl = fw }, reserved_index); - try p.decl_buf.append(gpa, @enumFromInt(reserved_index)); + try p.decl_buf.append(gpa, @fromBackingInt(@intCast(reserved_index))); return attributed_qt; } }; @@ -2481,7 +2481,7 @@ fn recordSpec(p: *Parser) Error!QualType { // can be specified after the closing rbrace, which we haven't encountered yet. const record_ty: Type.Record = .{ .name = interned_name, - .decl_node = @enumFromInt(reserved_index), + .decl_node = @fromBackingInt(@intCast(reserved_index)), .layout = null, .fields = &.{}, }; @@ -2505,7 +2505,7 @@ fn recordSpec(p: *Parser) Error!QualType { break :blk .{ record_ty, record_qt }; }; - try p.decl_buf.append(gpa, @enumFromInt(reserved_index)); + try p.decl_buf.append(gpa, @fromBackingInt(@intCast(reserved_index))); const decl_buf_top = p.decl_buf.items.len; const record_buf_top = p.record_buf.items.len; errdefer p.decl_buf.items.len = decl_buf_top - 1; @@ -2557,15 +2557,15 @@ fn recordSpec(p: *Parser) Error!QualType { .pointer_alignment_bits = 8, .required_alignment_bits = 8, }; - record_ty.decl_node = @enumFromInt(reserved_index); + record_ty.decl_node = @fromBackingInt(@intCast(reserved_index)); const base_type = qt.base(p.comp); if (is_struct) { std.debug.assert(base_type.type.@"struct".name == record_ty.name); - try p.comp.type_store.set(gpa, .{ .@"struct" = record_ty }, @intFromEnum(base_type.qt._index)); + try p.comp.type_store.set(gpa, .{ .@"struct" = record_ty }, @backingInt(base_type.qt._index)); } else { std.debug.assert(base_type.type.@"union".name == record_ty.name); - try p.comp.type_store.set(gpa, .{ .@"union" = record_ty }, @intFromEnum(base_type.qt._index)); + try p.comp.type_store.set(gpa, .{ .@"union" = record_ty }, @backingInt(base_type.qt._index)); } break :blk false; }; @@ -2597,7 +2597,7 @@ fn recordSpec(p: *Parser) Error!QualType { // Override previous incomplete layout and fields. const base_qt = qt.base(p.comp).qt; const ts = &p.comp.type_store; - var extra_index = ts.types.items(.data)[@intFromEnum(base_qt._index)][1]; + var extra_index = ts.types.items(.data)[@backingInt(base_qt._index)][1]; const layout_size = 5; comptime std.debug.assert(@sizeOf(Type.Record.Layout) == @sizeOf(u32) * layout_size); @@ -2804,7 +2804,7 @@ fn recordDecl(p: *Parser) Error!bool { .name = interned_name, .qt = qt, .name_tok = name_tok, - .bit_width = if (bits) |some| @enumFromInt(some) else .null, + .bit_width = if (bits) |some| @fromBackingInt(@intCast(some)) else .null, ._attr_index = attr_index, ._attr_len = attr_len, }); @@ -2951,7 +2951,7 @@ fn enumSpec(p: *Parser) Error!QualType { .tag = fixed_qt, .fixed = fixed_qt != null, .incomplete = true, - .decl_node = @enumFromInt(reserved_index), + .decl_node = @fromBackingInt(@intCast(reserved_index)), .fields = &.{}, } }); @@ -3001,7 +3001,7 @@ fn enumSpec(p: *Parser) Error!QualType { // can be specified after the closing rbrace, which we haven't encountered yet. const enum_ty: Type.Enum = .{ .name = interned_name, - .decl_node = @enumFromInt(reserved_index), + .decl_node = @fromBackingInt(@intCast(reserved_index)), .tag = fixed_qt, .incomplete = true, .fixed = fixed_qt != null, @@ -3012,7 +3012,7 @@ fn enumSpec(p: *Parser) Error!QualType { }; // reserve space for this enum - try p.decl_buf.append(gpa, @enumFromInt(reserved_index)); + try p.decl_buf.append(gpa, @fromBackingInt(@intCast(reserved_index))); const decl_buf_top = p.decl_buf.items.len; const list_buf_top = p.list_buf.items.len; const enum_buf_top = p.enum_buf.items.len; @@ -3076,17 +3076,17 @@ fn enumSpec(p: *Parser) Error!QualType { new_field_node.enum_field.init = res.node; } - try p.tree.setNode(new_field_node, @intFromEnum(field_node)); + try p.tree.setNode(new_field_node, @backingInt(field_node)); } } { // Override previous incomplete type enum_ty.fields = enum_fields; enum_ty.incomplete = false; - enum_ty.decl_node = @enumFromInt(reserved_index); + enum_ty.decl_node = @fromBackingInt(@intCast(reserved_index)); const base_type = attributed_qt.base(p.comp); std.debug.assert(base_type.type.@"enum".name == enum_ty.name); - try p.comp.type_store.set(gpa, .{ .@"enum" = enum_ty }, @intFromEnum(base_type.qt._index)); + try p.comp.type_store.set(gpa, .{ .@"enum" = enum_ty }, @backingInt(base_type.qt._index)); } // declare a symbol for the type @@ -3619,7 +3619,7 @@ fn declarator( else => unreachable, } // Child type is always stored in repr.data[0] - p.comp.type_store.types.items(.data)[@intFromEnum(cur._index)][0] = @bitCast(outer); + p.comp.type_store.types.items(.data)[@backingInt(cur._index)][0] = @bitCast(outer); break; } } @@ -5565,7 +5565,7 @@ fn pointerValue(p: *Parser, node: Node.Index, offset: Value) !Value { const var_name = try p.comp.internString(p.tokSlice(decl_ref.name_tok)); const sym = p.syms.findSymbol(var_name) orelse return .{}; const sym_node = sym.node.unpack() orelse return .{}; - return Value.pointer(.{ .node = @intFromEnum(sym_node), .offset = offset.ref() }, p.comp); + return Value.pointer(.{ .node = @backingInt(sym_node), .offset = offset.ref() }, p.comp); }, .string_literal_expr => return p.tree.value_map.get(node).?, else => return .{}, @@ -10066,7 +10066,7 @@ fn stringLiteral(p: *Parser) Error!Result { const strings_top = p.strings.items.len; defer p.strings.items.len = strings_top; - const literal_start = mem.alignForward(usize, strings_top, @intFromEnum(char_width)); + const literal_start = mem.alignForward(usize, strings_top, @backingInt(char_width)); try p.strings.resize(gpa, literal_start); while (p.tok_i < string_end) : (p.tok_i += 1) { @@ -10082,7 +10082,7 @@ fn stringLiteral(p: *Parser) Error!Result { .incorrect_encoding_is_error = count > 1, }; - try p.strings.ensureUnusedCapacity(gpa, (slice.len + 1) * @intFromEnum(char_width)); // +1 for null terminator + try p.strings.ensureUnusedCapacity(gpa, (slice.len + 1) * @backingInt(char_width)); // +1 for null terminator while (try char_literal_parser.next()) |item| switch (item) { .value => |v| { switch (char_width) { @@ -10143,7 +10143,7 @@ fn stringLiteral(p: *Parser) Error!Result { }, }; } - p.strings.appendNTimesAssumeCapacity(0, @intFromEnum(char_width)); + p.strings.appendNTimesAssumeCapacity(0, @backingInt(char_width)); const slice = p.strings.items[literal_start..]; // TODO this won't do anything if there is a cache hit @@ -10158,7 +10158,7 @@ fn stringLiteral(p: *Parser) Error!Result { const array_qt = try p.comp.type_store.put(gpa, .{ .array = .{ .elem = string_kind.elementType(p.comp), - .len = .{ .fixed = @divExact(slice.len, @intFromEnum(char_width)) }, + .len = .{ .fixed = @divExact(slice.len, @backingInt(char_width)) }, } }); const res: Result = .{ .qt = array_qt, @@ -10503,7 +10503,7 @@ fn parseInt(p: *Parser, prefix: NumberPrefix, buf: []const u8, suffix: NumberSuf if (prefix == .binary) { try p.err(tok_i, .binary_integer_literal, .{}); } - const base = @intFromEnum(prefix); + const base = @backingInt(prefix); var res = if (suffix.isBitInt()) try p.bitInt(base, buf, suffix, tok_i) else diff --git a/lib/compiler/aro/aro/Preprocessor.zig b/lib/compiler/aro/aro/Preprocessor.zig index 2018da7bd023d347fdedccfadf029a25140b4054..42244e41cbaa2268107e01cac5a02f90793f848d 100644 --- a/lib/compiler/aro/aro/Preprocessor.zig +++ b/lib/compiler/aro/aro/Preprocessor.zig @@ -45,11 +45,11 @@ const IfContext = struct { level: u8, fn get(self: *const IfContext) Nesting { - return @enumFromInt(std.mem.readPackedInt(Backing, &self.kind, @as(usize, self.level) * 2, .native)); + return @fromBackingInt(@intCast(std.mem.readPackedInt(Backing, &self.kind, @as(usize, self.level) * 2, .native))); } fn set(self: *IfContext, context: Nesting) void { - std.mem.writePackedInt(Backing, &self.kind, @as(usize, self.level) * 2, @intFromEnum(context), .native); + std.mem.writePackedInt(Backing, &self.kind, @as(usize, self.level) * 2, @backingInt(context), .native); } fn increment(self: *IfContext) bool { diff --git a/lib/compiler/aro/aro/StringInterner.zig b/lib/compiler/aro/aro/StringInterner.zig index 021bd3f602438587c91d8db63de450ba58098d65..1ee97fbbb762532f58874670b499760db19ad22d 100644 --- a/lib/compiler/aro/aro/StringInterner.zig +++ b/lib/compiler/aro/aro/StringInterner.zig @@ -10,12 +10,12 @@ pub const StringId = enum(u32) { pub fn lookup(id: StringId, comp: *const Compilation) []const u8 { if (id == .empty) return ""; - return comp.string_interner.table.keys()[@intFromEnum(id)]; + return comp.string_interner.table.keys()[@backingInt(id)]; } pub fn lookupExtra(id: StringId, si: StringInterner) []const u8 { if (id == .empty) return ""; - return si.table.keys()[@intFromEnum(id)]; + return si.table.keys()[@backingInt(id)]; } }; @@ -31,5 +31,5 @@ pub fn intern(si: *StringInterner, allocator: mem.Allocator, str: []const u8) !S if (str.len == 0) return .empty; const gop = try si.table.getOrPut(allocator, str); - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } diff --git a/lib/compiler/aro/aro/Target.zig b/lib/compiler/aro/aro/Target.zig index 842b383b164915953475f198d85091076c1d4dc2..3a871504700f666b6e74ca464d37c0770568c43d 100644 --- a/lib/compiler/aro/aro/Target.zig +++ b/lib/compiler/aro/aro/Target.zig @@ -104,14 +104,14 @@ pub const SubArch = enum { pub fn toFeature(sub: SubArch, arch: Cpu.Arch) ?std.Target.Cpu.Feature.Set.Index { if (arch.isPowerPC()) { - if (sub == .powerpc_spe) return @intFromEnum(std.Target.powerpc.Feature.spe); + if (sub == .powerpc_spe) return @backingInt(std.Target.powerpc.Feature.spe); } else if (arch.isMIPS32()) { - return @intFromEnum(std.Target.mips.Feature.mips32r6); + return @backingInt(std.Target.mips.Feature.mips32r6); } else if (arch.isMIPS64()) { - return @intFromEnum(std.Target.mips.Feature.mips64r6); + return @backingInt(std.Target.mips.Feature.mips64r6); } else if (arch.isSpirV()) { const spirv = std.Target.spirv.Feature; - return @intFromEnum(switch (sub) { + return @backingInt(switch (sub) { .spirv_v10 => spirv.v1_0, .spirv_v11 => spirv.v1_1, .spirv_v12 => spirv.v1_2, @@ -123,7 +123,7 @@ pub const SubArch = enum { }); } else if (arch.isAARCH64()) { const aarch64 = std.Target.aarch64.Feature; - return @intFromEnum(switch (sub) { + return @backingInt(switch (sub) { .arm_v8_1a => aarch64.v8_1a, .arm_v8_2a => aarch64.v8_2a, .arm_v8_3a => aarch64.v8_3a, @@ -149,7 +149,7 @@ pub const SubArch = enum { }); } else if (arch.isArm()) { const arm = std.Target.arm.Feature; - return @intFromEnum(switch (sub) { + return @backingInt(switch (sub) { .arm_v4t => arm.v4t, .arm_v5 => arm.v5t, .arm_v5te => arm.v5te, diff --git a/lib/compiler/aro/aro/Tokenizer.zig b/lib/compiler/aro/aro/Tokenizer.zig index 251a9897b395006b44b7e385eca80244ea8cd5bd..8c9c1e5405fdaa6b7e15810e7804293fe4d43490 100644 --- a/lib/compiler/aro/aro/Tokenizer.zig +++ b/lib/compiler/aro/aro/Tokenizer.zig @@ -1218,7 +1218,7 @@ pub fn next(self: *Tokenizer) Token { break; }, .hex4, .hex8 => { - self.index += @intFromEnum(ucn_kind); + self.index += @backingInt(ucn_kind); id = .extended_identifier; state = .extended_identifier; }, @@ -1458,7 +1458,7 @@ pub fn next(self: *Tokenizer) Token { }, .hex4, .hex8 => { state = .extended_identifier; - self.index += @intFromEnum(ucn_kind); + self.index += @backingInt(ucn_kind); }, } }, diff --git a/lib/compiler/aro/aro/Tree.zig b/lib/compiler/aro/aro/Tree.zig index 1bd854b43fcce8d4e392b11b66df2a109f2af021..c0d73a376c256d03d52e9c016045aaabadff831a 100644 --- a/lib/compiler/aro/aro/Tree.zig +++ b/lib/compiler/aro/aro/Tree.zig @@ -732,9 +732,9 @@ pub const Node = union(enum) { _, pub fn get(index: Index, tree: *const Tree) Node { - const node_tok = tree.nodes.items(.tok)[@intFromEnum(index)]; - const node_data = &tree.nodes.items(.data)[@intFromEnum(index)]; - return switch (tree.nodes.items(.tag)[@intFromEnum(index)]) { + const node_tok = tree.nodes.items(.tok)[@backingInt(index)]; + const node_data = &tree.nodes.items(.data)[@backingInt(index)]; + return switch (tree.nodes.items(.tag)[@backingInt(index)]) { .empty_decl => .{ .empty_decl = .{ .semicolon = node_tok, @@ -743,7 +743,7 @@ pub const Node = union(enum) { .static_assert => .{ .static_assert = .{ .assert_tok = node_tok, - .cond = @enumFromInt(node_data[0]), + .cond = @fromBackingInt(@intCast(node_data[0])), .message = unpackOptIndex(node_data[1]), }, }, @@ -768,7 +768,7 @@ pub const Node = union(enum) { .qt = @bitCast(node_data[0]), .static = attr.static, .@"inline" = attr.@"inline", - .body = @enumFromInt(node_data[2]), + .body = @fromBackingInt(@intCast(node_data[2])), .definition = null, }, }; @@ -838,7 +838,7 @@ pub const Node = union(enum) { .global_asm => .{ .global_asm = .{ .asm_tok = node_tok, - .asm_str = @enumFromInt(node_data[0]), + .asm_str = @fromBackingInt(@intCast(node_data[0])), }, }, .struct_decl => .{ @@ -922,7 +922,7 @@ pub const Node = union(enum) { .labeled_stmt = .{ .label_tok = node_tok, .qt = @bitCast(node_data[0]), - .body = @enumFromInt(node_data[1]), + .body = @fromBackingInt(@intCast(node_data[1])), }, }, .compound_stmt => .{ @@ -940,44 +940,44 @@ pub const Node = union(enum) { .if_stmt => .{ .if_stmt = .{ .if_tok = node_tok, - .cond = @enumFromInt(node_data[0]), - .then_body = @enumFromInt(node_data[1]), + .cond = @fromBackingInt(@intCast(node_data[0])), + .then_body = @fromBackingInt(@intCast(node_data[1])), .else_body = unpackOptIndex(node_data[2]), }, }, .switch_stmt => .{ .switch_stmt = .{ .switch_tok = node_tok, - .cond = @enumFromInt(node_data[0]), - .body = @enumFromInt(node_data[1]), + .cond = @fromBackingInt(@intCast(node_data[0])), + .body = @fromBackingInt(@intCast(node_data[1])), }, }, .case_stmt => .{ .case_stmt = .{ .case_tok = node_tok, - .start = @enumFromInt(node_data[0]), + .start = @fromBackingInt(@intCast(node_data[0])), .end = unpackOptIndex(node_data[1]), - .body = @enumFromInt(node_data[2]), + .body = @fromBackingInt(@intCast(node_data[2])), }, }, .default_stmt => .{ .default_stmt = .{ .default_tok = node_tok, - .body = @enumFromInt(node_data[0]), + .body = @fromBackingInt(@intCast(node_data[0])), }, }, .while_stmt => .{ .while_stmt = .{ .while_tok = node_tok, - .cond = @enumFromInt(node_data[0]), - .body = @enumFromInt(node_data[1]), + .cond = @fromBackingInt(@intCast(node_data[0])), + .body = @fromBackingInt(@intCast(node_data[1])), }, }, .do_while_stmt => .{ .do_while_stmt = .{ .do_tok = node_tok, - .cond = @enumFromInt(node_data[0]), - .body = @enumFromInt(node_data[1]), + .cond = @fromBackingInt(@intCast(node_data[0])), + .body = @fromBackingInt(@intCast(node_data[1])), }, }, .for_decl => .{ @@ -986,7 +986,7 @@ pub const Node = union(enum) { .init = .{ .decls = @ptrCast(tree.extra.items[node_data[0]..][0 .. node_data[1] - 2]) }, .cond = unpackOptIndex(tree.extra.items[node_data[0] + node_data[1] - 2]), .incr = unpackOptIndex(tree.extra.items[node_data[0] + node_data[1] - 1]), - .body = @enumFromInt(node_data[2]), + .body = @fromBackingInt(@intCast(node_data[2])), }, }, .for_expr => .{ @@ -995,7 +995,7 @@ pub const Node = union(enum) { .init = .{ .expr = unpackOptIndex(node_data[0]) }, .cond = unpackOptIndex(tree.extra.items[node_data[1]]), .incr = unpackOptIndex(tree.extra.items[node_data[1] + 1]), - .body = @enumFromInt(node_data[2]), + .body = @fromBackingInt(@intCast(node_data[2])), }, }, .goto_stmt => .{ @@ -1006,7 +1006,7 @@ pub const Node = union(enum) { .computed_goto_stmt => .{ .computed_goto_stmt = .{ .goto_tok = node_tok, - .expr = @enumFromInt(node_data[0]), + .expr = @fromBackingInt(@intCast(node_data[0])), }, }, .continue_stmt => .{ @@ -1030,7 +1030,7 @@ pub const Node = union(enum) { .return_tok = node_tok, .return_qt = @bitCast(node_data[0]), .operand = .{ - .expr = @enumFromInt(node_data[1]), + .expr = @fromBackingInt(@intCast(node_data[1])), }, }, }, @@ -1082,7 +1082,7 @@ pub const Node = union(enum) { return .{ .asm_stmt = .{ .asm_tok = node_tok, - .asm_str = @enumFromInt(node_data[0]), + .asm_str = @fromBackingInt(@intCast(node_data[0])), .outputs = @ptrCast(outputs), .inputs = @ptrCast(inputs), .clobbers = @ptrCast(clobbers), @@ -1094,7 +1094,7 @@ pub const Node = union(enum) { .asm_stmt_simple => .{ .asm_stmt = .{ .asm_tok = node_tok, - .asm_str = @enumFromInt(node_data[0]), + .asm_str = @fromBackingInt(@intCast(node_data[0])), .outputs = &.{}, .inputs = &.{}, .clobbers = &.{}, @@ -1106,255 +1106,255 @@ pub const Node = union(enum) { .assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .mul_assign_expr => .{ .mul_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .div_assign_expr => .{ .div_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .mod_assign_expr => .{ .mod_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .add_assign_expr => .{ .add_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .sub_assign_expr => .{ .sub_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .shl_assign_expr => .{ .shl_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .shr_assign_expr => .{ .shr_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bit_and_assign_expr => .{ .bit_and_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bit_xor_assign_expr => .{ .bit_xor_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bit_or_assign_expr => .{ .bit_or_assign_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .compound_assign_dummy_expr => .{ .compound_assign_dummy_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .comma_expr => .{ .comma_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bool_or_expr => .{ .bool_or_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bool_and_expr => .{ .bool_and_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bit_or_expr => .{ .bit_or_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bit_xor_expr => .{ .bit_xor_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .bit_and_expr => .{ .bit_and_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .equal_expr => .{ .equal_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .not_equal_expr => .{ .not_equal_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .less_than_expr => .{ .less_than_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .less_than_equal_expr => .{ .less_than_equal_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .greater_than_expr => .{ .greater_than_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .greater_than_equal_expr => .{ .greater_than_equal_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .shl_expr => .{ .shl_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .shr_expr => .{ .shr_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .add_expr => .{ .add_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .sub_expr => .{ .sub_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .mul_expr => .{ .mul_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .div_expr => .{ .div_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .mod_expr => .{ .mod_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(node_data[1]), - .rhs = @enumFromInt(node_data[2]), + .lhs = @fromBackingInt(@intCast(node_data[1])), + .rhs = @fromBackingInt(@intCast(node_data[2])), }, }, .explicit_cast => .{ .cast = .{ .l_paren = node_tok, .qt = @bitCast(node_data[0]), - .kind = @enumFromInt(node_data[1]), - .operand = @enumFromInt(node_data[2]), + .kind = @fromBackingInt(@intCast(node_data[1])), + .operand = @fromBackingInt(@intCast(node_data[2])), .implicit = false, }, }, @@ -1362,8 +1362,8 @@ pub const Node = union(enum) { .cast = .{ .l_paren = node_tok, .qt = @bitCast(node_data[0]), - .kind = @enumFromInt(node_data[1]), - .operand = @enumFromInt(node_data[2]), + .kind = @fromBackingInt(@intCast(node_data[1])), + .operand = @fromBackingInt(@intCast(node_data[2])), .implicit = true, }, }, @@ -1371,105 +1371,105 @@ pub const Node = union(enum) { .addr_of_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .deref_expr => .{ .deref_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .plus_expr => .{ .plus_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .negate_expr => .{ .negate_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .bit_not_expr => .{ .bit_not_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .bool_not_expr => .{ .bool_not_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .pre_inc_expr => .{ .pre_inc_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .pre_dec_expr => .{ .pre_dec_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .imag_expr => .{ .imag_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .real_expr => .{ .real_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .post_inc_expr => .{ .post_inc_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .post_dec_expr => .{ .post_dec_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .paren_expr => .{ .paren_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .stmt_expr => .{ .stmt_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .cond_dummy_expr => .{ .cond_dummy_expr = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .addr_of_label => .{ @@ -1482,15 +1482,15 @@ pub const Node = union(enum) { .array_access_expr = .{ .l_bracket_tok = node_tok, .qt = @bitCast(node_data[0]), - .base = @enumFromInt(node_data[1]), - .index = @enumFromInt(node_data[2]), + .base = @fromBackingInt(@intCast(node_data[1])), + .index = @fromBackingInt(@intCast(node_data[2])), }, }, .call_expr => .{ .call_expr = .{ .l_paren_tok = node_tok, .qt = @bitCast(node_data[0]), - .callee = @enumFromInt(tree.extra.items[node_data[1]]), + .callee = @fromBackingInt(@intCast(tree.extra.items[node_data[1]])), .args = @ptrCast(tree.extra.items[node_data[1] + 1 ..][0 .. node_data[2] - 1]), }, }, @@ -1498,7 +1498,7 @@ pub const Node = union(enum) { .call_expr = .{ .l_paren_tok = node_tok, .qt = @bitCast(node_data[0]), - .callee = @enumFromInt(node_data[1]), + .callee = @fromBackingInt(@intCast(node_data[1])), .args = unPackElems(node_data[2..]), }, }, @@ -1520,7 +1520,7 @@ pub const Node = union(enum) { .member_access_expr = .{ .access_tok = node_tok, .qt = @bitCast(node_data[0]), - .base = @enumFromInt(node_data[1]), + .base = @fromBackingInt(@intCast(node_data[1])), .member_index = node_data[2], }, }, @@ -1528,7 +1528,7 @@ pub const Node = union(enum) { .member_access_ptr_expr = .{ .access_tok = node_tok, .qt = @bitCast(node_data[0]), - .base = @enumFromInt(node_data[1]), + .base = @fromBackingInt(@intCast(node_data[1])), .member_index = node_data[2], }, }, @@ -1536,14 +1536,14 @@ pub const Node = union(enum) { .decl_ref_expr = .{ .name_tok = node_tok, .qt = @bitCast(node_data[0]), - .decl = @enumFromInt(node_data[1]), + .decl = @fromBackingInt(@intCast(node_data[1])), }, }, .enumeration_ref => .{ .enumeration_ref = .{ .name_tok = node_tok, .qt = @bitCast(node_data[0]), - .decl = @enumFromInt(node_data[1]), + .decl = @fromBackingInt(@intCast(node_data[1])), }, }, .builtin_ref => .{ @@ -1574,7 +1574,7 @@ pub const Node = union(enum) { .char_literal = .{ .literal_tok = node_tok, .qt = @bitCast(node_data[0]), - .kind = @enumFromInt(node_data[1]), + .kind = @fromBackingInt(@intCast(node_data[1])), }, }, .float_literal => .{ @@ -1587,14 +1587,14 @@ pub const Node = union(enum) { .string_literal_expr = .{ .literal_tok = node_tok, .qt = @bitCast(node_data[0]), - .kind = @enumFromInt(node_data[1]), + .kind = @fromBackingInt(@intCast(node_data[1])), }, }, .imaginary_literal => .{ .imaginary_literal = .{ .op_tok = node_tok, .qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .sizeof_expr => .{ @@ -1618,8 +1618,8 @@ pub const Node = union(enum) { .generic_expr = .{ .generic_tok = node_tok, .qt = @bitCast(node_data[0]), - .controlling = @enumFromInt(node_data[1]), - .chosen = @enumFromInt(node_data[2]), + .controlling = @fromBackingInt(@intCast(node_data[1])), + .chosen = @fromBackingInt(@intCast(node_data[2])), .rest = &.{}, }, }, @@ -1627,8 +1627,8 @@ pub const Node = union(enum) { .generic_expr = .{ .generic_tok = node_tok, .qt = @bitCast(node_data[0]), - .controlling = @enumFromInt(tree.extra.items[node_data[1]]), - .chosen = @enumFromInt(tree.extra.items[node_data[1] + 1]), + .controlling = @fromBackingInt(@intCast(tree.extra.items[node_data[1]])), + .chosen = @fromBackingInt(@intCast(tree.extra.items[node_data[1] + 1])), .rest = @ptrCast(tree.extra.items[node_data[1] + 2 ..][0 .. node_data[2] - 2]), }, }, @@ -1636,40 +1636,40 @@ pub const Node = union(enum) { .generic_association_expr = .{ .colon_tok = node_tok, .association_qt = @bitCast(node_data[0]), - .expr = @enumFromInt(node_data[1]), + .expr = @fromBackingInt(@intCast(node_data[1])), }, }, .generic_default_expr => .{ .generic_default_expr = .{ .default_tok = node_tok, - .expr = @enumFromInt(node_data[0]), + .expr = @fromBackingInt(@intCast(node_data[0])), }, }, .binary_cond_expr => .{ .binary_cond_expr = .{ .cond_tok = node_tok, .qt = @bitCast(node_data[0]), - .cond = @enumFromInt(node_data[1]), - .then_expr = @enumFromInt(tree.extra.items[node_data[2]]), - .else_expr = @enumFromInt(tree.extra.items[node_data[2] + 1]), + .cond = @fromBackingInt(@intCast(node_data[1])), + .then_expr = @fromBackingInt(@intCast(tree.extra.items[node_data[2]])), + .else_expr = @fromBackingInt(@intCast(tree.extra.items[node_data[2] + 1])), }, }, .cond_expr => .{ .cond_expr = .{ .cond_tok = node_tok, .qt = @bitCast(node_data[0]), - .cond = @enumFromInt(node_data[1]), - .then_expr = @enumFromInt(tree.extra.items[node_data[2]]), - .else_expr = @enumFromInt(tree.extra.items[node_data[2] + 1]), + .cond = @fromBackingInt(@intCast(node_data[1])), + .then_expr = @fromBackingInt(@intCast(tree.extra.items[node_data[2]])), + .else_expr = @fromBackingInt(@intCast(tree.extra.items[node_data[2] + 1])), }, }, .builtin_choose_expr => .{ .builtin_choose_expr = .{ .cond_tok = node_tok, .qt = @bitCast(node_data[0]), - .cond = @enumFromInt(node_data[1]), - .then_expr = @enumFromInt(tree.extra.items[node_data[2]]), - .else_expr = @enumFromInt(tree.extra.items[node_data[2] + 1]), + .cond = @fromBackingInt(@intCast(node_data[1])), + .then_expr = @fromBackingInt(@intCast(tree.extra.items[node_data[2]])), + .else_expr = @fromBackingInt(@intCast(tree.extra.items[node_data[2] + 1])), }, }, .builtin_types_compatible_p => .{ @@ -1683,15 +1683,15 @@ pub const Node = union(enum) { .builtin_convertvector = .{ .builtin_tok = node_tok, .dest_qt = @bitCast(node_data[0]), - .operand = @enumFromInt(node_data[1]), + .operand = @fromBackingInt(@intCast(node_data[1])), }, }, .builtin_shufflevector => .{ .builtin_shufflevector = .{ .builtin_tok = node_tok, .qt = @bitCast(node_data[0]), - .lhs = @enumFromInt(tree.extra.items[node_data[1]]), - .rhs = @enumFromInt(tree.extra.items[node_data[1] + 1]), + .lhs = @fromBackingInt(@intCast(tree.extra.items[node_data[1]])), + .rhs = @fromBackingInt(@intCast(tree.extra.items[node_data[1] + 1])), .indexes = @ptrCast(tree.extra.items[node_data[1] + 2 ..][0..node_data[2]]), }, }, @@ -1767,7 +1767,7 @@ pub const Node = union(enum) { else .auto, .thread_local = attr.thread_local, - .initializer = @enumFromInt(node_data[2]), + .initializer = @fromBackingInt(@intCast(node_data[2])), }, }; }, @@ -1775,7 +1775,7 @@ pub const Node = union(enum) { } pub fn tok(index: Index, tree: *const Tree) TokenIndex { - return tree.nodes.items(.tok)[@intFromEnum(index)]; + return tree.nodes.items(.tok)[@backingInt(index)]; } pub fn loc(index: Index, tree: *const Tree) Source.Location { @@ -1788,7 +1788,7 @@ pub const Node = union(enum) { } pub fn qtOrNull(index: Index, tree: *const Tree) ?QualType { - return switch (tree.nodes.items(.tag)[@intFromEnum(index)]) { + return switch (tree.nodes.items(.tag)[@backingInt(index)]) { .empty_decl, .static_assert, .compound_stmt, @@ -1819,7 +1819,7 @@ pub const Node = union(enum) { .builtin_types_compatible_p => .int, else => { // If a node is typed the type is stored in data[0]. - return @bitCast(tree.nodes.items(.data)[@intFromEnum(index)][0]); + return @bitCast(tree.nodes.items(.data)[@backingInt(index)][0]); }, }; } @@ -1830,15 +1830,15 @@ pub const Node = union(enum) { _, pub fn unpack(opt: OptIndex) ?Index { - return if (opt == .null) null else @enumFromInt(@intFromEnum(opt)); + return if (opt == .null) null else @fromBackingInt(@intCast(@backingInt(opt))); } pub fn pack(index: Index) OptIndex { - return @enumFromInt(@intFromEnum(index)); + return @fromBackingInt(@intCast(@backingInt(index))); } pub fn packOpt(optional: ?Index) OptIndex { - return if (optional) |some| @enumFromInt(@intFromEnum(some)) else .null; + return if (optional) |some| @fromBackingInt(@intCast(@backingInt(some))) else .null; } }; @@ -2013,7 +2013,7 @@ pub const Node = union(enum) { pub fn addNode(tree: *Tree, node: Node) !Node.Index { const index = try tree.nodes.addOne(tree.comp.gpa); try tree.setNode(node, index); - return @enumFromInt(index); + return @fromBackingInt(@intCast(index)); } pub fn setNode(tree: *Tree, node: Node, index: usize) !void { @@ -2025,7 +2025,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { }, .static_assert => |assert| { repr.tag = .static_assert; - repr.data[0] = @intFromEnum(assert.cond); + repr.data[0] = @backingInt(assert.cond); repr.data[1] = packOptIndex(assert.message); repr.tok = assert.assert_tok; }, @@ -2037,7 +2037,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .@"inline" = function.@"inline", }); if (function.body) |some| { - repr.data[2] = @intFromEnum(some); + repr.data[2] = @backingInt(some); } else { repr.data[2] = packOptIndex(function.definition); } @@ -2062,7 +2062,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .register = variable.storage_class == .register, }); if (variable.initializer) |some| { - repr.data[2] = @intFromEnum(some); + repr.data[2] = @backingInt(some); } else { repr.data[2] = packOptIndex(variable.definition); } @@ -2076,7 +2076,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { }, .global_asm => |global_asm| { repr.tag = .global_asm; - repr.data[0] = @intFromEnum(global_asm.asm_str); + repr.data[0] = @backingInt(global_asm.asm_str); repr.tok = global_asm.asm_tok; }, .struct_decl => |decl| { @@ -2151,7 +2151,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .labeled_stmt => |labeled| { repr.tag = .labeled_stmt; repr.data[0] = @bitCast(labeled.qt); - repr.data[1] = @intFromEnum(labeled.body); + repr.data[1] = @backingInt(labeled.body); repr.tok = labeled.label_tok; }, .compound_stmt => |compound| { @@ -2167,39 +2167,39 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { }, .if_stmt => |@"if"| { repr.tag = .if_stmt; - repr.data[0] = @intFromEnum(@"if".cond); - repr.data[1] = @intFromEnum(@"if".then_body); + repr.data[0] = @backingInt(@"if".cond); + repr.data[1] = @backingInt(@"if".then_body); repr.data[2] = packOptIndex(@"if".else_body); repr.tok = @"if".if_tok; }, .switch_stmt => |@"switch"| { repr.tag = .switch_stmt; - repr.data[0] = @intFromEnum(@"switch".cond); - repr.data[1] = @intFromEnum(@"switch".body); + repr.data[0] = @backingInt(@"switch".cond); + repr.data[1] = @backingInt(@"switch".body); repr.tok = @"switch".switch_tok; }, .case_stmt => |case| { repr.tag = .case_stmt; - repr.data[0] = @intFromEnum(case.start); + repr.data[0] = @backingInt(case.start); repr.data[1] = packOptIndex(case.end); repr.data[2] = packOptIndex(case.body); repr.tok = case.case_tok; }, .default_stmt => |default| { repr.tag = .default_stmt; - repr.data[0] = @intFromEnum(default.body); + repr.data[0] = @backingInt(default.body); repr.tok = default.default_tok; }, .while_stmt => |@"while"| { repr.tag = .while_stmt; - repr.data[0] = @intFromEnum(@"while".cond); - repr.data[1] = @intFromEnum(@"while".body); + repr.data[0] = @backingInt(@"while".cond); + repr.data[1] = @backingInt(@"while".body); repr.tok = @"while".while_tok; }, .do_while_stmt => |do_while| { repr.tag = .do_while_stmt; - repr.data[0] = @intFromEnum(do_while.cond); - repr.data[1] = @intFromEnum(do_while.body); + repr.data[0] = @backingInt(do_while.cond); + repr.data[1] = @backingInt(do_while.body); repr.tok = do_while.do_tok; }, .for_stmt => |@"for"| { @@ -2223,7 +2223,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { tree.extra.appendAssumeCapacity(packOptIndex(@"for".incr)); }, } - repr.data[2] = @intFromEnum(@"for".body); + repr.data[2] = @backingInt(@"for".body); repr.tok = @"for".for_tok; }, .goto_stmt => |goto| { @@ -2232,7 +2232,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { }, .computed_goto_stmt => |computed_goto| { repr.tag = .computed_goto_stmt; - repr.data[0] = @intFromEnum(computed_goto.expr); + repr.data[0] = @backingInt(computed_goto.expr); repr.tok = computed_goto.goto_tok; }, .continue_stmt => |@"continue"| { @@ -2253,7 +2253,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { switch (@"return".operand) { .expr => |expr| { repr.tag = .return_stmt; - repr.data[1] = @intFromEnum(expr); + repr.data[1] = @backingInt(expr); }, .none => { repr.tag = .return_none_stmt; @@ -2267,7 +2267,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { }, .asm_stmt => |asm_stmt| { repr.tok = asm_stmt.asm_tok; - repr.data[0] = @intFromEnum(asm_stmt.asm_str); + repr.data[0] = @backingInt(asm_stmt.asm_str); if (asm_stmt.outputs.len == 0 and asm_stmt.inputs.len == 0 and asm_stmt.clobbers.len == 0 and asm_stmt.labels.len == 0) { repr.tag = .asm_stmt_simple; repr.data[1] = @bitCast(asm_stmt.quals); @@ -2302,314 +2302,314 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .assign_expr => |bin| { repr.tag = .assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .mul_assign_expr => |bin| { repr.tag = .mul_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .div_assign_expr => |bin| { repr.tag = .div_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .mod_assign_expr => |bin| { repr.tag = .mod_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .add_assign_expr => |bin| { repr.tag = .add_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .sub_assign_expr => |bin| { repr.tag = .sub_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .shl_assign_expr => |bin| { repr.tag = .shl_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .shr_assign_expr => |bin| { repr.tag = .shr_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bit_and_assign_expr => |bin| { repr.tag = .bit_and_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bit_xor_assign_expr => |bin| { repr.tag = .bit_xor_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bit_or_assign_expr => |bin| { repr.tag = .bit_or_assign_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .compound_assign_dummy_expr => |un| { repr.tag = .compound_assign_dummy_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .comma_expr => |bin| { repr.tag = .comma_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bool_or_expr => |bin| { repr.tag = .bool_or_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bool_and_expr => |bin| { repr.tag = .bool_and_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bit_or_expr => |bin| { repr.tag = .bit_or_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bit_xor_expr => |bin| { repr.tag = .bit_xor_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .bit_and_expr => |bin| { repr.tag = .bit_and_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .equal_expr => |bin| { repr.tag = .equal_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .not_equal_expr => |bin| { repr.tag = .not_equal_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .less_than_expr => |bin| { repr.tag = .less_than_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .less_than_equal_expr => |bin| { repr.tag = .less_than_equal_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .greater_than_expr => |bin| { repr.tag = .greater_than_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .greater_than_equal_expr => |bin| { repr.tag = .greater_than_equal_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .shl_expr => |bin| { repr.tag = .shl_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .shr_expr => |bin| { repr.tag = .shr_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .add_expr => |bin| { repr.tag = .add_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .sub_expr => |bin| { repr.tag = .sub_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .mul_expr => |bin| { repr.tag = .mul_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .div_expr => |bin| { repr.tag = .div_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .mod_expr => |bin| { repr.tag = .mod_expr; repr.data[0] = @bitCast(bin.qt); - repr.data[1] = @intFromEnum(bin.lhs); - repr.data[2] = @intFromEnum(bin.rhs); + repr.data[1] = @backingInt(bin.lhs); + repr.data[2] = @backingInt(bin.rhs); repr.tok = bin.op_tok; }, .cast => |cast| { repr.tag = if (cast.implicit) .implicit_cast else .explicit_cast; repr.data[0] = @bitCast(cast.qt); - repr.data[1] = @intFromEnum(cast.kind); - repr.data[2] = @intFromEnum(cast.operand); + repr.data[1] = @backingInt(cast.kind); + repr.data[2] = @backingInt(cast.operand); repr.tok = cast.l_paren; }, .addr_of_expr => |un| { repr.tag = .addr_of_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .deref_expr => |un| { repr.tag = .deref_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .plus_expr => |un| { repr.tag = .plus_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .negate_expr => |un| { repr.tag = .negate_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .bit_not_expr => |un| { repr.tag = .bit_not_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .bool_not_expr => |un| { repr.tag = .bool_not_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .pre_inc_expr => |un| { repr.tag = .pre_inc_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .pre_dec_expr => |un| { repr.tag = .pre_dec_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .imag_expr => |un| { repr.tag = .imag_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .real_expr => |un| { repr.tag = .real_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .post_inc_expr => |un| { repr.tag = .post_inc_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .post_dec_expr => |un| { repr.tag = .post_dec_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .paren_expr => |un| { repr.tag = .paren_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .stmt_expr => |un| { repr.tag = .stmt_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .cond_dummy_expr => |un| { repr.tag = .cond_dummy_expr; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .addr_of_label => |addr_of| { @@ -2620,8 +2620,8 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .array_access_expr => |access| { repr.tag = .array_access_expr; repr.data[0] = @bitCast(access.qt); - repr.data[1] = @intFromEnum(access.base); - repr.data[2] = @intFromEnum(access.index); + repr.data[1] = @backingInt(access.base); + repr.data[2] = @backingInt(access.index); repr.tok = access.l_bracket_tok; }, .call_expr => |call| { @@ -2632,11 +2632,11 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { const len: u32 = @intCast(call.args.len + 1); repr.data[2] = len; try tree.extra.ensureUnusedCapacity(tree.comp.gpa, len); - tree.extra.appendAssumeCapacity(@intFromEnum(call.callee)); + tree.extra.appendAssumeCapacity(@backingInt(call.callee)); tree.extra.appendSliceAssumeCapacity(@ptrCast(call.args)); } else { repr.tag = .call_expr_one; - repr.data[1] = @intFromEnum(call.callee); + repr.data[1] = @backingInt(call.callee); repr.data[2] = packElem(call.args, 0); } repr.tok = call.l_paren_tok; @@ -2656,27 +2656,27 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .member_access_expr => |access| { repr.tag = .member_access_expr; repr.data[0] = @bitCast(access.qt); - repr.data[1] = @intFromEnum(access.base); + repr.data[1] = @backingInt(access.base); repr.data[2] = access.member_index; repr.tok = access.access_tok; }, .member_access_ptr_expr => |access| { repr.tag = .member_access_ptr_expr; repr.data[0] = @bitCast(access.qt); - repr.data[1] = @intFromEnum(access.base); + repr.data[1] = @backingInt(access.base); repr.data[2] = access.member_index; repr.tok = access.access_tok; }, .decl_ref_expr => |decl_ref| { repr.tag = .decl_ref_expr; repr.data[0] = @bitCast(decl_ref.qt); - repr.data[1] = @intFromEnum(decl_ref.decl); + repr.data[1] = @backingInt(decl_ref.decl); repr.tok = decl_ref.name_tok; }, .enumeration_ref => |enumeration_ref| { repr.tag = .enumeration_ref; repr.data[0] = @bitCast(enumeration_ref.qt); - repr.data[1] = @intFromEnum(enumeration_ref.decl); + repr.data[1] = @backingInt(enumeration_ref.decl); repr.tok = enumeration_ref.name_tok; }, .builtin_ref => |builtin_ref| { @@ -2702,7 +2702,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .char_literal => |literal| { repr.tag = .char_literal; repr.data[0] = @bitCast(literal.qt); - repr.data[1] = @intFromEnum(literal.kind); + repr.data[1] = @backingInt(literal.kind); repr.tok = literal.literal_tok; }, .float_literal => |literal| { @@ -2713,13 +2713,13 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .string_literal_expr => |literal| { repr.tag = .string_literal_expr; repr.data[0] = @bitCast(literal.qt); - repr.data[1] = @intFromEnum(literal.kind); + repr.data[1] = @backingInt(literal.kind); repr.tok = literal.literal_tok; }, .imaginary_literal => |un| { repr.tag = .imaginary_literal; repr.data[0] = @bitCast(un.qt); - repr.data[1] = @intFromEnum(un.operand); + repr.data[1] = @backingInt(un.operand); repr.tok = un.op_tok; }, .sizeof_expr => |type_info| { @@ -2744,45 +2744,45 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { const len: u32 = @intCast(generic.rest.len + 2); repr.data[2] = len; try tree.extra.ensureUnusedCapacity(tree.comp.gpa, len); - tree.extra.appendAssumeCapacity(@intFromEnum(generic.controlling)); - tree.extra.appendAssumeCapacity(@intFromEnum(generic.chosen)); + tree.extra.appendAssumeCapacity(@backingInt(generic.controlling)); + tree.extra.appendAssumeCapacity(@backingInt(generic.chosen)); tree.extra.appendSliceAssumeCapacity(@ptrCast(generic.rest)); } else { repr.tag = .generic_expr_zero; - repr.data[1] = @intFromEnum(generic.controlling); - repr.data[2] = @intFromEnum(generic.chosen); + repr.data[1] = @backingInt(generic.controlling); + repr.data[2] = @backingInt(generic.chosen); } repr.tok = generic.generic_tok; }, .generic_association_expr => |association| { repr.tag = .generic_association_expr; repr.data[0] = @bitCast(association.association_qt); - repr.data[1] = @intFromEnum(association.expr); + repr.data[1] = @backingInt(association.expr); repr.tok = association.colon_tok; }, .generic_default_expr => |default| { repr.tag = .generic_default_expr; - repr.data[0] = @intFromEnum(default.expr); + repr.data[0] = @backingInt(default.expr); repr.tok = default.default_tok; }, .binary_cond_expr => |cond| { repr.tag = .binary_cond_expr; repr.data[0] = @bitCast(cond.qt); - repr.data[1] = @intFromEnum(cond.cond); + repr.data[1] = @backingInt(cond.cond); repr.data[2], _ = try tree.addExtra(&.{ cond.then_expr, cond.else_expr }); repr.tok = cond.cond_tok; }, .cond_expr => |cond| { repr.tag = .cond_expr; repr.data[0] = @bitCast(cond.qt); - repr.data[1] = @intFromEnum(cond.cond); + repr.data[1] = @backingInt(cond.cond); repr.data[2], _ = try tree.addExtra(&.{ cond.then_expr, cond.else_expr }); repr.tok = cond.cond_tok; }, .builtin_choose_expr => |cond| { repr.tag = .builtin_choose_expr; repr.data[0] = @bitCast(cond.qt); - repr.data[1] = @intFromEnum(cond.cond); + repr.data[1] = @backingInt(cond.cond); repr.data[2], _ = try tree.addExtra(&.{ cond.then_expr, cond.else_expr }); repr.tok = cond.cond_tok; }, @@ -2795,7 +2795,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .builtin_convertvector => |builtin| { repr.tag = .builtin_convertvector; repr.data[0] = @bitCast(builtin.dest_qt); - repr.data[1] = @intFromEnum(builtin.operand); + repr.data[1] = @backingInt(builtin.operand); repr.tok = builtin.builtin_tok; }, .builtin_shufflevector => |builtin| { @@ -2805,8 +2805,8 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { repr.data[2] = @intCast(builtin.indexes.len); repr.tok = builtin.builtin_tok; try tree.extra.ensureUnusedCapacity(tree.comp.gpa, builtin.indexes.len + 2); - tree.extra.appendAssumeCapacity(@intFromEnum(builtin.lhs)); - tree.extra.appendAssumeCapacity(@intFromEnum(builtin.rhs)); + tree.extra.appendAssumeCapacity(@backingInt(builtin.lhs)); + tree.extra.appendAssumeCapacity(@backingInt(builtin.rhs)); tree.extra.appendSliceAssumeCapacity(@ptrCast(builtin.indexes)); }, .builtin_va_arg_pack => |builtin| { @@ -2867,7 +2867,7 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { .register = literal.storage_class == .register, .thread_local = literal.thread_local, }); - repr.data[2] = @intFromEnum(literal.initializer); + repr.data[2] = @backingInt(literal.initializer); repr.tok = literal.l_paren_tok; }, } @@ -2875,19 +2875,19 @@ pub fn setNode(tree: *Tree, node: Node, index: usize) !void { } fn packOptIndex(opt: ?Node.Index) u32 { - return @intFromEnum(Node.OptIndex.packOpt(opt)); + return @backingInt(Node.OptIndex.packOpt(opt)); } fn unpackOptIndex(idx: u32) ?Node.Index { - return @as(Node.OptIndex, @enumFromInt(idx)).unpack(); + return @as(Node.OptIndex, @fromBackingInt(@intCast(idx))).unpack(); } fn packElem(nodes: []const Node.Index, index: usize) u32 { - return if (nodes.len > index) @intFromEnum(nodes[index]) else @intFromEnum(Node.OptIndex.null); + return if (nodes.len > index) @backingInt(nodes[index]) else @backingInt(Node.OptIndex.null); } fn unPackElems(data: []const u32) []const Node.Index { - const sentinel = @intFromEnum(Node.OptIndex.null); + const sentinel = @backingInt(Node.OptIndex.null); for (data, 0..) |item, i| { if (item == sentinel) return @ptrCast(data[0..i]); } @@ -3146,7 +3146,7 @@ fn dumpNode( _ = try ptr.offset.print(tree.comp.type_store.ptrdiff, tree.comp, w); }, else => { - const ptr_node: Node.Index = @enumFromInt(ptr.node); + const ptr_node: Node.Index = @fromBackingInt(@intCast(ptr.node)); const decl_name = tree.tokSlice(ptr_node.tok(tree)); try ptr.offset.printPointer(decl_name, tree.comp, w); }, @@ -3212,7 +3212,7 @@ fn dumpNode( try w.splatByteAll(' ', level + half); try w.writeAll("definition: "); try term.setColor(NAME); - try w.print("0x{X}\n", .{@intFromEnum(definition)}); + try w.print("0x{X}\n", .{@backingInt(definition)}); try term.setColor(.reset); } }, @@ -3268,7 +3268,7 @@ fn dumpNode( try w.splatByteAll(' ', level + half); try w.writeAll("definition: "); try term.setColor(NAME); - try w.print("0x{X}\n", .{@intFromEnum(definition)}); + try w.print("0x{X}\n", .{@backingInt(definition)}); try term.setColor(.reset); } }, diff --git a/lib/compiler/aro/aro/TypeStore.zig b/lib/compiler/aro/aro/TypeStore.zig index 70b48ba4a82c0fd03f41d73b4aa13027559c9581..4cc30508cc4f06c0979a565bc97f46087a381b77 100644 --- a/lib/compiler/aro/aro/TypeStore.zig +++ b/lib/compiler/aro/aro/TypeStore.zig @@ -226,13 +226,13 @@ pub const QualType = packed struct(u32) { else => {}, } - const repr = comp.type_store.types.get(@intFromEnum(qt._index)); + const repr = comp.type_store.types.get(@backingInt(qt._index)); return switch (repr.tag) { .complex => .{ .complex = @bitCast(repr.data[0]) }, .atomic => .{ .atomic = @bitCast(repr.data[0]) }, .bit_int => .{ .bit_int = .{ .bits = @intCast(repr.data[0]), - .signedness = @enumFromInt(repr.data[1]), + .signedness = @fromBackingInt(@intCast(repr.data[1])), } }, .func_zero => .{ .func = .{ .return_type = @bitCast(repr.data[0]), @@ -280,7 +280,7 @@ pub const QualType = packed struct(u32) { }, .pointer => .{ .pointer = .{ .child = @bitCast(repr.data[0]), - .bounds = @enumFromInt(repr.data[1]), + .bounds = @fromBackingInt(@intCast(repr.data[1])), } }, .pointer_decayed => .{ .pointer = .{ .child = @bitCast(repr.data[0]), @@ -300,7 +300,7 @@ pub const QualType = packed struct(u32) { } }, .array_variable => .{ .array = .{ .elem = @bitCast(repr.data[0]), - .len = .{ .variable = @enumFromInt(repr.data[1]) }, + .len = .{ .variable = @fromBackingInt(@intCast(repr.data[1])) }, } }, .array_unspecified_variable => .{ .array = .{ .elem = @bitCast(repr.data[0]), @@ -322,8 +322,8 @@ pub const QualType = packed struct(u32) { const extra_fields = extra[repr.data[1] + layout_size + 2 ..][0 .. fields_len * field_size]; const record: Type.Record = .{ - .name = @enumFromInt(repr.data[0]), - .decl_node = @enumFromInt(extra[repr.data[1]]), + .name = @fromBackingInt(@intCast(repr.data[0])), + .decl_node = @fromBackingInt(@intCast(extra[repr.data[1]])), .layout = layout, .fields = std.mem.bytesAsSlice(Type.Record.Field, std.mem.sliceAsBytes(extra_fields)), }; @@ -334,14 +334,14 @@ pub const QualType = packed struct(u32) { }; }, .struct_incomplete => .{ .@"struct" = .{ - .name = @enumFromInt(repr.data[0]), - .decl_node = @enumFromInt(repr.data[1]), + .name = @fromBackingInt(@intCast(repr.data[0])), + .decl_node = @fromBackingInt(@intCast(repr.data[1])), .layout = null, .fields = &.{}, } }, .union_incomplete => .{ .@"union" = .{ - .name = @enumFromInt(repr.data[0]), - .decl_node = @enumFromInt(repr.data[1]), + .name = @fromBackingInt(@intCast(repr.data[0])), + .decl_node = @fromBackingInt(@intCast(repr.data[1])), .layout = null, .fields = &.{}, } }, @@ -354,8 +354,8 @@ pub const QualType = packed struct(u32) { const extra_fields = extra[repr.data[1] + 3 ..][0 .. fields_len * field_size]; return .{ .@"enum" = .{ - .name = @enumFromInt(extra[repr.data[1]]), - .decl_node = @enumFromInt(extra[repr.data[1] + 1]), + .name = @fromBackingInt(@intCast(extra[repr.data[1]])), + .decl_node = @fromBackingInt(@intCast(extra[repr.data[1] + 1])), .tag = @bitCast(repr.data[0]), .incomplete = false, .fixed = repr.tag == .enum_fixed, @@ -365,8 +365,8 @@ pub const QualType = packed struct(u32) { .enum_incomplete => .{ .@"enum" = .{ .tag = null, - .name = @enumFromInt(repr.data[0]), - .decl_node = @enumFromInt(repr.data[1]), + .name = @fromBackingInt(@intCast(repr.data[0])), + .decl_node = @fromBackingInt(@intCast(repr.data[1])), .incomplete = true, .fixed = false, .fields = &.{}, @@ -375,8 +375,8 @@ pub const QualType = packed struct(u32) { .enum_incomplete_fixed => .{ .@"enum" = .{ .tag = @bitCast(repr.data[0]), - .name = @enumFromInt(comp.type_store.extra.items[repr.data[1]]), - .decl_node = @enumFromInt(comp.type_store.extra.items[repr.data[1] + 1]), + .name = @fromBackingInt(@intCast(comp.type_store.extra.items[repr.data[1]])), + .decl_node = @fromBackingInt(@intCast(comp.type_store.extra.items[repr.data[1] + 1])), .incomplete = true, .fixed = true, .fields = &.{}, @@ -388,12 +388,12 @@ pub const QualType = packed struct(u32) { } }, .typeof_expr => .{ .typeof = .{ .base = @bitCast(repr.data[0]), - .expr = @enumFromInt(repr.data[1]), + .expr = @fromBackingInt(@intCast(repr.data[1])), } }, .typedef => .{ .typedef = .{ .base = @bitCast(repr.data[0]), - .name = @enumFromInt(comp.type_store.extra.items[repr.data[1]]), - .decl_node = @enumFromInt(comp.type_store.extra.items[repr.data[1] + 1]), + .name = @fromBackingInt(@intCast(comp.type_store.extra.items[repr.data[1]])), + .decl_node = @fromBackingInt(@intCast(comp.type_store.extra.items[repr.data[1] + 1])), } }, .attributed => { const extra = comp.type_store.extra.items; @@ -1694,7 +1694,7 @@ pub const Type = union(enum) { pub fn unpack(width: @This()) ?u32 { if (width == .null) return null; - return @intFromEnum(width); + return @backingInt(width); } } = .null, layout: Field.Layout = .{ @@ -1881,7 +1881,7 @@ pub fn putExtra(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type) !Index { } const index = try ts.types.addOne(gpa); try ts.set(gpa, ty, index); - return @enumFromInt(index); + return @fromBackingInt(@intCast(index)); } pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void { @@ -1899,7 +1899,7 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void .bit_int => |bit_int| { repr.tag = .bit_int; repr.data[0] = bit_int.bits; - repr.data[1] = @intFromEnum(bit_int.signedness); + repr.data[1] = @backingInt(bit_int.signedness); }, .atomic => |atomic| { repr.tag = .atomic; @@ -1950,7 +1950,7 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void repr.data[1] = @bitCast(array); } else { repr.tag = .pointer; - repr.data[1] = @intFromEnum(pointer.bounds); + repr.data[1] = @backingInt(pointer.bounds); } }, .array => |array| { @@ -1973,7 +1973,7 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void }, .variable => |expr| { repr.tag = .array_variable; - repr.data[1] = @intFromEnum(expr); + repr.data[1] = @backingInt(expr); }, .unspecified_variable => { repr.tag = .array_unspecified_variable; @@ -1986,7 +1986,7 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void repr.data[1] = vector.len; }, .@"struct", .@"union" => |record| record: { - repr.data[0] = @intFromEnum(record.name); + repr.data[0] = @backingInt(record.name); const layout = record.layout orelse { std.debug.assert(record.fields.len == 0); repr.tag = switch (ty) { @@ -1994,7 +1994,7 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void .@"union" => .union_incomplete, else => unreachable, }; - repr.data[1] = @intFromEnum(record.decl_node); + repr.data[1] = @backingInt(record.decl_node); break :record; }; repr.tag = switch (ty) { @@ -2012,7 +2012,7 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void comptime std.debug.assert(@sizeOf(Type.Record.Field) == @sizeOf(u32) * field_size); try ts.extra.ensureUnusedCapacity(gpa, record.fields.len * field_size + layout_size + 2); - ts.extra.appendAssumeCapacity(@intFromEnum(record.decl_node)); + ts.extra.appendAssumeCapacity(@backingInt(record.decl_node)); const casted_layout: *const [layout_size]u32 = @ptrCast(&layout); ts.extra.appendSliceAssumeCapacity(casted_layout); ts.extra.appendAssumeCapacity(@intCast(record.fields.len)); @@ -2030,13 +2030,13 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void repr.data[0] = @bitCast(@"enum".tag.?); repr.data[1] = @intCast(ts.extra.items.len); try ts.extra.appendSlice(gpa, &.{ - @intFromEnum(@"enum".name), - @intFromEnum(@"enum".decl_node), + @backingInt(@"enum".name), + @backingInt(@"enum".decl_node), }); } else { repr.tag = .enum_incomplete; - repr.data[0] = @intFromEnum(@"enum".name); - repr.data[1] = @intFromEnum(@"enum".decl_node); + repr.data[0] = @backingInt(@"enum".name); + repr.data[1] = @backingInt(@"enum".decl_node); } break :@"enum"; } @@ -2050,8 +2050,8 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void comptime std.debug.assert(@sizeOf(Type.Enum.Field) == @sizeOf(u32) * field_size); try ts.extra.ensureUnusedCapacity(gpa, @"enum".fields.len * field_size + 3); - ts.extra.appendAssumeCapacity(@intFromEnum(@"enum".name)); - ts.extra.appendAssumeCapacity(@intFromEnum(@"enum".decl_node)); + ts.extra.appendAssumeCapacity(@backingInt(@"enum".name)); + ts.extra.appendAssumeCapacity(@backingInt(@"enum".decl_node)); ts.extra.appendAssumeCapacity(@intCast(@"enum".fields.len)); for (@"enum".fields) |*field| { @@ -2063,7 +2063,7 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void repr.data[0] = @bitCast(typeof.base); if (typeof.expr) |some| { repr.tag = .typeof_expr; - repr.data[1] = @intFromEnum(some); + repr.data[1] = @backingInt(some); } else { repr.tag = .typeof; } @@ -2073,8 +2073,8 @@ pub fn set(ts: *TypeStore, gpa: std.mem.Allocator, ty: Type, index: usize) !void repr.data[0] = @bitCast(typedef.base); repr.data[1] = @intCast(ts.extra.items.len); try ts.extra.appendSlice(gpa, &.{ - @intFromEnum(typedef.name), - @intFromEnum(typedef.decl_node), + @backingInt(typedef.name), + @backingInt(typedef.decl_node), }); }, .attributed => |attributed| { @@ -2194,7 +2194,7 @@ fn generateNsConstantStringType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); return qt; } @@ -2282,7 +2282,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); return qt; }, @@ -2300,7 +2300,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); return qt; }, @@ -2321,7 +2321,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); break :blk qt; }, @@ -2343,7 +2343,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); break :blk qt; }, @@ -2363,7 +2363,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); break :blk qt; }, @@ -2384,7 +2384,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); break :blk qt; }, @@ -2404,7 +2404,7 @@ fn generateVaListType(ts: *TypeStore, comp: *Compilation) !QualType { }; record.fields = &fields; record.layout = record_layout.compute(&fields, qt, comp, null) catch unreachable; - try ts.set(comp.gpa, .{ .@"struct" = record }, @intFromEnum(qt._index)); + try ts.set(comp.gpa, .{ .@"struct" = record }, @backingInt(qt._index)); return qt; }, diff --git a/lib/compiler/aro/aro/Value.zig b/lib/compiler/aro/aro/Value.zig index cc5d24bb3b4dec6b51e1588ae7abe75bb4a2f192..99ba8d1fb2476cd3e017f263b34ffbc3b2b9b404 100644 --- a/lib/compiler/aro/aro/Value.zig +++ b/lib/compiler/aro/aro/Value.zig @@ -21,7 +21,7 @@ pub const @"null" = Value{ .opt_ref = .null }; pub fn intern(comp: *Compilation, k: Interner.Key) !Value { const r = try comp.interner.put(comp.gpa, k); - return .{ .opt_ref = @enumFromInt(@intFromEnum(r)) }; + return .{ .opt_ref = @fromBackingInt(@intCast(@backingInt(r))) }; } pub fn int(i: anytype, comp: *Compilation) !Value { @@ -39,11 +39,11 @@ pub fn pointer(r: Interner.Key.Pointer, comp: *Compilation) !Value { pub fn ref(v: Value) Interner.Ref { std.debug.assert(v.opt_ref != .none); - return @enumFromInt(@intFromEnum(v.opt_ref)); + return @fromBackingInt(@intCast(@backingInt(v.opt_ref))); } pub fn fromRef(r: Interner.Ref) Value { - return .{ .opt_ref = @enumFromInt(@intFromEnum(r)) }; + return .{ .opt_ref = @fromBackingInt(@intCast(@backingInt(r))) }; } pub fn is(v: Value, tag: std.meta.Tag(Interner.Key), comp: *const Compilation) bool { @@ -1114,8 +1114,8 @@ pub fn print(v: Value, qt: QualType, comp: *const Compilation, w: *std.Io.Writer } pub fn printString(bytes: []const u8, qt: QualType, comp: *const Compilation, w: *std.Io.Writer) std.Io.Writer.Error!void { - const size: Compilation.CharUnitSize = @enumFromInt(qt.childType(comp).sizeof(comp)); - const without_null = bytes[0 .. bytes.len - @intFromEnum(size)]; + const size: Compilation.CharUnitSize = @fromBackingInt(@intCast(qt.childType(comp).sizeof(comp))); + const without_null = bytes[0 .. bytes.len - @backingInt(size)]; try w.writeByte('"'); switch (size) { .@"1" => try std.zig.stringEscape(without_null, w), diff --git a/lib/compiler/aro/aro/text_literal.zig b/lib/compiler/aro/aro/text_literal.zig index 5d186167b1966a7db222fac069bd8b63effe5fe9..5ebc75a4cd3c75be038aeb72587ad990f2571b11 100644 --- a/lib/compiler/aro/aro/text_literal.zig +++ b/lib/compiler/aro/aro/text_literal.zig @@ -508,7 +508,7 @@ pub const Parser = struct { }, }; for (slice) |c| { - const char = std.fmt.charToDigit(c, @intFromEnum(base)) catch break; + const char = std.fmt.charToDigit(c, @backingInt(base)) catch break; val, const overflow = @shlWithOverflow(val, base.log2()); if (overflow != 0) overflowed = true; val += char; diff --git a/lib/compiler/aro/assembly_backend/x86_64.zig b/lib/compiler/aro/assembly_backend/x86_64.zig index ffde03865efbbc37992691f056c40f5d40ded4ed..0ac68e25267229e2c38231271de950a55a1c12fd 100644 --- a/lib/compiler/aro/assembly_backend/x86_64.zig +++ b/lib/compiler/aro/assembly_backend/x86_64.zig @@ -166,7 +166,7 @@ fn genDecls(c: *AsmCodeGen) !void { if (c.tree.comp.code_gen_options.debug != .strip) { const sources = c.tree.comp.sources.values(); for (sources) |source| { - try c.data.print(" .file {d} \"{s}\"\n", .{ @intFromEnum(source.id.index) + 1, source.path }); + try c.data.print(" .file {d} \"{s}\"\n", .{ @backingInt(source.id.index) + 1, source.path }); } } diff --git a/lib/compiler/aro/backend/Interner.zig b/lib/compiler/aro/backend/Interner.zig index 6a7fe6fd0772d478ac9ff0d30cbeb7064819cee8..a040f25bb14c44dad5230fba394187a2901442bd 100644 --- a/lib/compiler/aro/backend/Interner.zig +++ b/lib/compiler/aro/backend/Interner.zig @@ -22,7 +22,7 @@ const KeyAdapter = struct { pub fn eql(adapter: KeyAdapter, a: Key, b_void: void, b_map_index: usize) bool { _ = b_void; - return adapter.interner.get(@as(Ref, @enumFromInt(b_map_index))).eql(a); + return adapter.interner.get(@as(Ref, @fromBackingInt(@intCast(b_map_index)))).eql(a); } pub fn hash(adapter: KeyAdapter, a: Key) u32 { @@ -582,7 +582,7 @@ pub fn put(i: *Interner, gpa: Allocator, key: Key) !Ref { if (key.toRef()) |some| return some; const adapter: KeyAdapter = .{ .interner = i }; const gop = try i.map.getOrPutAdapted(gpa, key, adapter); - if (gop.found_existing) return @enumFromInt(gop.index); + if (gop.found_existing) return @fromBackingInt(@intCast(gop.index)); try i.items.ensureUnusedCapacity(gpa, 1); switch (key) { @@ -751,7 +751,7 @@ pub fn put(i: *Interner, gpa: Allocator, key: Key) !Ref { => unreachable, } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn addExtra(i: *Interner, gpa: Allocator, extra: anytype) Allocator.Error!u32 { @@ -765,7 +765,7 @@ fn addExtraAssumeCapacity(i: *Interner, extra: anytype) u32 { const info = @typeInfo(@TypeOf(extra)).@"struct"; inline for (info.field_names, info.field_types) |field_name, field_type| { i.extra.appendAssumeCapacity(switch (field_type) { - Ref => @intFromEnum(@field(extra, field_name)), + Ref => @backingInt(@field(extra, field_name)), u32 => @field(extra, field_name), else => @compileError("bad field type: " ++ @typeName(field_type)), }); @@ -800,7 +800,7 @@ pub fn get(i: *const Interner, ref: Ref) Key { else => {}, } - const item = i.items.get(@intFromEnum(ref)); + const item = i.items.get(@backingInt(ref)); const data = item.data; return switch (item.tag) { .int_ty => .{ .int_ty = @intCast(data) }, @@ -896,7 +896,7 @@ fn extraDataTrail(i: *const Interner, comptime T: type, index: usize) struct { d inline for (info.field_names, info.field_types, 0..) |field_name, field_type, field_i| { const int32 = i.extra.items[field_i + index]; @field(result, field_name) = switch (field_type) { - Ref => @enumFromInt(int32), + Ref => @fromBackingInt(@intCast(int32)), u32 => int32, else => @compileError("bad field type: " ++ @typeName(field_type)), }; diff --git a/lib/compiler/aro/backend/Ir.zig b/lib/compiler/aro/backend/Ir.zig index f35eca40f7af811593b8a4161ad8d575f44609ce..8ab5ab488616b910c885e06e924e557532cd3a26 100644 --- a/lib/compiler/aro/backend/Ir.zig +++ b/lib/compiler/aro/backend/Ir.zig @@ -81,7 +81,7 @@ pub const Builder = struct { } pub fn addArg(b: *Builder, ty: Interner.Ref) Allocator.Error!Ref { - const ref: Ref = @enumFromInt(b.instructions.len); + const ref: Ref = @fromBackingInt(@intCast(b.instructions.len)); try b.instructions.append(b.gpa, .{ .tag = .arg, .data = .{ .none = {} }, .ty = ty }); try b.body.insert(b.gpa, b.arg_count, ref); b.arg_count += 1; @@ -89,7 +89,7 @@ pub const Builder = struct { } pub fn addAlloc(b: *Builder, size: u32, @"align": u32) Allocator.Error!Ref { - const ref: Ref = @enumFromInt(b.instructions.len); + const ref: Ref = @fromBackingInt(@intCast(b.instructions.len)); try b.instructions.append(b.gpa, .{ .tag = .alloc, .data = .{ .alloc = .{ .size = size, .@"align" = @"align" } }, @@ -101,14 +101,14 @@ pub const Builder = struct { } pub fn addInst(b: *Builder, tag: Ir.Inst.Tag, data: Ir.Inst.Data, ty: Interner.Ref) Allocator.Error!Ref { - const ref: Ref = @enumFromInt(b.instructions.len); + const ref: Ref = @fromBackingInt(@intCast(b.instructions.len)); try b.instructions.append(b.gpa, .{ .tag = tag, .data = data, .ty = ty }); try b.body.append(b.gpa, ref); return ref; } pub fn makeLabel(b: *Builder, name: [*:0]const u8) Allocator.Error!Ref { - const ref: Ref = @enumFromInt(b.instructions.len); + const ref: Ref = @fromBackingInt(@intCast(b.instructions.len)); try b.instructions.append(b.gpa, .{ .tag = .label, .data = .{ .label = name }, .ty = .void }); return ref; } @@ -146,7 +146,7 @@ pub const Builder = struct { } pub fn addConstant(b: *Builder, val: Interner.Ref, ty: Interner.Ref) Allocator.Error!Ref { - const ref: Ref = @enumFromInt(b.instructions.len); + const ref: Ref = @fromBackingInt(@intCast(b.instructions.len)); try b.instructions.append(b.gpa, .{ .tag = .constant, .data = .{ .constant = val }, @@ -158,7 +158,7 @@ pub const Builder = struct { pub fn addPhi(b: *Builder, inputs: []const Inst.Phi.Input, ty: Interner.Ref) Allocator.Error!Ref { const a = b.arena.allocator(); const input_refs = try a.alloc(Ref, inputs.len * 2 + 1); - input_refs[0] = @enumFromInt(inputs.len); + input_refs[0] = @fromBackingInt(@intCast(inputs.len)); @memcpy(input_refs[1..], std.mem.bytesAsSlice(Ref, std.mem.sliceAsBytes(inputs))); return b.addInst(.phi, .{ .phi = .{ .ptr = input_refs.ptr } }, ty); @@ -359,7 +359,7 @@ pub const Inst = struct { }; pub fn inputs(p: Phi) []Input { - const len = @intFromEnum(p.ptr[0]) * 2; + const len = @backingInt(p.ptr[0]) * 2; const slice = (p.ptr + 1)[0..len]; return std.mem.bytesAsSlice(Input, std.mem.sliceAsBytes(slice)); } @@ -403,8 +403,8 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, defer label_map.deinit(gpa); const ret_inst = decl.body.items[decl.body.items.len - 1]; - const ret_operand = data[@intFromEnum(ret_inst)].un; - const ret_ty = decl.instructions.items(.ty)[@intFromEnum(ret_operand)]; + const ret_operand = data[@backingInt(ret_inst)].un; + const ret_ty = decl.instructions.items(.ty)[@backingInt(ret_operand)]; try ir.writeType(ret_ty, term); try term.setColor(REF); try w.print(" @{s}", .{name}); @@ -414,7 +414,7 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, var arg_count: u32 = 0; while (true) : (arg_count += 1) { const ref = decl.body.items[arg_count]; - if (tags[@intFromEnum(ref)] != .arg) break; + if (tags[@backingInt(ref)] != .arg) break; if (arg_count != 0) try w.writeAll(", "); try ref_map.put(gpa, ref, {}); try ir.writeRef(decl, &ref_map, ref, term); @@ -422,14 +422,14 @@ fn dumpDecl(ir: *const Ir, decl: *const Decl, gpa: Allocator, name: []const u8, } try w.writeAll(") {\n"); for (decl.body.items[arg_count..]) |ref| { - switch (tags[@intFromEnum(ref)]) { + switch (tags[@backingInt(ref)]) { .label => try label_map.put(gpa, ref, {}), else => {}, } } for (decl.body.items[arg_count..]) |ref| { - const i = @intFromEnum(ref); + const i = @backingInt(ref); const tag = tags[i]; switch (tag) { .arg, .constant, .symbol => unreachable, @@ -664,7 +664,7 @@ fn writeValue(ir: Ir, val: Interner.Ref, term: std.Io.Terminal) !void { fn writeRef(ir: Ir, decl: *const Decl, ref_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void { const w = term.writer; assert(ref != .none); - const index = @intFromEnum(ref); + const index = @backingInt(ref); const ty_ref = decl.instructions.items(.ty)[index]; if (decl.instructions.items(.tag)[index] == .constant) { try ir.writeType(ty_ref, term); @@ -698,7 +698,7 @@ fn writeNewRef(ir: Ir, gpa: Allocator, decl: *const Decl, ref_map: *RefMap, ref: fn writeLabel(decl: *const Decl, label_map: *RefMap, ref: Ref, term: std.Io.Terminal) !void { const w = term.writer; assert(ref != .none); - const index = @intFromEnum(ref); + const index = @backingInt(ref); const label = decl.instructions.items(.data)[index].label; try term.setColor(REF); const label_index = label_map.getIndex(ref).?; diff --git a/lib/compiler/objcopy.zig b/lib/compiler/objcopy.zig index 9c3fffc67f07b8e6c918d554747ba6a421ba026d..857299a60e16f410c3eb54ca6be8382c33b99567 100644 --- a/lib/compiler/objcopy.zig +++ b/lib/compiler/objcopy.zig @@ -600,7 +600,7 @@ const HexWriter = struct { const parts = addressParts(self.address); sum +%= parts[0]; sum +%= parts[1]; - sum +%= @intFromEnum(self.payload); + sum +%= @backingInt(self.payload); for (payload_bytes) |byte| { sum +%= byte; } @@ -618,7 +618,7 @@ const HexWriter = struct { const line = try std.fmt.bufPrint(&outbuf, ":{0X:0>2}{1X:0>4}{2X:0>2}{3X}{4X:0>2}" ++ linesep, .{ @as(u8, @intCast(payload_bytes.len)), self.address, - @intFromEnum(self.payload), + @backingInt(self.payload), payload_bytes, self.checksum(), }); diff --git a/lib/compiler/objdump.zig b/lib/compiler/objdump.zig index c3f6f5e8a7a444862b1396427fcf589805725942..3988dfb198c85dd5e9d5e6ffa122f9a52a1c2022 100644 --- a/lib/compiler/objdump.zig +++ b/lib/compiler/objdump.zig @@ -594,7 +594,7 @@ const coff = struct { const member_sig = try r.peek(4); const machine: std.coff.IMAGE.FILE.MACHINE = - @enumFromInt(std.mem.readInt(u16, member_sig[0..2], .little)); + @fromBackingInt(@intCast(std.mem.readInt(u16, member_sig[0..2], .little))); const sig = std.mem.readInt(u16, member_sig[2..4], .little); const is_imp_lib = machine == std.coff.IMAGE.FILE.MACHINE.UNKNOWN and sig == 0xffff; @@ -723,7 +723,7 @@ const coff = struct { if (d.opts.file_headers and d.element(.@"header-name")) try w.writeAll("COFF Optional Header:\n"); - const magic: std.coff.OptionalHeader.Magic = @enumFromInt(try r.peekInt(u16, .little)); + const magic: std.coff.OptionalHeader.Magic = @fromBackingInt(@intCast(try r.peekInt(u16, .little))); const num_directory_entries, const image_base = switch (magic) { inline .PE32, .@"PE32+" => |v| num_data_dirs: { const OptionalHeader = if (v == .PE32) @@ -795,7 +795,7 @@ const coff = struct { if (d.opts.file_headers) try w.print( "{x: >16} {x: >8} {t}\n", - .{ dir.virtual_address, dir.size, @as(DIRECTORY_ENTRY, @enumFromInt(dir_i)) }, + .{ dir.virtual_address, dir.size, @as(DIRECTORY_ENTRY, @fromBackingInt(@intCast(dir_i))) }, ); } if (d.opts.file_headers and d.element(.newlines)) try w.writeByte('\n'); @@ -980,7 +980,7 @@ const coff = struct { .ABSOLUTE => w.writeAll(" ABS"), .DEBUG => w.writeAll("DEBUG"), else => |v| { - const backing = @intFromEnum(v); + const backing = @backingInt(v); const fmt = "{x: >5}"; if (backing >= 0) try w.print(fmt, .{@as(u15, @intCast(backing))}) @@ -1009,7 +1009,7 @@ const coff = struct { .complex_type = .FUNCTION, .base_type = .NULL, } and - @intFromEnum(symbol.section_number) > 0) + @backingInt(symbol.section_number) > 0) { try w.writeAll("TODO function aux symbol"); } else if (symbol.type == std.coff.SymType{ @@ -1064,10 +1064,10 @@ const coff = struct { symbol.value == 0 and switch (symbol.section_number) { .UNDEFINED, .DEBUG, .ABSOLUTE => false, - else => |sn| @intFromEnum(sn) > 0, + else => |sn| @backingInt(sn) > 0, }) { - const section_i: u15 = @intCast(@intFromEnum(symbol.section_number) - 1); + const section_i: u15 = @intCast(@backingInt(symbol.section_number) - 1); try w.writeAll(" Section "); if (section_i >= sections.items.len) { @@ -1160,7 +1160,7 @@ const coff = struct { void => try w.writeAll("(unknown arch)"), else => |RelocationType| try w.print( "{t: <17} ", - .{@as(RelocationType, @enumFromInt(reloc.type))}, + .{@as(RelocationType, @fromBackingInt(@intCast(reloc.type)))}, ), }, } @@ -1263,7 +1263,7 @@ const coff = struct { // All the variable length fields should be contained within this directory. // Read it entirely to avoid needing to seek per-name when iterating. - const dir = image_info.?.data_dirs[@intFromEnum(DIRECTORY_ENTRY.EXPORT)]; + const dir = image_info.?.data_dirs[@backingInt(DIRECTORY_ENTRY.EXPORT)]; const dir_end_rva = dir.virtual_address + dir.size; const dir_loc = fr.logicalPos(); const dir_slice = try r.readAlloc(gpa, dir.size); @@ -1533,8 +1533,8 @@ const coff = struct { data_dirs: []const std.coff.ImageDataDirectory, entry: DIRECTORY_ENTRY, ) !?u16 { - if (@intFromEnum(entry) < data_dirs.len) blk: { - const rva = data_dirs[@intFromEnum(entry)].virtual_address; + if (@backingInt(entry) < data_dirs.len) blk: { + const rva = data_dirs[@backingInt(entry)].virtual_address; if (rva == 0) break :blk; const section_index = sectionContainingRva(rva_index, sections, rva) orelse @@ -1603,7 +1603,7 @@ const coff = struct { .ABSOLUTE => w.writeAll(" ABS"), .DEBUG => w.writeAll("DEBUG"), else => |v| { - const backing = @intFromEnum(v); + const backing = @backingInt(v); const fmt = "{x: >5}"; if (backing >= 0) try w.print(fmt, .{@as(u15, @intCast(backing))}) diff --git a/lib/compiler/reduce.zig b/lib/compiler/reduce.zig index 25616e0640d27f505da59e5564073fc1e8380f0f..04f0c03650031d0083cd84f89fa87bfa7b8aff09 100644 --- a/lib/compiler/reduce.zig +++ b/lib/compiler/reduce.zig @@ -198,7 +198,7 @@ pub fn main(init: std.process.Init) !void { if (zir.hasCompileErrors()) { more_fixups.clearRetainingCapacity(); - const payload_index = zir.extra[@intFromEnum(Zir.ExtraIndex.compile_errors)]; + const payload_index = zir.extra[@backingInt(Zir.ExtraIndex.compile_errors)]; assert(payload_index != 0); const header = zir.extraData(Zir.Inst.CompileErrors, payload_index); var extra_index = header.end; diff --git a/lib/compiler/resinator/bmp.zig b/lib/compiler/resinator/bmp.zig index d4ec0ba886e21426f433a70f5a66b519bcd50b9f..79c9386b4db64bf752b2a8cfe35e1121bb11ed1d 100644 --- a/lib/compiler/resinator/bmp.zig +++ b/lib/compiler/resinator/bmp.zig @@ -124,7 +124,7 @@ pub fn read(reader: *std.Io.Reader, max_size: u64) ReadError!BitmapInfo { bitmap_info.colors_in_palette = try dib_header.numColorsInTable(); bitmap_info.bytes_per_color_palette_element = 4; - bitmap_info.compression = @enumFromInt(dib_header.biCompression); + bitmap_info.compression = @fromBackingInt(@intCast(dib_header.biCompression)); if (bitmap_info.getByteLenBetweenHeadersAndPixels() < bitmap_info.getBitmasksByteLen()) { return error.MissingBitfieldMasks; diff --git a/lib/compiler/resinator/cli.zig b/lib/compiler/resinator/cli.zig index 276b03af412368ac49ba27eeca4d4dff562d5798..f5382cfb260cc2a069b888dc34a80dc3a1ed432e 100644 --- a/lib/compiler/resinator/cli.zig +++ b/lib/compiler/resinator/cli.zig @@ -369,7 +369,7 @@ pub const Options = struct { try writer.print("Default language: {s} (id=0x{x})\n", .{ language_name, language_id }); const code_page = self.default_code_page orelse .windows1252; - try writer.print("Default codepage: {s} (id={})\n", .{ @tagName(code_page), @intFromEnum(code_page) }); + try writer.print("Default codepage: {s} (id={})\n", .{ @tagName(code_page), @backingInt(code_page) }); } }; diff --git a/lib/compiler/resinator/code_pages.zig b/lib/compiler/resinator/code_pages.zig index 7907f6e1737143c383a8ce55cb6dae01e063477d..78a926e402a8770967514c79749fe53fc6cf040c 100644 --- a/lib/compiler/resinator/code_pages.zig +++ b/lib/compiler/resinator/code_pages.zig @@ -191,7 +191,7 @@ pub const CodePage = blk: { pub fn isSupported(code_page: CodePage) bool { inline for (@typeInfo(SupportedCodePage).@"enum".field_names) |field_name| { - if (@intFromEnum(code_page) == @intFromEnum(@field(SupportedCodePage, field_name))) { + if (@backingInt(code_page) == @backingInt(@field(SupportedCodePage, field_name))) { return true; } } @@ -213,7 +213,7 @@ pub fn getByIdentifier(identifier: u16) !CodePage { pub fn getByIdentifierEnsureSupported(identifier: u16) !SupportedCodePage { const code_page = try getByIdentifier(identifier); return if (isSupported(code_page)) - @enumFromInt(@intFromEnum(code_page)) + @fromBackingInt(@intCast(@backingInt(code_page))) else error.UnsupportedCodePage; } diff --git a/lib/compiler/resinator/compile.zig b/lib/compiler/resinator/compile.zig index fc814576ac5e9e86a7510d8ef2542a60078cebfa..0ac556120885512572c9dde4a8525373849b8c72 100644 --- a/lib/compiler/resinator/compile.zig +++ b/lib/compiler/resinator/compile.zig @@ -606,7 +606,7 @@ pub const Compiler = struct { .GROUP_CURSOR => .ANICURSOR, else => unreachable, }; - header.type_value.ordinal = @intFromEnum(new_predefined_type); + header.type_value.ordinal = @backingInt(new_predefined_type); header.memory_flags = MemoryFlags.defaults(new_predefined_type); header.applyMemoryFlags(node.common_resource_attributes, self.source); header.data_size = std.math.cast(u32, try file_reader.getSize()) orelse { @@ -668,7 +668,7 @@ pub const Compiler = struct { applyToGroupMemoryFlags(&header.memory_flags, node.common_resource_attributes, self.source); const first_icon_id = self.state.icon_id; - const entry_type = if (predefined_type == .GROUP_ICON) @intFromEnum(res.RT.ICON) else @intFromEnum(res.RT.CURSOR); + const entry_type = if (predefined_type == .GROUP_ICON) @backingInt(res.RT.ICON) else @backingInt(res.RT.CURSOR); for (icon_dir.entries, 0..) |*entry, entry_i_usize| { // We know that the entry index must fit within a u16, so // cast it here to simplify usage sites. @@ -1909,7 +1909,7 @@ pub const Compiler = struct { } if (res.ControlClass.fromControl(control_type)) |control_class| { - const ordinal = NameOrOrdinal{ .ordinal = @intFromEnum(control_class) }; + const ordinal = NameOrOrdinal{ .ordinal = @backingInt(control_class) }; try ordinal.write(data_writer); } else { const class_node = control.class.?; @@ -1944,7 +1944,7 @@ pub const Compiler = struct { const parsed = try self.parseQuotedStringAsWideString(literal_node.token); defer self.allocator.free(parsed); if (rc.ControlClass.fromWideString(parsed)) |control_class| { - const ordinal = NameOrOrdinal{ .ordinal = @intFromEnum(control_class) }; + const ordinal = NameOrOrdinal{ .ordinal = @backingInt(control_class) }; try ordinal.write(data_writer); } else { // NUL acts as a terminator @@ -1959,7 +1959,7 @@ pub const Compiler = struct { const literal_slice = literal_node.token.slice(self.source); // This succeeding is guaranteed by the parser const control_class = rc.ControlClass.map.get(literal_slice) orelse unreachable; - const ordinal = NameOrOrdinal{ .ordinal = @intFromEnum(control_class) }; + const ordinal = NameOrOrdinal{ .ordinal = @backingInt(control_class) }; try ordinal.write(data_writer); } } @@ -2620,7 +2620,7 @@ pub const Compiler = struct { const type_value = type: { const resource_type = ResourceType.fromString(type_bytes); if (res.RT.fromResource(resource_type)) |rt_constant| { - break :type NameOrOrdinal{ .ordinal = @intFromEnum(rt_constant) }; + break :type NameOrOrdinal{ .ordinal = @backingInt(rt_constant) }; } else { break :type try NameOrOrdinal.fromString(allocator, type_bytes); } @@ -2974,7 +2974,7 @@ pub const FontDir = struct { var header = Compiler.ResourceHeader{ .name_value = try NameOrOrdinal.nameFromString(compiler.allocator, .{ .slice = "FONTDIR", .code_page = .windows1252 }), - .type_value = NameOrOrdinal{ .ordinal = @intFromEnum(res.RT.FONTDIR) }, + .type_value = NameOrOrdinal{ .ordinal = @backingInt(res.RT.FONTDIR) }, .memory_flags = res.MemoryFlags.defaults(res.RT.FONTDIR), .language = compiler.state.language, .version = compiler.state.version, @@ -3230,7 +3230,7 @@ pub const StringTable = struct { const header = Compiler.ResourceHeader{ .name_value = .{ .ordinal = block_id }, - .type_value = .{ .ordinal = @intFromEnum(res.RT.STRING) }, + .type_value = .{ .ordinal = @backingInt(res.RT.STRING) }, .memory_flags = self.memory_flags, .language = language, .version = self.version, diff --git a/lib/compiler/resinator/cvtres.zig b/lib/compiler/resinator/cvtres.zig index 52f3a70ca0b4162ae5fc2248c29205b686ce56bb..fb8ce8718907f1b369f4c5126e6d6f3bb554e85a 100644 --- a/lib/compiler/resinator/cvtres.zig +++ b/lib/compiler/resinator/cvtres.zig @@ -40,7 +40,7 @@ pub const Resource = struct { } pub fn isDlgInclude(resource: Resource) bool { - return resource.type_value == .ordinal and resource.type_value.ordinal == @intFromEnum(res.RT.DLGINCLUDE); + return resource.type_value == .ordinal and resource.type_value.ordinal == @backingInt(res.RT.DLGINCLUDE); } }; @@ -306,7 +306,7 @@ pub fn writeCoff( try writeSymbol(writer, .{ .name = ".rsrc$01".*, .value = 0, - .section_number = @enumFromInt(1), + .section_number = @fromBackingInt(@intCast(1)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -327,7 +327,7 @@ pub fn writeCoff( try writeSymbol(writer, .{ .name = ".rsrc$02".*, .value = 0, - .section_number = @enumFromInt(2), + .section_number = @fromBackingInt(@intCast(2)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -383,10 +383,10 @@ pub fn writeCoff( fn writeSymbol(writer: *std.Io.Writer, symbol: std.coff.Symbol) !void { try writer.writeAll(&symbol.name); try writer.writeInt(u32, symbol.value, .little); - try writer.writeInt(i16, @intFromEnum(symbol.section_number), .little); - try writer.writeInt(u8, @intFromEnum(symbol.type.base_type), .little); - try writer.writeInt(u8, @intFromEnum(symbol.type.complex_type), .little); - try writer.writeInt(u8, @intFromEnum(symbol.storage_class), .little); + try writer.writeInt(i16, @backingInt(symbol.section_number), .little); + try writer.writeInt(u8, @backingInt(symbol.type.base_type), .little); + try writer.writeInt(u8, @backingInt(symbol.type.complex_type), .little); + try writer.writeInt(u8, @backingInt(symbol.storage_class), .little); try writer.writeInt(u8, symbol.number_of_aux_symbols, .little); } @@ -396,7 +396,7 @@ fn writeSectionDefinition(writer: *std.Io.Writer, def: std.coff.SectionDefinitio try writer.writeInt(u16, def.number_of_linenumbers, .little); try writer.writeInt(u32, def.checksum, .little); try writer.writeInt(u16, def.number, .little); - try writer.writeInt(u8, @intFromEnum(def.selection), .little); + try writer.writeInt(u8, @backingInt(def.selection), .little); try writer.writeAll(&def.unused); } @@ -890,7 +890,7 @@ const ResourceTree = struct { symbols[i] = .{ .name = name_buf, .value = relocation.data_offset, - .section_number = @enumFromInt(2), + .section_number = @fromBackingInt(@intCast(2)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -1056,7 +1056,7 @@ pub const supported_targets = struct { comptime { const info = @typeInfo(Arch).@"enum"; for (info.field_names, info.field_values) |field_name, field_value| { - _ = std.mem.indexOfScalar(Arch, ordered_for_display, @enumFromInt(field_value)) orelse { + _ = std.mem.indexOfScalar(Arch, ordered_for_display, @fromBackingInt(@intCast(field_value))) orelse { @compileError(std.fmt.comptimePrint("'{s}' missing from ordered_for_display", .{field_name})); }; } @@ -1089,11 +1089,11 @@ pub const supported_targets = struct { // https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#type-indicators pub fn rvaRelocationTypeIndicator(target: std.coff.IMAGE.FILE.MACHINE) ?u16 { return switch (target) { - .AMD64 => @intFromEnum(std.coff.IMAGE.REL.AMD64.ADDR32NB), - .I386 => @intFromEnum(std.coff.IMAGE.REL.I386.DIR32NB), - .ARMNT => @intFromEnum(std.coff.IMAGE.REL.ARM.ADDR32NB), - .ARM64, .ARM64EC, .ARM64X => @intFromEnum(std.coff.IMAGE.REL.ARM64.ADDR32NB), - .IA64 => @intFromEnum(std.coff.IMAGE.REL.IA64.DIR32NB), + .AMD64 => @backingInt(std.coff.IMAGE.REL.AMD64.ADDR32NB), + .I386 => @backingInt(std.coff.IMAGE.REL.I386.DIR32NB), + .ARMNT => @backingInt(std.coff.IMAGE.REL.ARM.ADDR32NB), + .ARM64, .ARM64EC, .ARM64X => @backingInt(std.coff.IMAGE.REL.ARM64.ADDR32NB), + .IA64 => @backingInt(std.coff.IMAGE.REL.IA64.DIR32NB), .EBC => 0x1, // This is what cvtres.exe writes for this target, unsure where it comes from else => null, }; diff --git a/lib/compiler/resinator/ico.zig b/lib/compiler/resinator/ico.zig index 16e0379970cdc74e2796a0236f52c807960ee542..895a3d90954d999147b9d445fd8db4e7df2eebe3 100644 --- a/lib/compiler/resinator/ico.zig +++ b/lib/compiler/resinator/ico.zig @@ -123,7 +123,7 @@ pub const IconDir = struct { pub fn writeResData(self: IconDir, writer: *std.Io.Writer, first_image_id: u16) !void { try writer.writeInt(u16, 0, .little); - try writer.writeInt(u16, @intFromEnum(self.image_type), .little); + try writer.writeInt(u16, @backingInt(self.image_type), .little); // We know that entries.len must fit into a u16 try writer.writeInt(u16, @as(u16, @intCast(self.entries.len)), .little); diff --git a/lib/compiler/resinator/lang.zig b/lib/compiler/resinator/lang.zig index 625462cf4764ff0319073e72dc32c54b80fd1915..013d421b1b81d4ffaa71e54b2506a69e8b6ad286 100644 --- a/lib/compiler/resinator/lang.zig +++ b/lib/compiler/resinator/lang.zig @@ -74,7 +74,7 @@ test parseInt { pub fn tagToInt(tag: []const u8) error{InvalidLanguageTag}!u16 { const maybe_id = try tagToId(tag); if (maybe_id) |id| { - return @intFromEnum(id); + return @backingInt(id); } else { return LOCALE_CUSTOM_UNSPECIFIED; } diff --git a/lib/compiler/resinator/parse.zig b/lib/compiler/resinator/parse.zig index c884e0510a8c295e24d9a69da8ca750a7ce20363..445424429ea2249991661e99840331e2b936bd96 100644 --- a/lib/compiler/resinator/parse.zig +++ b/lib/compiler/resinator/parse.zig @@ -151,7 +151,7 @@ pub const Parser = struct { }; try self.nextToken(.normal); - const type_i = @intFromEnum(optional_statement_type); + const type_i = @backingInt(optional_statement_type); if (last_statement_per_type[type_i] != null) { statement_type_has_duplicates[type_i] = true; } @@ -300,13 +300,13 @@ pub const Parser = struct { const slice = statement_identifier.slice(self.lexer.buffer); const optional_statement_type = rc.OptionalStatements.map.get(slice) orelse rc.OptionalStatements.dialog_map.get(slice).?; - break :type_i @intFromEnum(optional_statement_type); + break :type_i @backingInt(optional_statement_type); }, .font_statement => { - break :type_i @intFromEnum(rc.OptionalStatements.font); + break :type_i @backingInt(rc.OptionalStatements.font); }, .language_statement => { - break :type_i @intFromEnum(rc.OptionalStatements.language); + break :type_i @backingInt(rc.OptionalStatements.language); }, else => unreachable, } diff --git a/lib/compiler/resinator/rc.zig b/lib/compiler/resinator/rc.zig index 753decb1a7e10b472316b050e06032296cc62452..5007ec990eb6dc0668891a826a0f4641c7316b0c 100644 --- a/lib/compiler/resinator/rc.zig +++ b/lib/compiler/resinator/rc.zig @@ -76,7 +76,7 @@ pub const ResourceType = enum { const maybe_ordinal = res.NameOrOrdinal.maybeOrdinalFromString(bytes); if (maybe_ordinal) |ordinal| { if (ordinal.ordinal >= 256) return .user_defined; - return fromRT(@enumFromInt(ordinal.ordinal)); + return fromRT(@fromBackingInt(@intCast(ordinal.ordinal))); } return map.get(bytes.slice) orelse .user_defined; } @@ -133,13 +133,13 @@ pub const ResourceType = enum { .toolbar, .versioninfo, .vxd => @tagName(resource), // zig fmt: on .user_defined => "user-defined", - .cursor_num => std.fmt.comptimePrint("{d} (cursor)", .{@intFromEnum(res.RT.CURSOR)}), - .icon_num => std.fmt.comptimePrint("{d} (icon)", .{@intFromEnum(res.RT.ICON)}), - .string_num => std.fmt.comptimePrint("{d} (string)", .{@intFromEnum(res.RT.STRING)}), - .anicursor_num => std.fmt.comptimePrint("{d} (anicursor)", .{@intFromEnum(res.RT.ANICURSOR)}), - .aniicon_num => std.fmt.comptimePrint("{d} (aniicon)", .{@intFromEnum(res.RT.ANIICON)}), - .fontdir_num => std.fmt.comptimePrint("{d} (fontdir)", .{@intFromEnum(res.RT.FONTDIR)}), - .manifest_num => std.fmt.comptimePrint("{d} (manifest)", .{@intFromEnum(res.RT.MANIFEST)}), + .cursor_num => std.fmt.comptimePrint("{d} (cursor)", .{@backingInt(res.RT.CURSOR)}), + .icon_num => std.fmt.comptimePrint("{d} (icon)", .{@backingInt(res.RT.ICON)}), + .string_num => std.fmt.comptimePrint("{d} (string)", .{@backingInt(res.RT.STRING)}), + .anicursor_num => std.fmt.comptimePrint("{d} (anicursor)", .{@backingInt(res.RT.ANICURSOR)}), + .aniicon_num => std.fmt.comptimePrint("{d} (aniicon)", .{@backingInt(res.RT.ANIICON)}), + .fontdir_num => std.fmt.comptimePrint("{d} (fontdir)", .{@backingInt(res.RT.FONTDIR)}), + .manifest_num => std.fmt.comptimePrint("{d} (manifest)", .{@backingInt(res.RT.MANIFEST)}), }; } }; diff --git a/lib/compiler/resinator/res.zig b/lib/compiler/resinator/res.zig index 70da89a607f0315614522eccc22863c1f1bbf789..002fbc9a6edfa40f1f3ececce053c9584c23f837 100644 --- a/lib/compiler/resinator/res.zig +++ b/lib/compiler/resinator/res.zig @@ -407,7 +407,7 @@ pub const NameOrOrdinal = union(enum) { switch (self) { .ordinal => |ordinal| { if (ordinal >= 256) return null; - switch (@as(RT, @enumFromInt(ordinal))) { + switch (@as(RT, @fromBackingInt(@intCast(ordinal)))) { .ACCELERATOR, .ANICURSOR, .ANIICON, @@ -456,7 +456,7 @@ pub const NameOrOrdinal = union(enum) { try w.print("{f}", .{std.unicode.fmtUtf16Le(name)}); }, .ordinal => |ordinal| { - if (std.enums.tagName(RT, @enumFromInt(ordinal))) |predefined_type_name| { + if (std.enums.tagName(RT, @fromBackingInt(@intCast(ordinal)))) |predefined_type_name| { try w.print("{s}", .{predefined_type_name}); } else { try w.print("{d}", .{ordinal}); diff --git a/lib/compiler/test_runner.zig b/lib/compiler/test_runner.zig index 69b078a4bcd7a9c1277901d52b47a354fad51437..62c09fe22800abc8aeb462dbd8c8beffe0ef7925 100644 --- a/lib/compiler/test_runner.zig +++ b/lib/compiler/test_runner.zig @@ -187,7 +187,7 @@ fn mainServer(init: std.process.Init.Minimal) !void { defer io_instance.deinit(); const io = io_instance.io(); - const mode: fuzz_abi.LimitKind = @enumFromInt(try server.receiveBody_u8()); + const mode: fuzz_abi.LimitKind = @fromBackingInt(@intCast(try server.receiveBody_u8())); const amount_or_instance = try server.receiveBody_u64(); const main_instance = mode == .iterations or amount_or_instance == 0; @@ -249,7 +249,7 @@ fn mainServer(init: std.process.Init.Minimal) !void { }, else => { - std.debug.print("unsupported message: {x}\n", .{@intFromEnum(hdr.tag)}); + std.debug.print("unsupported message: {x}\n", .{@backingInt(hdr.tag)}); std.process.exit(1); }, } @@ -351,10 +351,10 @@ pub fn log( args: anytype, ) void { @disableInstrumentation(); - if (@intFromEnum(message_level) <= @intFromEnum(std.log.Level.err)) { + if (@backingInt(message_level) <= @backingInt(std.log.Level.err)) { log_err_count +|= 1; } - if (@intFromEnum(message_level) <= @intFromEnum(testing.log_level)) { + if (@backingInt(message_level) <= @backingInt(testing.log_level)) { std.debug.print( "[" ++ @tagName(scope) ++ "] (" ++ @tagName(message_level) ++ "): " ++ format ++ "\n", args, @@ -513,7 +513,7 @@ var fuzz_runner: if (builtin.fuzz) struct { while (true) { const hdr = try server.receiveMessage(); if (hdr.tag != .new_fuzz_input) { - panic("unexpected message: {x}\n", .{@intFromEnum(hdr.tag)}); + panic("unexpected message: {x}\n", .{@backingInt(hdr.tag)}); } const test_i = try server.receiveBody_u32(); const input_len = hdr.bytes_len - 4; diff --git a/lib/compiler/translate-c/ast.zig b/lib/compiler/translate-c/ast.zig index ebe9e7b20136fce75b091077207c43cf3cbc73fe..8350f0dbc5eb6b1522b616341d3adda239f0e03b 100644 --- a/lib/compiler/translate-c/ast.zig +++ b/lib/compiler/translate-c/ast.zig @@ -252,7 +252,7 @@ pub const Node = extern union { root_ref, pub const last_no_payload_tag = Tag.@"break"; - pub const no_payload_count = @intFromEnum(last_no_payload_tag) + 1; + pub const no_payload_count = @backingInt(last_no_payload_tag) + 1; pub fn Type(comptime t: Tag) type { return switch (t) { @@ -416,8 +416,8 @@ pub const Node = extern union { } pub fn init(comptime t: Tag) Node { - comptime std.debug.assert(@intFromEnum(t) < Tag.no_payload_count); - return .{ .tag_if_small_enough = @intFromEnum(t) }; + comptime std.debug.assert(@backingInt(t) < Tag.no_payload_count); + return .{ .tag_if_small_enough = @backingInt(t) }; } pub fn create(comptime t: Tag, ally: Allocator, data: Data(t)) error{OutOfMemory}!Node { @@ -436,7 +436,7 @@ pub const Node = extern union { pub fn tag(self: Node) Tag { if (self.tag_if_small_enough < Tag.no_payload_count) { - return @enumFromInt(@as(std.meta.Tag(Tag), @intCast(self.tag_if_small_enough))); + return @fromBackingInt(@intCast(@as(std.meta.Tag(Tag), @intCast(self.tag_if_small_enough)))); } else { return self.ptr_otherwise.tag; } @@ -453,7 +453,7 @@ pub const Node = extern union { } pub fn initPayload(payload: *Payload) Node { - std.debug.assert(@intFromEnum(payload.tag) >= Tag.no_payload_count); + std.debug.assert(@backingInt(payload.tag) >= Tag.no_payload_count); return .{ .ptr_otherwise = payload }; } @@ -913,13 +913,13 @@ const Context = struct { fn listToSpan(c: *Context, list: []const NodeIndex) Allocator.Error!NodeSubRange { try c.extra_data.appendSlice(c.gpa, @ptrCast(list)); return .{ - .start = @enumFromInt(c.extra_data.items.len - list.len), - .end = @enumFromInt(c.extra_data.items.len), + .start = @fromBackingInt(@intCast(c.extra_data.items.len - list.len)), + .end = @fromBackingInt(@intCast(c.extra_data.items.len)), }; } fn addNode(c: *Context, elem: std.zig.Ast.Node) Allocator.Error!NodeIndex { - const result: NodeIndex = @enumFromInt(c.nodes.len); + const result: NodeIndex = @fromBackingInt(@intCast(c.nodes.len)); try c.nodes.append(c.gpa, elem); return result; } @@ -927,14 +927,14 @@ const Context = struct { fn addExtra(c: *Context, extra: anytype) Allocator.Error!std.zig.Ast.ExtraIndex { const info = @typeInfo(@TypeOf(extra)).@"struct"; try c.extra_data.ensureUnusedCapacity(c.gpa, info.field_names.len); - const result: std.zig.Ast.ExtraIndex = @enumFromInt(c.extra_data.items.len); + const result: std.zig.Ast.ExtraIndex = @fromBackingInt(@intCast(c.extra_data.items.len)); inline for (info.field_names, info.field_types) |field_name, field_type| { const data: u32 = switch (field_type) { NodeIndex, std.zig.Ast.Node.OptionalIndex, std.zig.Ast.OptionalTokenIndex, std.zig.Ast.ExtraIndex, - => @intFromEnum(@field(extra, field_name)), + => @backingInt(@field(extra, field_name)), TokenIndex, => @field(extra, field_name), else => @compileError("unexpected field type"), diff --git a/lib/compiler/translate-c/main.zig b/lib/compiler/translate-c/main.zig index 1b884815bb720c37183ec94f62f8dca73409347e..95836a94519ecbae20eea20f63b03d161301376c 100644 --- a/lib/compiler/translate-c/main.zig +++ b/lib/compiler/translate-c/main.zig @@ -189,7 +189,7 @@ fn translate(d: *aro.Driver, tc: *aro.Toolchain, args: []const [:0]const u8, zig if (val_str.len != 1 or val_str[0] < '0' or val_str[0] > '3') { return d.fatal("-fstrict-flex-arrays= requires a value of '0', '1', '2', or '3'", .{}); } - strict_flex_arrays = @enumFromInt(val_str[0] - '0'); + strict_flex_arrays = @fromBackingInt(@intCast(val_str[0] - '0')); } else { aro_args.appendAssumeCapacity(arg); } diff --git a/lib/compiler_rt/cmpdf2.zig b/lib/compiler_rt/cmpdf2.zig index 7a9295bcdb764fc9860a591ef16adadf844c3d96..e55972efbd00da3c3b215e722ba2277557a37525 100644 --- a/lib/compiler_rt/cmpdf2.zig +++ b/lib/compiler_rt/cmpdf2.zig @@ -25,7 +25,7 @@ comptime { /// Note that this matches the definition of `__ledf2`, `__eqdf2`, `__nedf2`, `__cmpdf2`, /// and `__ltdf2`. fn __cmpdf2(a: f64, b: f64) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f64, comparef.LE, a, b)); + return @backingInt(comparef.cmpf2(f64, comparef.LE, a, b)); } /// "These functions return a value less than or equal to zero if neither argument is NaN, diff --git a/lib/compiler_rt/cmptf2.zig b/lib/compiler_rt/cmptf2.zig index dfe488aedb7109c1e26b04ca6abdeac70b982f2e..89418fb320b5b8ea3d2f972cf05dde162eccc7c0 100644 --- a/lib/compiler_rt/cmptf2.zig +++ b/lib/compiler_rt/cmptf2.zig @@ -41,7 +41,7 @@ comptime { /// Note that this matches the definition of `__letf2`, `__eqtf2`, `__netf2`, `__cmptf2`, /// and `__lttf2`. fn __cmptf2(a: f128, b: f128) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f128, comparef.LE, a, b)); + return @backingInt(comparef.cmpf2(f128, comparef.LE, a, b)); } /// "These functions return a value less than or equal to zero if neither argument is NaN, @@ -78,68 +78,68 @@ const SparcFCMP = enum(i32) { }; fn _Qp_cmp(a: *const f128, b: *const f128) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f128, SparcFCMP, a.*, b.*)); + return @backingInt(comparef.cmpf2(f128, SparcFCMP, a.*, b.*)); } fn _Qp_feq(a: *const f128, b: *const f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) == .Equal; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Qp_cmp(a, b)))) == .Equal; } fn _Qp_fne(a: *const f128, b: *const f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) != .Equal; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Qp_cmp(a, b)))) != .Equal; } fn _Qp_flt(a: *const f128, b: *const f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) == .Less; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Qp_cmp(a, b)))) == .Less; } fn _Qp_fgt(a: *const f128, b: *const f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b))) == .Greater; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Qp_cmp(a, b)))) == .Greater; } fn _Qp_fge(a: *const f128, b: *const f128) callconv(.c) bool { - return switch (@as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b)))) { + return switch (@as(SparcFCMP, @fromBackingInt(@intCast(_Qp_cmp(a, b))))) { .Equal, .Greater => true, .Less, .Unordered => false, }; } fn _Qp_fle(a: *const f128, b: *const f128) callconv(.c) bool { - return switch (@as(SparcFCMP, @enumFromInt(_Qp_cmp(a, b)))) { + return switch (@as(SparcFCMP, @fromBackingInt(@intCast(_Qp_cmp(a, b))))) { .Equal, .Less => true, .Greater, .Unordered => false, }; } fn _Q_cmp(a: f128, b: f128) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f128, SparcFCMP, a, b)); + return @backingInt(comparef.cmpf2(f128, SparcFCMP, a, b)); } fn _Q_feq(a: f128, b: f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Q_cmp(a, b))) == .Equal; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Q_cmp(a, b)))) == .Equal; } fn _Q_fne(a: f128, b: f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Q_cmp(a, b))) != .Equal; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Q_cmp(a, b)))) != .Equal; } fn _Q_flt(a: f128, b: f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Q_cmp(a, b))) == .Less; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Q_cmp(a, b)))) == .Less; } fn _Q_fgt(a: f128, b: f128) callconv(.c) bool { - return @as(SparcFCMP, @enumFromInt(_Q_cmp(a, b))) == .Greater; + return @as(SparcFCMP, @fromBackingInt(@intCast(_Q_cmp(a, b)))) == .Greater; } fn _Q_fge(a: f128, b: f128) callconv(.c) bool { - return switch (@as(SparcFCMP, @enumFromInt(_Q_cmp(a, b)))) { + return switch (@as(SparcFCMP, @fromBackingInt(@intCast(_Q_cmp(a, b))))) { .Equal, .Greater => true, .Less, .Unordered => false, }; } fn _Q_fle(a: f128, b: f128) callconv(.c) bool { - return switch (@as(SparcFCMP, @enumFromInt(_Q_cmp(a, b)))) { + return switch (@as(SparcFCMP, @fromBackingInt(@intCast(_Q_cmp(a, b))))) { .Equal, .Less => true, .Greater, .Unordered => false, }; diff --git a/lib/compiler_rt/cmpxf2.zig b/lib/compiler_rt/cmpxf2.zig index c6e2e375a1f6c5d80331d8bd325f937248202168..8146cd83c2f05bff98a3a122de2431820d897a08 100644 --- a/lib/compiler_rt/cmpxf2.zig +++ b/lib/compiler_rt/cmpxf2.zig @@ -19,7 +19,7 @@ comptime { /// Note that this matches the definition of `__lexf2`, `__eqxf2`, `__nexf2`, `__cmpxf2`, /// and `__ltxf2`. fn __cmpxf2(a: f80, b: f80) callconv(.c) i32 { - return @intFromEnum(comparef.cmp_f80(comparef.LE, a, b)); + return @backingInt(comparef.cmp_f80(comparef.LE, a, b)); } /// "These functions return a value less than or equal to zero if neither argument is NaN, diff --git a/lib/compiler_rt/comparef.zig b/lib/compiler_rt/comparef.zig index 25437298eead6581b5f8275d700d1c2f21e0190e..a0f7551c74c9068909ef9e10c0ea71fa93140eef 100644 --- a/lib/compiler_rt/comparef.zig +++ b/lib/compiler_rt/comparef.zig @@ -52,7 +52,7 @@ pub fn __unordtf2(a: f128, b: f128) callconv(.c) i32 { /// Note that this matches the definition of `__lesf2`, `__eqsf2`, `__nesf2`, `__cmpsf2`, /// and `__ltsf2`. fn __cmpsf2(a: f32, b: f32) callconv(.c) i32 { - return @intFromEnum(cmpf2(f32, LE, a, b)); + return @backingInt(cmpf2(f32, LE, a, b)); } /// "These functions return a value less than or equal to zero if neither argument is NaN, @@ -100,7 +100,7 @@ fn __aeabi_fcmple(a: f32, b: f32) callconv(.{ .arm_aapcs = .{} }) i32 { /// Note that this matches the definition of `__lehf2`, `__eqhf2`, `__nehf2`, `__cmphf2`, /// and `__lthf2`. fn __cmphf2(a: f16, b: f16) callconv(.c) i32 { - return @intFromEnum(cmpf2(f16, LE, a, b)); + return @backingInt(cmpf2(f16, LE, a, b)); } /// "These functions return a value less than or equal to zero if neither argument is NaN, diff --git a/lib/compiler_rt/gedf2.zig b/lib/compiler_rt/gedf2.zig index a37fb27bd362d4f5a3155657624430e19461356c..f6b4b6d718fd20d8068244cfa6250f030f890e92 100644 --- a/lib/compiler_rt/gedf2.zig +++ b/lib/compiler_rt/gedf2.zig @@ -17,7 +17,7 @@ comptime { /// "These functions return a value greater than or equal to zero if neither /// argument is NaN, and a is greater than or equal to b." pub fn __gedf2(a: f64, b: f64) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f64, comparef.GE, a, b)); + return @backingInt(comparef.cmpf2(f64, comparef.GE, a, b)); } /// "These functions return a value greater than zero if neither argument is NaN, diff --git a/lib/compiler_rt/gehf2.zig b/lib/compiler_rt/gehf2.zig index e4e15a449d41b5e703498b9a1e66c6c6c1683d0d..8008a06849887d2f317be4517a5cb6c485c2675a 100644 --- a/lib/compiler_rt/gehf2.zig +++ b/lib/compiler_rt/gehf2.zig @@ -11,7 +11,7 @@ comptime { /// "These functions return a value greater than or equal to zero if neither /// argument is NaN, and a is greater than or equal to b." pub fn __gehf2(a: f16, b: f16) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f16, comparef.GE, a, b)); + return @backingInt(comparef.cmpf2(f16, comparef.GE, a, b)); } /// "These functions return a value greater than zero if neither argument is NaN, diff --git a/lib/compiler_rt/gesf2.zig b/lib/compiler_rt/gesf2.zig index 49454c469411e4fe41aee3d5edbb71630b6ca7f0..7f5022104eba9378efe6184befcd7f40f479306f 100644 --- a/lib/compiler_rt/gesf2.zig +++ b/lib/compiler_rt/gesf2.zig @@ -17,7 +17,7 @@ comptime { /// "These functions return a value greater than or equal to zero if neither /// argument is NaN, and a is greater than or equal to b." pub fn __gesf2(a: f32, b: f32) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f32, comparef.GE, a, b)); + return @backingInt(comparef.cmpf2(f32, comparef.GE, a, b)); } /// "These functions return a value greater than zero if neither argument is NaN, diff --git a/lib/compiler_rt/getf2.zig b/lib/compiler_rt/getf2.zig index 927013050ae01019e80c2d7c2d862991495072ed..88a91600f1e32c5f7124f5e9be9d5828b2471f2e 100644 --- a/lib/compiler_rt/getf2.zig +++ b/lib/compiler_rt/getf2.zig @@ -16,7 +16,7 @@ comptime { /// "These functions return a value greater than or equal to zero if neither /// argument is NaN, and a is greater than or equal to b." fn __getf2(a: f128, b: f128) callconv(.c) i32 { - return @intFromEnum(comparef.cmpf2(f128, comparef.GE, a, b)); + return @backingInt(comparef.cmpf2(f128, comparef.GE, a, b)); } /// "These functions return a value greater than zero if neither argument is NaN, diff --git a/lib/compiler_rt/gexf2.zig b/lib/compiler_rt/gexf2.zig index c6b3a1befdab554692b4d41411b933eefa227d4a..9f1f356187cdf9c7b85be2d49f9e2e73439f381b 100644 --- a/lib/compiler_rt/gexf2.zig +++ b/lib/compiler_rt/gexf2.zig @@ -7,7 +7,7 @@ comptime { } fn __gexf2(a: f80, b: f80) callconv(.c) i32 { - return @intFromEnum(comparef.cmp_f80(comparef.GE, a, b)); + return @backingInt(comparef.cmp_f80(comparef.GE, a, b)); } fn __gtxf2(a: f80, b: f80) callconv(.c) i32 { diff --git a/lib/docs/wasm/Decl.zig b/lib/docs/wasm/Decl.zig index 79a55294d25afee9eaf9bc36f0644308a83dbd1c..ee0d82ae5a231130e32c9c7e9f765684a1992150 100644 --- a/lib/docs/wasm/Decl.zig +++ b/lib/docs/wasm/Decl.zig @@ -24,7 +24,7 @@ pub const Index = enum(u32) { _, pub fn get(i: Index) *Decl { - return &Walk.decls.items[@intFromEnum(i)]; + return &Walk.decls.items[@backingInt(i)]; } }; @@ -130,7 +130,7 @@ pub fn get_child(decl: *const Decl, name: []const u8) ?Decl.Index { // Find a decl with this function as the parent, with a name matching `name` for (Walk.decls.items, 0..) |*candidate, i| { if (candidate.parent != .none and candidate.parent.get() == decl and std.mem.eql(u8, candidate.extra_info().name, name)) { - return @enumFromInt(i); + return @fromBackingInt(@intCast(i)); } } diff --git a/lib/docs/wasm/Walk.zig b/lib/docs/wasm/Walk.zig index 6f7a288ea14631158214e95053174af12a51df6f..6d69a184cdd6f8287971592edac48a5664dbfd42 100644 --- a/lib/docs/wasm/Walk.zig +++ b/lib/docs/wasm/Walk.zig @@ -68,13 +68,13 @@ pub const File = struct { .file = i, .parent = parent_decl, }); - const decl_index: Decl.Index = @enumFromInt(decls.items.len - 1); + const decl_index: Decl.Index = @fromBackingInt(@intCast(decls.items.len - 1)); try i.get().node_decls.put(gpa, node, decl_index); return decl_index; } pub fn get(i: File.Index) *File { - return &files.values()[@intFromEnum(i)]; + return &files.values()[@backingInt(i)]; } pub fn get_ast(i: File.Index) *Ast { @@ -82,7 +82,7 @@ pub const File = struct { } pub fn path(i: File.Index) []const u8 { - return files.keys()[@intFromEnum(i)]; + return files.keys()[@backingInt(i)]; } pub fn findRootDecl(file_index: File.Index) Decl.Index { @@ -329,7 +329,7 @@ pub const File = struct { base_path, file_path, resolved_path, }); if (files.getIndex(resolved_path)) |imported_file_index| { - return .{ .alias = File.Index.findRootDecl(@enumFromInt(imported_file_index)) }; + return .{ .alias = File.Index.findRootDecl(@fromBackingInt(@intCast(imported_file_index))) }; } else { log.warn("import target '{s}' did not resolve to any file", .{resolved_path}); } @@ -388,7 +388,7 @@ pub const ModuleIndex = enum(u32) { pub fn add_file(file_name: []const u8, bytes: []u8) !File.Index { const ast = try parse(file_name, bytes); assert(ast.errors.len == 0); - const file_index: File.Index = @enumFromInt(files.entries.len); + const file_index: File.Index = @fromBackingInt(@intCast(files.entries.len)); try files.put(gpa, file_name, .{ .ast = ast }); var w: Walk = .{ diff --git a/lib/docs/wasm/main.zig b/lib/docs/wasm/main.zig index d73f2a68160ff2db197067d8cc39e40e4998a824..7f8bf047e44235eabdc5350098923ca074e862bd 100644 --- a/lib/docs/wasm/main.zig +++ b/lib/docs/wasm/main.zig @@ -90,7 +90,7 @@ export fn query_exec(ignore_case: bool) [*]Decl.Index { query_exec_fallible(query, ignore_case) catch |err| switch (err) { error.OutOfMemory => @panic("OOM"), }; - query_results.items[0] = @enumFromInt(query_results.items.len - 1); + query_results.items[0] = @fromBackingInt(@intCast(query_results.items.len - 1)); return query_results.items.ptr; } @@ -165,7 +165,7 @@ fn query_exec_fallible(query: []const u8, ignore_case: bool) !void { } if (query_results.items.len < max_matched_items or bypass_limit) { - try query_results.append(gpa, @enumFromInt(decl_index)); + try query_results.append(gpa, @fromBackingInt(@intCast(decl_index))); try g.scores.append(gpa, .{ .points = points, .segments = @intCast(count_scalar(g.full_path_search_text.items, '.')), @@ -717,8 +717,8 @@ fn render_docs( node: markdown.Document.Node.Index, writer: *Writer, ) Writer.Error!void { - const data = doc.nodes.items(.data)[@intFromEnum(node)]; - switch (doc.nodes.items(.tag)[@intFromEnum(node)]) { + const data = doc.nodes.items(.data)[@backingInt(node)]; + switch (doc.nodes.items(.tag)[@backingInt(node)]) { .code_span => { try writer.writeAll(""); const content = doc.string(data.text.content); @@ -806,7 +806,7 @@ fn unpackInner(tar_bytes: []u8) !void { if (std.mem.indexOfScalar(u8, file_name, '/')) |pkg_name_end| { const pkg_name = file_name[0..pkg_name_end]; const gop = try Walk.modules.getOrPut(gpa, pkg_name); - const file: Walk.File.Index = @enumFromInt(Walk.files.entries.len); + const file: Walk.File.Index = @fromBackingInt(@intCast(Walk.files.entries.len)); if (!gop.found_existing or std.mem.eql(u8, file_name[pkg_name_end..], "/root.zig") or std.mem.eql(u8, file_name[pkg_name_end + 1 .. file_name.len - ".zig".len], pkg_name)) @@ -837,7 +837,7 @@ export fn module_name(index: u32) String { } export fn find_module_root(pkg: Walk.ModuleIndex) Decl.Index { - const root_file = Walk.modules.values()[@intFromEnum(pkg)]; + const root_file = Walk.modules.values()[@backingInt(pkg)]; const result = root_file.findRootDecl(); assert(result != .none); return result; @@ -854,7 +854,7 @@ export fn set_input_string(len: usize) [*]u8 { /// Looks up the root struct decl corresponding to a file by path. /// Uses `input_string`. export fn find_file_root() Decl.Index { - const file: Walk.File.Index = @enumFromInt(Walk.files.getIndex(input_string.items) orelse return .none); + const file: Walk.File.Index = @fromBackingInt(@intCast(Walk.files.getIndex(input_string.items) orelse return .none)); return file.findRootDecl(); } @@ -874,7 +874,7 @@ export fn find_decl() Decl.Index { if (std.mem.eql(u8, g.match_fqn.items, input_string.items)) { //const path = @as(Decl.Index, @enumFromInt(decl_index)).get().file.path(); //log.debug("find_decl '{s}' found in {s}", .{ input_string.items, path }); - return @enumFromInt(decl_index); + return @fromBackingInt(@intCast(decl_index)); } } return .none; @@ -930,7 +930,7 @@ export fn namespace_members(parent: Decl.Index, include_private: bool) Slice(Dec for (Walk.decls.items, 0..) |*decl, i| { if (decl.parent == parent) { if (include_private or decl.is_pub()) { - g.members.append(gpa, @enumFromInt(i)) catch @panic("OOM"); + g.members.append(gpa, @fromBackingInt(@intCast(i))) catch @panic("OOM"); } } } diff --git a/lib/docs/wasm/markdown/Document.zig b/lib/docs/wasm/markdown/Document.zig index 0cf00556fbbcbcb5a54289db47d0bb31493e16c2..97507506af7a15bb5a800085930709d1446d8a11 100644 --- a/lib/docs/wasm/markdown/Document.zig +++ b/lib/docs/wasm/markdown/Document.zig @@ -126,8 +126,8 @@ pub const Node = struct { pub fn asNumber(start: ListStart) ?u30 { if (start == .unordered) return null; - assert(@intFromEnum(start) <= 999_999_999); - return @intFromEnum(start); + assert(@backingInt(start) <= 999_999_999); + return @backingInt(start); } }; @@ -171,7 +171,7 @@ pub fn ExtraData(comptime T: type) type { pub fn extraData(doc: Document, comptime T: type, index: ExtraIndex) ExtraData(T) { const info = @typeInfo(T).@"struct"; - var i: usize = @intFromEnum(index); + var i: usize = @backingInt(index); var result: T = undefined; inline for (info.field_names, info.field_types) |field_name, field_type| { @field(result, field_name) = switch (field_type) { @@ -189,6 +189,6 @@ pub fn extraChildren(doc: Document, index: ExtraIndex) []const Node.Index { } pub fn string(doc: Document, index: StringIndex) [:0]const u8 { - const start = @intFromEnum(index); + const start = @backingInt(index); return std.mem.span(@as([*:0]u8, @ptrCast(doc.string_bytes[start..].ptr))); } diff --git a/lib/docs/wasm/markdown/Parser.zig b/lib/docs/wasm/markdown/Parser.zig index 9d1bc1f46d45c3ff87e29307e2e78196849d81fd..0b4695983cc7fc7dd89ffbd4273f809fdfe7bba1 100644 --- a/lib/docs/wasm/markdown/Parser.zig +++ b/lib/docs/wasm/markdown/Parser.zig @@ -444,7 +444,7 @@ fn appendBlockStart(p: *Parser, block_start: BlockStart) !void { const header_data = datas[p.scratch_extra.getLast().?]; for (p.extraChildren(header_data.container.children), 0..) |header_cell, i| { const alignment = if (i < alignments.len) alignments[i] else .unset; - const cell_data = &datas[@intFromEnum(header_cell)].table_cell; + const cell_data = &datas[@backingInt(header_cell)].table_cell; cell_data.info.alignment = alignment; cell_data.info.header = true; } @@ -847,7 +847,7 @@ fn closeLastBlock(p: *Parser) !void { .tag = .list, .data = .{ .list = .{ .start = switch (b.data.list.marker) { - .number_dot, .number_paren => @enumFromInt(b.data.list.start), + .number_dot, .number_paren => @fromBackingInt(@intCast(b.data.list.start)), .@"-", .@"*", .@"+" => .unordered, }, .children = children, @@ -1087,7 +1087,7 @@ const InlineParser = struct { } } try ip.parent.string_bytes.append(ip.parent.allocator, 0); - return @enumFromInt(string_top); + return @fromBackingInt(@intCast(string_top)); } /// Parses an autolink, starting at the opening `<`. `ip.pos` is left at the @@ -1478,7 +1478,7 @@ const InlineParser = struct { try ip.parent.addScratchExtraNode(try ip.parent.addNode(.{ .tag = .text, .data = .{ .text = .{ - .content = @enumFromInt(string_start), + .content = @fromBackingInt(@intCast(string_start)), } }, })); string_start = ip.parent.string_bytes.items.len; @@ -1495,7 +1495,7 @@ const InlineParser = struct { try ip.parent.addScratchExtraNode(try ip.parent.addNode(.{ .tag = .text, .data = .{ .text = .{ - .content = @enumFromInt(string_start), + .content = @fromBackingInt(@intCast(string_start)), } }, })); } @@ -1575,7 +1575,7 @@ fn parseInlines(p: *Parser, content: []const u8) !ExtraIndex { pub fn extraData(p: Parser, comptime T: type, index: ExtraIndex) ExtraData(T) { const info = @typeInfo(T).@"struct"; - var i: usize = @intFromEnum(index); + var i: usize = @backingInt(index); var result: T = undefined; inline for (info.field_names, info.field_types) |field_name, field_type| { @field(result, field_name) = switch (field_type) { @@ -1593,7 +1593,7 @@ pub fn extraChildren(p: Parser, index: ExtraIndex) []const Node.Index { } fn addNode(p: *Parser, node: Node) !Node.Index { - const index: Node.Index = @enumFromInt(@as(u32, @intCast(p.nodes.len))); + const index: Node.Index = @fromBackingInt(@intCast(@as(u32, @intCast(p.nodes.len)))); try p.nodes.append(p.allocator, node); return index; } @@ -1601,7 +1601,7 @@ fn addNode(p: *Parser, node: Node) !Node.Index { fn addString(p: *Parser, s: []const u8) !StringIndex { if (s.len == 0) return .empty; - const index: StringIndex = @enumFromInt(@as(u32, @intCast(p.string_bytes.items.len))); + const index: StringIndex = @fromBackingInt(@intCast(@as(u32, @intCast(p.string_bytes.items.len)))); try p.string_bytes.ensureUnusedCapacity(p.allocator, s.len + 1); p.string_bytes.appendSliceAssumeCapacity(s); p.string_bytes.appendAssumeCapacity(0); @@ -1609,7 +1609,7 @@ fn addString(p: *Parser, s: []const u8) !StringIndex { } fn addExtraChildren(p: *Parser, nodes: []const Node.Index) !ExtraIndex { - const index: ExtraIndex = @enumFromInt(@as(u32, @intCast(p.extra.items.len))); + const index: ExtraIndex = @fromBackingInt(@intCast(@as(u32, @intCast(p.extra.items.len)))); try p.extra.ensureUnusedCapacity(p.allocator, nodes.len + 1); p.extra.appendAssumeCapacity(@intCast(nodes.len)); p.extra.appendSliceAssumeCapacity(@ptrCast(nodes)); @@ -1617,7 +1617,7 @@ fn addExtraChildren(p: *Parser, nodes: []const Node.Index) !ExtraIndex { } fn addScratchExtraNode(p: *Parser, node: Node.Index) !void { - try p.scratch_extra.append(p.allocator, @intFromEnum(node)); + try p.scratch_extra.append(p.allocator, @backingInt(node)); } fn addScratchStringLine(p: *Parser, line: []const u8) !void { diff --git a/lib/docs/wasm/markdown/renderer.zig b/lib/docs/wasm/markdown/renderer.zig index 91fd7129d562b9bc6adc6e34377a49ae71c0d344..12b68d874421b72fcbe4b166c5c6830b2bdd4c1f 100644 --- a/lib/docs/wasm/markdown/renderer.zig +++ b/lib/docs/wasm/markdown/renderer.zig @@ -31,8 +31,8 @@ pub fn Renderer(comptime Context: type) type { node: Node.Index, writer: *Writer, ) Writer.Error!void { - const data = doc.nodes.items(.data)[@intFromEnum(node)]; - switch (doc.nodes.items(.tag)[@intFromEnum(node)]) { + const data = doc.nodes.items(.data)[@backingInt(node)]; + switch (doc.nodes.items(.tag)[@backingInt(node)]) { .root => { for (doc.extraChildren(data.container.children)) |child| { try r.renderFn(r, doc, child, writer); @@ -60,8 +60,8 @@ pub fn Renderer(comptime Context: type) type { .list_item => { try writer.writeAll("
  • "); for (doc.extraChildren(data.list_item.children)) |child| { - if (data.list_item.tight and doc.nodes.items(.tag)[@intFromEnum(child)] == .paragraph) { - const para_data = doc.nodes.items(.data)[@intFromEnum(child)]; + if (data.list_item.tight and doc.nodes.items(.tag)[@backingInt(child)] == .paragraph) { + const para_data = doc.nodes.items(.data)[@backingInt(child)]; for (doc.extraChildren(para_data.container.children)) |para_child| { try r.renderFn(r, doc, para_child, writer); } @@ -191,8 +191,8 @@ pub fn renderInlineNodeText( node: Node.Index, writer: *Writer, ) Writer.Error!void { - const data = doc.nodes.items(.data)[@intFromEnum(node)]; - switch (doc.nodes.items(.tag)[@intFromEnum(node)]) { + const data = doc.nodes.items(.data)[@backingInt(node)]; + switch (doc.nodes.items(.tag)[@backingInt(node)]) { .root, .list, .list_item, diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig index d4353db874490765967e47e90aaa923c871f2011..65f677fb4e95b301403ef95f3f7f4034697df856 100644 --- a/lib/fuzzer.zig +++ b/lib/fuzzer.zig @@ -830,7 +830,7 @@ const Fuzzer = struct { .seen_uids = .empty, .corpus = .empty, - .corpus_pos = @enumFromInt(0), + .corpus_pos = @fromBackingInt(@intCast(0)), .start_mut_corpus = math.maxInt(u32), .dirname = dirname, .lock_file = lock_file, @@ -965,14 +965,14 @@ const Fuzzer = struct { var i: usize = t.start_mut_corpus; while (i < t.corpus.len) { if (ref[i].best_i_len == 0) { - f.removeInput(@enumFromInt(i)); + f.removeInput(@fromBackingInt(@intCast(i))); } else { i += 1; } } } - t.corpus_pos = @enumFromInt(0); + t.corpus_pos = @fromBackingInt(@intCast(0)); } const CorpusFileName = struct { @@ -1084,12 +1084,12 @@ const Fuzzer = struct { fn removeBest(f: *Fuzzer, i: Input.Index, best_i: u32) void { const t = &f.tests[f.test_i]; - const ref = &t.corpus.items(.ref)[@intFromEnum(i)]; + const ref = &t.corpus.items(.ref)[@backingInt(i)]; const list_i = mem.indexOfScalar(u32, ref.best_i_buf[0..ref.best_i_len], best_i).?; ref.best_i_len -= 1; ref.best_i_buf[list_i] = ref.best_i_buf[ref.best_i_len]; - if (ref.best_i_len == 0 and @intFromEnum(i) >= t.start_mut_corpus) { + if (ref.best_i_len == 0 and @backingInt(i) >= t.start_mut_corpus) { // The input is no longer valuable, so remove it. f.removeInput(i); } @@ -1097,10 +1097,10 @@ const Fuzzer = struct { fn removeInput(f: *Fuzzer, i: Input.Index) void { const t = &f.tests[f.test_i]; - const ref = &t.corpus.items(.ref)[@intFromEnum(i)]; - assert(ref.best_i_len == 0 and @intFromEnum(i) >= t.start_mut_corpus); + const ref = &t.corpus.items(.ref)[@backingInt(i)]; + assert(ref.best_i_len == 0 and @backingInt(i) >= t.start_mut_corpus); - var removed_input = t.corpus.get(@intFromEnum(i)); + var removed_input = t.corpus.get(@backingInt(i)); for ( removed_input.data.uid_slices.keys(), removed_input.data.uid_slices.values(), @@ -1135,18 +1135,18 @@ const Fuzzer = struct { } } removed_input.deinit(); - t.corpus.swapRemove(@intFromEnum(i)); + t.corpus.swapRemove(@backingInt(i)); - if (@intFromEnum(i) != t.corpus.len) { + if (@backingInt(i) != t.corpus.len) { // The last item was moved so its refs need updated. // `ref` can be reused since it was a swap remove. for (ref.best_i_buf[0..ref.best_i_len]) |update_pc_i| { const best = &t.bests.input_buf[update_pc_i]; - assert(@intFromEnum(best.min) == t.corpus.len or - @intFromEnum(best.max) == t.corpus.len); + assert(@backingInt(best.min) == t.corpus.len or + @backingInt(best.max) == t.corpus.len); - if (@intFromEnum(best.min) == t.corpus.len) best.min = i; - if (@intFromEnum(best.max) == t.corpus.len) best.max = i; + if (@backingInt(best.min) == t.corpus.len) best.min = i; + if (@backingInt(best.max) == t.corpus.len) best.max = i; } } @@ -1161,8 +1161,8 @@ const Fuzzer = struct { }) catch |e| panic("failed to open '{s}': {t}", .{ readlock_name, e }); defer readlock_file.close(io); - const removed_name = removed_cname.inputName(@intFromEnum(i) - t.start_mut_corpus); - if (@intFromEnum(i) == t.corpus.len) { + const removed_name = removed_cname.inputName(@backingInt(i) - t.start_mut_corpus); + if (@backingInt(i) == t.corpus.len) { exec.cache_f.deleteFile(io, removed_name) catch |e| panic( "failed to remove corpus file '{s}': {t}", .{ removed_name, e }, @@ -1201,7 +1201,7 @@ const Fuzzer = struct { // omitted (i.e. test corpus inputs and filesystem inputs cannot be dropped) ) { f.input_builder.reset(); - t.corpus_pos = @enumFromInt(0); + t.corpus_pos = @fromBackingInt(@intCast(0)); return; } @@ -1250,7 +1250,7 @@ const Fuzzer = struct { } // Must come after the above since some inputs may be removed - const input_i: Input.Index = @enumFromInt(t.corpus.len); + const input_i: Input.Index = @fromBackingInt(@intCast(t.corpus.len)); if (input_i == Input.Index.reserved_start) { @panic("corpus size limit exceeded"); } @@ -1295,7 +1295,7 @@ const Fuzzer = struct { if (best_i_list.items.len == 0 and new_is_mut) { assert(best_i_list.capacity == 0); f.input_builder.reset(); - t.corpus_pos = @enumFromInt(0); + t.corpus_pos = @fromBackingInt(@intCast(0)); return; } @@ -1338,7 +1338,7 @@ const Fuzzer = struct { _ = @atomicRmw(usize, &exec.seenPcsHeader().unique_runs, .Add, 1, .monotonic); // Write new input to the cache var cname: CorpusFileName = .fromTest(t.dirname); - const name = cname.inputName(@intFromEnum(input_i) - t.start_mut_corpus); + const name = cname.inputName(@backingInt(input_i) - t.start_mut_corpus); exec.cache_f.writeFile(io, .{ .sub_path = name, .data = bytes, .flags = .{ .exclusive = true, } }) catch |e| panic("failed to write corpus file '{s}': {t}", .{ name, e }); @@ -1377,7 +1377,7 @@ const Fuzzer = struct { const t = &f.tests[f.test_i]; const corpus = t.corpus.slice(); - const corpus_i = @intFromEnum(t.corpus_pos); + const corpus_i = @backingInt(t.corpus_pos); var small_entronopy: SmallEntronopy = .{ .bits = f.rngInt(u64) }; var n_mutate = mutCount(small_entronopy.take(u16)); @@ -1436,8 +1436,8 @@ const Fuzzer = struct { abi.runner_broadcast_input(f.test_i, .fromSlice(f.mmap_input.inputSlice())); f.newInput(); } else { - assert(@intFromEnum(t.corpus_pos) < t.corpus.len); - t.corpus_pos = @enumFromInt((@intFromEnum(t.corpus_pos) + 1) % t.corpus.len); + assert(@backingInt(t.corpus_pos) < t.corpus.len); + t.corpus_pos = @fromBackingInt(@intCast((@backingInt(t.corpus_pos) + 1) % t.corpus.len)); } f.mmap_input.clearRetainingCapacity(); } @@ -1669,7 +1669,7 @@ const Fuzzer = struct { } { const t = &f.tests[f.test_i]; const corpus = t.corpus.slice(); - const corpus_i = @intFromEnum(t.corpus_pos); + const corpus_i = @backingInt(t.corpus_pos); const data = &corpus.items(.data)[corpus_i]; var small_entronopy: SmallEntronopy = .{ .bits = f.rngInt(u64) }; @@ -1689,7 +1689,7 @@ const Fuzzer = struct { f.uid_data_i.items[uid_i] += 1; const mut_i = std.simd.firstIndexOfValue( @as(@Vector(4, u32), f.mut_data.i), - data_i + @as(u32, @intCast(data.ints.len)) * @intFromEnum(uid.kind), + data_i + @as(u32, @intCast(data.ints.len)) * @backingInt(uid.kind), ) orelse { @branchHint(.likely); switch (uid.kind) { @@ -1918,7 +1918,7 @@ const Fuzzer = struct { pub fn nextInt(f: *Fuzzer, uid: Uid, weights: []const abi.Weight) u64 { const t = &f.tests[f.test_i]; f.req_values += 1; - if (@intFromEnum(t.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) { + if (@backingInt(t.corpus_pos) >= @backingInt(Input.Index.reserved_start)) { @branchHint(.unlikely); const int = f.bytes_input.valueWeightedWithHash(u64, weights, undefined); if (t.corpus_pos == .bytes_fresh) { @@ -1942,7 +1942,7 @@ const Fuzzer = struct { pub fn nextEos(f: *Fuzzer, uid: Uid, weights: []const abi.Weight) bool { const t = &f.tests[f.test_i]; f.req_values += 1; - if (@intFromEnum(t.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) { + if (@backingInt(t.corpus_pos) >= @backingInt(Input.Index.reserved_start)) { @branchHint(.unlikely); const eos = f.bytes_input.eosWeightedWithHash(weights, undefined); if (t.corpus_pos == .bytes_fresh) { @@ -2059,7 +2059,7 @@ const Fuzzer = struct { f.req_values += 1; f.req_bytes +%= @truncate(out.len); // This function should panic since the 32-bit // data limit is exceeded, so wrapping is fine. - if (@intFromEnum(t.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) { + if (@backingInt(t.corpus_pos) >= @backingInt(Input.Index.reserved_start)) { @branchHint(.unlikely); f.bytes_input.bytesWeightedWithHash(out, weights, undefined); if (t.corpus_pos == .bytes_fresh) { @@ -2149,7 +2149,7 @@ const Fuzzer = struct { ) u32 { const t = &f.tests[f.test_i]; f.req_values += 1; - if (@intFromEnum(t.corpus_pos) >= @intFromEnum(Input.Index.reserved_start)) { + if (@backingInt(t.corpus_pos) >= @backingInt(Input.Index.reserved_start)) { @branchHint(.unlikely); const n = f.bytes_input.sliceWeightedWithHash( buf, diff --git a/lib/std/Build.zig b/lib/std/Build.zig index 2b5d33f551e7d66b3462fd90ba9b58d2c8af9bab..fc2d9909729f1417a4ac486ffea254846137d09b 100644 --- a/lib/std/Build.zig +++ b/lib/std/Build.zig @@ -145,7 +145,7 @@ pub const Graph = struct { pub fn addGeneratedFile(graph: *Graph, owner: *Step) Configuration.GeneratedFileIndex { graph.generated_files.append(graph.arena, owner) catch @panic("OOM"); - return @enumFromInt(graph.generated_files.items.len - 1); + return @fromBackingInt(@intCast(graph.generated_files.items.len - 1)); } pub fn dupeString(graph: *const Graph, bytes: []const u8) []const u8 { @@ -2607,7 +2607,7 @@ pub const LazyPath = union(enum) { .src_path, .cwd_relative, .relative, .dependency => {}, .generated => |gen| { const graph = other_step.owner.graph; - const generated_owner_step = graph.generated_files.items[@intFromEnum(gen.index)]; + const generated_owner_step = graph.generated_files.items[@backingInt(gen.index)]; other_step.dependOn(generated_owner_step); }, } diff --git a/lib/std/Build/Configuration.zig b/lib/std/Build/Configuration.zig index f860fef0f5ad4d46435e0d7af01fb2e2980fe161..b839523867b4f151b9761b7178bd2d0290e593eb 100644 --- a/lib/std/Build/Configuration.zig +++ b/lib/std/Build/Configuration.zig @@ -109,7 +109,7 @@ pub const Wip = struct { } pub fn hash(ctx: @This(), key: String) u64 { - return std.hash_map.hashString(std.mem.sliceTo(ctx.bytes[@intFromEnum(key)..], 0)); + return std.hash_map.hashString(std.mem.sliceTo(ctx.bytes[@backingInt(key)..], 0)); } }; @@ -117,7 +117,7 @@ pub const Wip = struct { bytes: []const u8, pub fn eql(ctx: @This(), a: []const u8, b: String) bool { - return std.mem.eql(u8, a, std.mem.sliceTo(ctx.bytes[@intFromEnum(b)..], 0)); + return std.mem.eql(u8, a, std.mem.sliceTo(ctx.bytes[@backingInt(b)..], 0)); } pub fn hash(_: @This(), adapted_key: []const u8) u64 { @@ -192,7 +192,7 @@ pub const Wip = struct { if (gop.found_existing) return gop.key_ptr.*; try wip.string_bytes.ensureUnusedCapacity(gpa, bytes.len + 1); - const new_off: String = @enumFromInt(wip.string_bytes.items.len); + const new_off: String = @fromBackingInt(@intCast(wip.string_bytes.items.len)); wip.string_bytes.appendSliceAssumeCapacity(bytes); wip.string_bytes.appendAssumeCapacity(0); @@ -213,7 +213,7 @@ pub const Wip = struct { const revert_index: u32 = @intCast(wip.extra.items.len); const added = try wip.extra.addManyAsSlice(gpa, list.len + 1); added[0] = @intCast(list.len); - for (added[1..], list) |*d, s| d.* = @intFromEnum(try addString(wip, s)); + for (added[1..], list) |*d, s| d.* = @backingInt(try addString(wip, s)); const gop = try wip.dedupe_table.getOrPutContext(gpa, .{ .index = revert_index, .len = @intCast(added.len), @@ -221,10 +221,10 @@ pub const Wip = struct { if (gop.found_existing) { wip.extra.items.len = revert_index; - return @enumFromInt(gop.key_ptr.index); + return @fromBackingInt(@intCast(gop.key_ptr.index)); } - return @enumFromInt(revert_index); + return @fromBackingInt(@intCast(revert_index)); } pub fn addBytes(wip: *Wip, bytes: []const u8) Allocator.Error!Bytes { @@ -296,7 +296,7 @@ pub const Wip = struct { .extra = wip.extra.items, })); if (gop.found_existing) { - wip.extra.items.len = @intFromEnum(result_index); + wip.extra.items.len = @backingInt(result_index); return .init(gop.key_ptr.*); } else { return .init(result_index); @@ -371,7 +371,7 @@ pub const Wip = struct { .extra = wip.extra.items, })); if (gop.found_existing) { - wip.extra.items.len = @intFromEnum(result_index); + wip.extra.items.len = @backingInt(result_index); return gop.key_ptr.*; } else { return result_index; @@ -410,14 +410,14 @@ pub const Wip = struct { if (gop.found_existing) { wip.extra.items.len = revert_index; - return @enumFromInt(gop.key_ptr.index); + return @fromBackingInt(@intCast(gop.key_ptr.index)); } - return @enumFromInt(new_index); + return @fromBackingInt(@intCast(new_index)); } pub fn addExtraReserved(wip: *Wip, comptime T: type, v: T) T.Index { - return @enumFromInt(addExtraReservedErased(wip, T, v)); + return @fromBackingInt(@intCast(addExtraReservedErased(wip, T, v))); } pub fn addExtraReservedErased(wip: *Wip, comptime T: type, v: T) u32 { @@ -428,17 +428,17 @@ pub const Wip = struct { fn addExtraOptionalStringAssumeCapacity(wip: *Wip, optional_string: ?String) void { const string = optional_string orelse return; - wip.extra.appendAssumeCapacity(@intFromEnum(string)); + wip.extra.appendAssumeCapacity(@backingInt(string)); } pub fn addGeneratedFile(wip: *Wip) GeneratedFileIndex { defer wip.next_generated_file_index += 1; - return @enumFromInt(wip.next_generated_file_index); + return @fromBackingInt(@intCast(wip.next_generated_file_index)); } /// Returned slice expires upon next append to the configuration. pub fn stringSlice(wip: *const Wip, s: String) [:0]const u8 { - const start_slice = wip.string_bytes.items[@intFromEnum(s)..]; + const start_slice = wip.string_bytes.items[@backingInt(s)..]; return start_slice[0..std.mem.indexOfScalar(u8, start_slice, 0).? :0]; } }; @@ -503,7 +503,7 @@ pub const Step = extern struct { _, pub fn ptr(i: Index, c: *const Configuration) *const Step { - return &c.steps[@intFromEnum(i)]; + return &c.steps[@backingInt(i)]; } }; @@ -1134,7 +1134,7 @@ pub const Step = extern struct { .undef => .undef, .defined => .defined, _ => { - const value = extraData(c, Value, @intFromEnum(this)); + const value = extraData(c, Value, @backingInt(this)); return switch (value.flags.tag) { .ident => .{ .ident = value.ident.value.?.slice(c) }, .string => .{ .string = value.string.value.?.slice(c) }, @@ -1457,7 +1457,7 @@ pub const Step = extern struct { }; pub fn flags(s: *const Step, c: *const Configuration) Flags { - return @bitCast(c.extra[@intFromEnum(s.extended)]); + return @bitCast(c.extra[@backingInt(s.extended)]); } }; @@ -1466,12 +1466,12 @@ pub const MaxRss = enum(u32) { _, pub fn toBytes(mr: MaxRss) u64 { - const x: usize = @intFromEnum(mr); + const x: usize = @backingInt(mr); return x << 8; } pub fn fromBytes(bytes: u64) MaxRss { - return @enumFromInt(bytes >> 8); + return @fromBackingInt(@intCast(bytes >> 8)); } }; @@ -1499,7 +1499,7 @@ pub const LazyPath = union(@This().Tag) { _, pub fn get(this: @This(), c: *const Configuration) LazyPath { - return extraData(c, LazyPath, @intFromEnum(this)); + return extraData(c, LazyPath, @backingInt(this)); } }; @@ -1511,7 +1511,7 @@ pub const LazyPath = union(@This().Tag) { pub fn unwrap(this: @This()) ?Index { return switch (this) { .none => null, - else => @enumFromInt(@intFromEnum(this)), + else => @fromBackingInt(@intCast(@backingInt(this))), }; } }; @@ -1578,13 +1578,13 @@ pub const OptionalGeneratedFileIndex = enum(u32) { _, pub fn init(i: ?GeneratedFileIndex) OptionalGeneratedFileIndex { - return @enumFromInt(@intFromEnum(i orelse return .none)); + return @fromBackingInt(@intCast(@backingInt(i orelse return .none))); } pub fn unwrap(this: @This()) ?GeneratedFileIndex { return switch (this) { .none => null, - else => @enumFromInt(@intFromEnum(this)), + else => @fromBackingInt(@intCast(@backingInt(this))), }; } }; @@ -1601,7 +1601,7 @@ pub const Package = struct { /// Returns `null` for root package. pub fn get(i: @This(), c: *const Configuration) ?Package { if (i == .root) return null; - return extraData(c, Package, @intFromEnum(i)); + return extraData(c, Package, @backingInt(i)); } pub fn depPrefixSlice(i: @This(), c: *const Configuration) [:0]const u8 { @@ -1616,7 +1616,7 @@ pub const Package = struct { _, pub fn init(i: Index) OptionalIndex { - const result: OptionalIndex = @enumFromInt(@intFromEnum(i)); + const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i))); assert(result != .none); return result; } @@ -1625,7 +1625,7 @@ pub const Package = struct { return switch (this) { .none => null, .root => .root, - _ => @enumFromInt(@intFromEnum(this)), + _ => @fromBackingInt(@intCast(@backingInt(this))), }; } }; @@ -1710,7 +1710,7 @@ pub const Module = struct { _, pub fn get(this: @This(), c: *const Configuration) Module { - return extraData(c, Module, @intFromEnum(this)); + return extraData(c, Module, @backingInt(this)); } }; @@ -1802,7 +1802,7 @@ pub const ImportTable = struct { pub fn get(this: @This(), c: *const Configuration) ImportTable { return switch (this) { .invalid => unreachable, - _ => extraData(c, ImportTable, @intFromEnum(this)), + _ => extraData(c, ImportTable, @backingInt(this)), }; } }; @@ -1815,7 +1815,7 @@ pub const Deps = struct { _, pub fn get(this: @This(), c: *const Configuration) Deps { - return extraData(c, Deps, @intFromEnum(this)); + return extraData(c, Deps, @backingInt(this)); } pub fn slice(this: @This(), c: *const Configuration) []const Step.Index { @@ -1839,8 +1839,8 @@ pub const StringList = enum(u32) { _, pub fn slice(this: @This(), c: *const Configuration) []const String { - const len = c.extra[@intFromEnum(this)]; - return @ptrCast(c.extra[@intFromEnum(this) + 1 ..][0..len]); + const len = c.extra[@backingInt(this)]; + return @ptrCast(c.extra[@backingInt(this) + 1 ..][0..len]); } }; @@ -1850,14 +1850,14 @@ pub const OptionalStringList = enum(u32) { pub fn init(opt_string_list: ?StringList) OptionalStringList { const sl = opt_string_list orelse return .none; - const result: OptionalStringList = @enumFromInt(@intFromEnum(sl)); + const result: OptionalStringList = @fromBackingInt(@intCast(@backingInt(sl))); assert(result != .none); return result; } pub fn unwrap(this: @This()) ?StringList { if (this == .none) return null; - return @enumFromInt(@intFromEnum(this)); + return @fromBackingInt(@intCast(@backingInt(this))); } pub fn slice(this: @This(), c: *const Configuration) ?[]const String { @@ -1889,8 +1889,8 @@ pub const InstallDestDir = enum(u32) { _, pub fn initCustom(sub_path: String) InstallDestDir { - assert(@intFromEnum(sub_path) < @intFromEnum(InstallDestDir.none)); - return @enumFromInt(@intFromEnum(sub_path)); + assert(@backingInt(sub_path) < @backingInt(InstallDestDir.none)); + return @fromBackingInt(@intCast(@backingInt(sub_path))); } pub const Unpacked = union(enum) { @@ -1908,7 +1908,7 @@ pub const InstallDestDir = enum(u32) { .lib => .lib, .bin => .bin, .header => .header, - _ => .{ .sub_path = @enumFromInt(@intFromEnum(this)) }, + _ => .{ .sub_path = @fromBackingInt(@intCast(@backingInt(this))) }, }; } }; @@ -1922,14 +1922,14 @@ pub const OptionalString = enum(u32) { _, pub fn init(s: String) OptionalString { - const result: OptionalString = @enumFromInt(@intFromEnum(s)); + const result: OptionalString = @fromBackingInt(@intCast(@backingInt(s))); assert(result != .none); return result; } pub fn unwrap(this: @This()) ?String { if (this == .none) return null; - return @enumFromInt(@intFromEnum(this)); + return @fromBackingInt(@intCast(@backingInt(this))); } pub fn slice(this: @This(), c: *const Configuration) ?[:0]const u8 { @@ -1945,7 +1945,7 @@ pub const String = enum(u32) { _, pub fn slice(index: String, c: *const Configuration) [:0]const u8 { - const start_slice = c.string_bytes[@intFromEnum(index)..]; + const start_slice = c.string_bytes[@backingInt(index)..]; return start_slice[0..std.mem.indexOfScalar(u8, start_slice, 0).? :0]; } }; @@ -1975,13 +1975,13 @@ pub const Alignment = enum(u6) { pub fn init(optional_alignment: ?std.mem.Alignment) @This() { const a = optional_alignment orelse return .none; - return @enumFromInt(@intFromEnum(a)); + return @fromBackingInt(@intCast(@backingInt(a))); } pub fn toBytes(a: @This()) ?u64 { return switch (a) { .none => null, - else => @as(u64, 1) << @intFromEnum(a), + else => @as(u64, 1) << @backingInt(a), }; } }; @@ -2015,7 +2015,7 @@ pub const SystemLib = struct { _, pub fn get(this: @This(), c: *const Configuration) SystemLib { - return extraData(c, SystemLib, @intFromEnum(this)); + return extraData(c, SystemLib, @backingInt(this)); } }; @@ -2054,7 +2054,7 @@ pub const CSourceFiles = struct { _, pub fn get(this: @This(), c: *const Configuration) CSourceFiles { - return extraData(c, CSourceFiles, @intFromEnum(this)); + return extraData(c, CSourceFiles, @backingInt(this)); } }; @@ -2074,7 +2074,7 @@ pub const CSourceFile = struct { _, pub fn get(this: @This(), c: *const Configuration) CSourceFile { - return extraData(c, CSourceFile, @intFromEnum(this)); + return extraData(c, CSourceFile, @backingInt(this)); } }; @@ -2095,7 +2095,7 @@ pub const RcSourceFile = struct { _, pub fn get(this: @This(), c: *const Configuration) RcSourceFile { - return extraData(c, RcSourceFile, @intFromEnum(this)); + return extraData(c, RcSourceFile, @backingInt(this)); } }; @@ -2149,7 +2149,7 @@ pub const ResolvedTarget = struct { _, pub fn get(this: @This(), c: *const Configuration) ResolvedTarget { - return extraData(c, ResolvedTarget, @intFromEnum(this)); + return extraData(c, ResolvedTarget, @backingInt(this)); } }; @@ -2158,7 +2158,7 @@ pub const ResolvedTarget = struct { _, pub fn init(i: Index) OptionalIndex { - const result: OptionalIndex = @enumFromInt(@intFromEnum(i)); + const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i))); assert(result != .none); return result; } @@ -2166,7 +2166,7 @@ pub const ResolvedTarget = struct { pub fn unwrap(this: @This()) ?Index { return switch (this) { .none => null, - _ => @enumFromInt(@intFromEnum(this)), + _ => @fromBackingInt(@intCast(@backingInt(this))), }; } @@ -2219,15 +2219,15 @@ pub const TargetQuery = struct { _, pub fn extraSlice(i: Index, extra: []const u32) []const u32 { - return extra[@intFromEnum(i)..][0..length(i, extra)]; + return extra[@backingInt(i)..][0..length(i, extra)]; } pub fn length(i: Index, extra: []const u32) usize { - return Storage.dataLength(extra, @intFromEnum(i), TargetQuery); + return Storage.dataLength(extra, @backingInt(i), TargetQuery); } pub fn get(this: @This(), c: *const Configuration) TargetQuery { - return extraData(c, TargetQuery, @intFromEnum(this)); + return extraData(c, TargetQuery, @backingInt(this)); } }; @@ -2236,7 +2236,7 @@ pub const TargetQuery = struct { _, pub fn init(i: Index) OptionalIndex { - const result: OptionalIndex = @enumFromInt(@intFromEnum(i)); + const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i))); assert(result != .none); return result; } @@ -2244,7 +2244,7 @@ pub const TargetQuery = struct { pub fn unwrap(this: @This()) ?Index { return switch (this) { .none => null, - _ => @enumFromInt(@intFromEnum(this)), + _ => @fromBackingInt(@intCast(@backingInt(this))), }; } @@ -2927,7 +2927,7 @@ pub const Storage = enum { pub const storage: Storage = .extended; pub fn tag(this: @This(), c: *const Configuration) @FieldType(BaseFlags, "tag") { - const base_flags: BaseFlags = @bitCast(c.extra[@intFromEnum(this)]); + const base_flags: BaseFlags = @bitCast(c.extra[@backingInt(this)]); return base_flags.tag; } @@ -2936,14 +2936,14 @@ pub const Storage = enum { const info = @typeInfo(S.Flags).@"struct"; break :blk info.field_attrs[0].defaultValue(info.field_types[0]).?; }; - const base_flags: BaseFlags = @bitCast(c.extra[@intFromEnum(this)]); + const base_flags: BaseFlags = @bitCast(c.extra[@backingInt(this)]); if (base_flags.tag != wanted_tag) return null; - var i: usize = @intFromEnum(this); + var i: usize = @backingInt(this); return data(c.extra, &i, S); } pub fn get(this: @This(), buffer: []const u32) U { - var i: usize = @intFromEnum(this); + var i: usize = @backingInt(this); const base_flags: BaseFlags = @bitCast(buffer[i]); return switch (base_flags.tag) { inline else => |t| @unionInit(U, @tagName(t), data(buffer, &i, @FieldType(U, @tagName(t)))), @@ -3071,7 +3071,7 @@ pub const Storage = enum { pub fn get(this: *const @This(), extra: []const u32, i: usize) Union { const elem = slice(this, extra)[i]; return switch (this.tag(extra, i)) { - inline else => |comptime_tag| @unionInit(Union, @tagName(comptime_tag), @enumFromInt(elem)), + inline else => |comptime_tag| @unionInit(Union, @tagName(comptime_tag), @fromBackingInt(@intCast(elem))), }; } @@ -3109,7 +3109,7 @@ pub const Storage = enum { inline else => |comptime_tag| @unionInit( T, @tagName(comptime_tag), - data(buffer, i, info.field_types[@intFromEnum(comptime_tag)]), + data(buffer, i, info.field_types[@backingInt(comptime_tag)]), ), }; }, @@ -3133,7 +3133,7 @@ pub const Storage = enum { }, .@"enum" => { defer i.* += 1; - return @enumFromInt(buffer[i.*]); + return @fromBackingInt(@intCast(buffer[i.*])); }, .@"struct" => |info| switch (info.layout) { .@"packed" => switch (info.backing_integer.?) { @@ -3176,7 +3176,7 @@ pub const Storage = enum { buffer, i, container, - @typeInfo(Field.Union).@"union".field_types[@intFromEnum(comptime_tag)], + @typeInfo(Field.Union).@"union".field_types[@backingInt(comptime_tag)], ), ), }, @@ -3324,7 +3324,7 @@ pub const Storage = enum { else => comptime unreachable, }, .@"enum" => { - buffer[i] = @intFromEnum(value); + buffer[i] = @backingInt(value); return 1; }, .@"struct" => |info| switch (info.layout) { @@ -3379,7 +3379,7 @@ pub const Storage = enum { const field_names = @typeInfo(Field.Elem).@"struct".field_names; inline for (0..field_names.len) |field_i| @memcpy( buffer[i + 1 + field_i * len ..][0..len], - @as([]const u32, @ptrCast(value.mal.items(@enumFromInt(field_i)))), + @as([]const u32, @ptrCast(value.mal.items(@fromBackingInt(@intCast(field_i))))), ); return 1 + field_names.len * len; }, @@ -3429,7 +3429,7 @@ fn IndexType(comptime T: type) type { _, pub fn get(this: @This(), c: *const Configuration) T { - return extraData(c, T, @intFromEnum(this)); + return extraData(c, T, @backingInt(this)); } }; } diff --git a/lib/std/Build/Serialize.zig b/lib/std/Build/Serialize.zig index 2ed27fca2f1b3a623e80d1b123e0284123b5b9cd..8849f7aaeec31bf6093f3ee60ec48ba2376f026d 100644 --- a/lib/std/Build/Serialize.zig +++ b/lib/std/Build/Serialize.zig @@ -75,7 +75,7 @@ pub fn write(b: *std.Build, wc: *Configuration.Wip, writer: *std.Io.Writer) !voi // Add and then de-duplicate dependencies. const dep_steps = try arena.alloc(Configuration.Step.Index, step.dependencies.items.len); for (dep_steps, step.dependencies.items) |*dest, src| - dest.* = @enumFromInt(s.step_map.getIndex(src).?); + dest.* = @fromBackingInt(@intCast(s.step_map.getIndex(src).?)); const deps: Configuration.Deps.Index = try wc.addDeduped(Configuration.Deps, .{ .steps = .{ .slice = dep_steps }, @@ -87,7 +87,7 @@ pub fn write(b: *std.Build, wc: *Configuration.Wip, writer: *std.Io.Writer) !voi .owner = try s.builderToPackage(step.owner), .deps = deps, .max_rss = .fromBytes(step.max_rss), - .extended = @enumFromInt(switch (step.tag) { + .extended = @fromBackingInt(@intCast(switch (step.tag) { .top_level => e: { const top_level: *Step.TopLevel = @fieldParentPtr("step", step); break :e try wc.addExtraErased(Configuration.Step.TopLevel, .{ @@ -445,8 +445,8 @@ pub fn write(b: *std.Build, wc: *Configuration.Wip, writer: *std.Io.Writer) !voi }, .expect_term => |t| expect_term = switch (t) { .exited => |x| .{ .status = .exited, .value = x }, - .signal => |x| .{ .status = .signal, .value = @intFromEnum(x) }, - .stopped => |x| .{ .status = .stopped, .value = @intFromEnum(x) }, + .signal => |x| .{ .status = .signal, .value = @backingInt(x) }, + .stopped => |x| .{ .status = .stopped, .value = @backingInt(x) }, .unknown => |x| .{ .status = .unknown, .value = x }, }, .expect_stderr_snapshot => |path| expect_stderr_snapshot = try s.addLazyPath(path), @@ -656,7 +656,7 @@ pub fn write(b: *std.Build, wc: *Configuration.Wip, writer: *std.Io.Writer) !voi .args = .{ .slice = args }, }); }, - }), + })), }); } } @@ -734,7 +734,7 @@ fn builderToPackage(s: *Serialize, b: *std.Build) !Configuration.Package.Index { fn addOptionalLazyPathEnum(s: *Serialize, lp: ?std.Build.LazyPath) !Configuration.LazyPath.OptionalIndex { const wc = s.wc; - return @enumFromInt(switch (lp orelse return .none) { + return @fromBackingInt(@intCast(switch (lp orelse return .none) { .src_path => |src_path| i: { const sub_path = try wc.addString(src_path.sub_path); break :i try wc.addExtraErased(Configuration.LazyPath.SourcePath, .{ @@ -770,7 +770,7 @@ fn addOptionalLazyPathEnum(s: *Serialize, lp: ?std.Build.LazyPath) !Configuratio .sub_path = sub_path, }); }, - }); + })); } fn addOptionalLazyPath(s: *Serialize, lp: ?std.Build.LazyPath) !?Configuration.LazyPath.Index { @@ -778,7 +778,7 @@ fn addOptionalLazyPath(s: *Serialize, lp: ?std.Build.LazyPath) !?Configuration.L } fn addLazyPath(s: *Serialize, lp: std.Build.LazyPath) !Configuration.LazyPath.Index { - return @enumFromInt(@intFromEnum(try addOptionalLazyPathEnum(s, lp))); + return @fromBackingInt(@intCast(@backingInt(try addOptionalLazyPathEnum(s, lp)))); } fn addOptionalSemVer(s: *Serialize, sem_ver: ?std.SemanticVersion) !?Configuration.String { @@ -1163,17 +1163,17 @@ fn addModule(s: *Serialize, m: *std.Build.Module) !Configuration.Module.Index { comptime assert(std.mem.eql(u8, @typeInfo(Configuration.Module).@"struct".field_names[2], "import_table")); comptime assert(@typeInfo(Configuration.Module).@"struct".field_types[2] == Configuration.ImportTable.Index); - assert(wc.extra.items[@intFromEnum(module_index) + 2] == @intFromEnum(Configuration.ImportTable.Index.invalid)); + assert(wc.extra.items[@backingInt(module_index) + 2] == @backingInt(Configuration.ImportTable.Index.invalid)); const import_table_index = try wc.addDeduped(Configuration.ImportTable, .{ .imports = .{ .mal = imports }, }); - wc.extra.items[@intFromEnum(module_index) + 2] = @intFromEnum(import_table_index); + wc.extra.items[@backingInt(module_index) + 2] = @backingInt(import_table_index); return module_index; } fn stepIndex(s: *const Serialize, step: *Step) Configuration.Step.Index { - return @enumFromInt(s.step_map.getIndex(step).?); + return @fromBackingInt(@intCast(s.step_map.getIndex(step).?)); } fn addOptionalResolvedTarget( diff --git a/lib/std/Build/abi.zig b/lib/std/Build/abi.zig index d0c56bd1a7529d484525f3da5a532fe41785c049..c28d8c79b6cea8943ea06017929fd0614ff543c3 100644 --- a/lib/std/Build/abi.zig +++ b/lib/std/Build/abi.zig @@ -265,7 +265,7 @@ pub const fuzz = struct { return switch (@typeInfo(T)) { .comptime_int => x, .bool => @intFromBool(x), - .@"enum" => @intFromEnum(x), + .@"enum" => @backingInt(x), else => @as(@Int(.unsigned, @bitSizeOf(T)), @bitCast(x)), .int => |i| x: { diff --git a/lib/std/Io.zig b/lib/std/Io.zig index 50d1ebc21c8a6e511ba6c733219311a747a93ef6..a680c9d198583eac1b1969d6e92c8ae1065886c3 100644 --- a/lib/std/Io.zig +++ b/lib/std/Io.zig @@ -437,14 +437,14 @@ pub const Operation = union(enum) { _, pub fn fromIndex(i: usize) OptionalIndex { - const oi: OptionalIndex = @enumFromInt(i); + const oi: OptionalIndex = @fromBackingInt(@intCast(i)); assert(oi != .none); return oi; } pub fn toIndex(oi: OptionalIndex) u32 { assert(oi != .none); - return @intFromEnum(oi); + return @backingInt(oi); } }; pub const List = struct { @@ -640,13 +640,13 @@ pub const Limit = enum(usize) { /// `math.maxInt(usize)` is interpreted to mean `.unlimited`. pub fn limited(n: usize) Limit { - return @enumFromInt(n); + return @fromBackingInt(@intCast(n)); } /// Any value grater than `math.maxInt(usize)` is interpreted to mean /// `.unlimited`. pub fn limited64(n: u64) Limit { - return @enumFromInt(@min(n, math.maxInt(usize))); + return @fromBackingInt(@intCast(@min(n, math.maxInt(usize)))); } pub fn countVec(data: []const []const u8) Limit { @@ -656,7 +656,7 @@ pub const Limit = enum(usize) { } pub fn min(a: Limit, b: Limit) Limit { - return @enumFromInt(@min(@intFromEnum(a), @intFromEnum(b))); + return @fromBackingInt(@intCast(@min(@backingInt(a), @backingInt(b)))); } pub fn max(a: Limit, b: Limit) Limit { @@ -664,15 +664,15 @@ pub const Limit = enum(usize) { return .unlimited; } - return @enumFromInt(@max(@intFromEnum(a), @intFromEnum(b))); + return @fromBackingInt(@intCast(@max(@backingInt(a), @backingInt(b)))); } pub fn minInt(l: Limit, n: usize) usize { - return @min(n, @intFromEnum(l)); + return @min(n, @backingInt(l)); } pub fn minInt64(l: Limit, n: u64) usize { - return @min(n, @intFromEnum(l)); + return @min(n, @backingInt(l)); } pub fn slice(l: Limit, s: []u8) []u8 { @@ -685,14 +685,14 @@ pub const Limit = enum(usize) { pub fn toInt(l: Limit) ?usize { return switch (l) { - else => @intFromEnum(l), + else => @backingInt(l), .unlimited => null, }; } pub fn toInt64(l: Limit) ?u64 { return switch (l) { - else => @intFromEnum(l), + else => @backingInt(l), .unlimited => null, }; } @@ -702,7 +702,7 @@ pub const Limit = enum(usize) { /// between end-of-stream and reaching the limit. pub fn slice1(l: Limit, non_empty_buffer: []u8) []u8 { assert(non_empty_buffer.len >= 1); - return non_empty_buffer[0..@min(@intFromEnum(l) +| 1, non_empty_buffer.len)]; + return non_empty_buffer[0..@min(@backingInt(l) +| 1, non_empty_buffer.len)]; } pub fn nonzero(l: Limit) bool { @@ -713,8 +713,8 @@ pub const Limit = enum(usize) { /// limit would be exceeded. pub fn subtract(l: Limit, amount: usize) ?Limit { if (l == .unlimited) return .unlimited; - if (amount > @intFromEnum(l)) return null; - return @enumFromInt(@intFromEnum(l) - amount); + if (amount > @backingInt(l)) return null; + return @fromBackingInt(@intCast(@backingInt(l) - amount)); } }; @@ -1583,7 +1583,7 @@ pub fn futexWait(io: Io, comptime T: type, ptr: *align(@alignOf(u32)) const T, e /// three possible wake-up reasons if necessary. pub fn futexWaitTimeout(io: Io, comptime T: type, ptr: *align(@alignOf(u32)) const T, expected: T, timeout: Timeout) Cancelable!void { const expected_int: u32 = switch (@typeInfo(T)) { - .@"enum" => @bitCast(@intFromEnum(expected)), + .@"enum" => @bitCast(@backingInt(expected)), else => @bitCast(expected), }; return io.vtable.futexWait(io.userdata, @ptrCast(ptr), expected_int, timeout); @@ -1593,7 +1593,7 @@ pub fn futexWaitTimeout(io: Io, comptime T: type, ptr: *align(@alignOf(u32)) con /// For a description of cancelation and cancelation points, see `Future.cancel`. pub fn futexWaitUncancelable(io: Io, comptime T: type, ptr: *align(@alignOf(u32)) const T, expected: T) void { const expected_int: u32 = switch (@typeInfo(T)) { - .@"enum" => @bitCast(@intFromEnum(expected)), + .@"enum" => @bitCast(@backingInt(expected)), else => @bitCast(expected), }; io.vtable.futexWaitUncancelable(io.userdata, @ptrCast(ptr), expected_int); diff --git a/lib/std/Io/Dispatch.zig b/lib/std/Io/Dispatch.zig index 851ed34156737103639d12f03170e74bd2500e79..438ee0d31b4bb907690c3f355a16d10392b1b60f 100644 --- a/lib/std/Io/Dispatch.zig +++ b/lib/std/Io/Dispatch.zig @@ -124,15 +124,15 @@ const Fiber = struct { const shift = 1; fn subWrap(lhs: Awaiting, rhs: Awaiting) Awaiting { - return @enumFromInt(@intFromEnum(lhs) -% @intFromEnum(rhs)); + return @fromBackingInt(@intCast(@backingInt(lhs) -% @backingInt(rhs))); } fn fromCancelable(cancelable: *Cancelable) Awaiting { - return @enumFromInt(@shrExact(@intFromPtr(cancelable), shift)); + return @fromBackingInt(@intCast(@shrExact(@intFromPtr(cancelable), shift))); } fn toCancelable(awaiting: Awaiting) *Cancelable { - return @ptrFromInt(@shlExact(@as(usize, @intFromEnum(awaiting)), shift)); + return @ptrFromInt(@shlExact(@as(usize, @backingInt(awaiting)), shift)); } }; @@ -157,7 +157,7 @@ const Fiber = struct { const unblocked: CancelProtection = .{ .user = .unblocked, .acknowledged = false }; fn check(cancel_protection: CancelProtection) Io.CancelProtection { - return @enumFromInt(@intFromBool(cancel_protection != unblocked)); + return @fromBackingInt(@intCast(@intFromBool(cancel_protection != unblocked))); } fn acknowledge(cancel_protection: *CancelProtection) void { @@ -1892,7 +1892,7 @@ fn deviceIoControl(o: *const Io.Operation.DeviceIoControl) Io.Cancelable!i32 { switch (c.errno(rc)) { .SUCCESS => return rc, .INTR => {}, - else => |err| return -@as(i32, @intFromEnum(err)), + else => |err| return -@as(i32, @backingInt(err)), } } } @@ -2805,7 +2805,7 @@ fn dirRealPathFile( assert(redundant_pointer == out_buffer.ptr); return std.mem.indexOfScalar(u8, out_buffer, 0) orelse out_buffer.len; } - const err: c.E = @enumFromInt(c._errno().*); + const err: c.E = @fromBackingInt(@intCast(c._errno().*)); switch (err) { .INTR => {}, .INVAL => return errnoBug(err), @@ -3347,12 +3347,12 @@ fn fileWriteFileStreaming( ) File.Writer.WriteFileError!usize { const ev: *Evented = @ptrCast(@alignCast(userdata)); const reader_buffered = file_reader.interface.buffered(); - if (reader_buffered.len >= @intFromEnum(limit)) { + if (reader_buffered.len >= @backingInt(limit)) { const n = try fileWriteStreaming(ev, file, header, &.{limit.slice(reader_buffered)}, 1); file_reader.interface.toss(n -| header.len); return n; } - const file_limit = @intFromEnum(limit) - reader_buffered.len; + const file_limit = @backingInt(limit) - reader_buffered.len; const out_fd = file.handle; const in_fd = file_reader.file.handle; @@ -3441,7 +3441,7 @@ fn fileWriteFilePositional( ) File.WriteFilePositionalError!usize { const ev: *Evented = @ptrCast(@alignCast(userdata)); const reader_buffered = file_reader.interface.buffered(); - if (reader_buffered.len >= @intFromEnum(limit)) { + if (reader_buffered.len >= @backingInt(limit)) { const n = try fileWritePositional( ev, file, @@ -3866,7 +3866,7 @@ fn fileMemoryMapCreate( const contents = while (true) { const casted_offset = std.math.cast(i64, options.offset) orelse return error.Unseekable; const rc = c.mmap(null, options.len, prot, flags, file.handle, casted_offset); - const err: c.E = if (rc != c.MAP_FAILED) .SUCCESS else @enumFromInt(c._errno().*); + const err: c.E = if (rc != c.MAP_FAILED) .SUCCESS else @fromBackingInt(@intCast(c._errno().*)); switch (err) { .SUCCESS => break @as([*]align(page_align) u8, @ptrCast(@alignCast(rc)))[0..options.len], .INTR => {}, @@ -4026,7 +4026,7 @@ fn unlockStderr(userdata: ?*anyopaque) void { fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathError!usize { const ev: *Evented = @ptrCast(@alignCast(userdata)); _ = ev; - const err: c.E = if (c.getcwd(buffer.ptr, buffer.len)) |_| .SUCCESS else @enumFromInt(c._errno().*); + const err: c.E = if (c.getcwd(buffer.ptr, buffer.len)) |_| .SUCCESS else @fromBackingInt(@intCast(c._errno().*)); switch (err) { .SUCCESS => return std.mem.findScalar(u8, buffer, 0).?, .NOENT => return error.CurrentDirUnlinked, diff --git a/lib/std/Io/File.zig b/lib/std/Io/File.zig index 9dee99c86241d1490658e72d621816c4dedff197..ace3812ca20d720b3d9647029ac4e7d06e8dbd52 100644 --- a/lib/std/Io/File.zig +++ b/lib/std/Io/File.zig @@ -340,7 +340,7 @@ pub const Permissions = std.Options.FilePermissions orelse if (is_windows) enum( const windows = std.os.windows; pub fn toAttributes(self: @This()) windows.FILE.ATTRIBUTE { - return @bitCast(@intFromEnum(self)); + return @bitCast(@backingInt(self)); } pub fn readOnly(self: @This()) bool { @@ -350,10 +350,10 @@ pub const Permissions = std.Options.FilePermissions orelse if (is_windows) enum( pub fn setReadOnly(self: @This(), read_only: bool) @This() { const attributes = toAttributes(self); - return @enumFromInt(if (read_only) + return @fromBackingInt(@intCast(if (read_only) attributes | windows.FILE_ATTRIBUTE_READONLY else - attributes & ~@as(windows.DWORD, windows.FILE_ATTRIBUTE_READONLY)); + attributes & ~@as(windows.DWORD, windows.FILE_ATTRIBUTE_READONLY))); } } else if (std.posix.mode_t != u0) enum(std.posix.mode_t) { /// This is the default mode given to POSIX operating systems for creating @@ -375,11 +375,11 @@ pub const Permissions = std.Options.FilePermissions orelse if (is_windows) enum( pub const executable_file: @This() = .default_dir; pub fn toMode(self: @This()) std.posix.mode_t { - return @intFromEnum(self); + return @backingInt(self); } pub fn fromMode(mode: std.posix.mode_t) @This() { - return @enumFromInt(mode); + return @fromBackingInt(@intCast(mode)); } /// Returns `true` if and only if no class has write permissions. @@ -392,7 +392,7 @@ pub const Permissions = std.Options.FilePermissions orelse if (is_windows) enum( pub fn setReadOnly(self: @This(), read_only: bool) @This() { const mode = toMode(self); const o222 = @as(std.posix.mode_t, 0o222); - return @enumFromInt(if (read_only) mode & ~o222 else mode | o222); + return @fromBackingInt(@intCast(if (read_only) mode & ~o222 else mode | o222)); } } else enum(u0) { default_file = 0, diff --git a/lib/std/Io/File/Reader.zig b/lib/std/Io/File/Reader.zig index fb4c47869590293e475af373f8298654592848d0..ca442bf54a1d0653e20e7afff3a682880eae90a5 100644 --- a/lib/std/Io/File/Reader.zig +++ b/lib/std/Io/File/Reader.zig @@ -311,7 +311,7 @@ fn discard(io_reader: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize { const logical_pos = logicalPos(r); const bytes_remaining = size - logical_pos; if (bytes_remaining == 0) return error.EndOfStream; - const delta = @min(@intFromEnum(limit), bytes_remaining); + const delta = @min(@backingInt(limit), bytes_remaining); setLogicalPos(r, logical_pos + delta); return delta; }, @@ -324,7 +324,7 @@ fn discard(io_reader: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize { if (r.size_err == null and r.seek_err == null) break :fallback; const buffered_len = r.interface.bufferedLen(); - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); if (remaining <= buffered_len) { r.interface.seek += remaining; return remaining; @@ -356,10 +356,10 @@ fn discard(io_reader: *Io.Reader, limit: Io.Limit) Io.Reader.Error!usize { } else { remaining -= n; } - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } const size = r.getSize() catch return 0; - const n = @min(size - r.pos, std.math.maxInt(i64), @intFromEnum(limit)); + const n = @min(size - r.pos, std.math.maxInt(i64), @backingInt(limit)); io.vtable.fileSeekBy(io.userdata, file, n) catch |err| { r.seek_err = err; return 0; diff --git a/lib/std/Io/Kqueue.zig b/lib/std/Io/Kqueue.zig index 45e49b0f0cadf89efee58186ac08d71f2739cfce..d34d4132a1a37646303191831a3c050cd579c500 100644 --- a/lib/std/Io/Kqueue.zig +++ b/lib/std/Io/Kqueue.zig @@ -332,7 +332,7 @@ fn schedule(k: *Kqueue, thread: *Thread, ready_queue: Fiber.Queue) void { .flags = std.c.EV.ADD | std.c.EV.ONESHOT, .fflags = std.c.NOTE.TRIGGER, .data = 0, - .udata = @intFromEnum(Completion.UserData.wakeup), + .udata = @backingInt(Completion.UserData.wakeup), }, }; // If an error occurs it only pessimises scheduling. @@ -439,7 +439,7 @@ fn idle(k: *Kqueue, thread: *Thread) void { @panic(@errorName(err)); // TODO }; var maybe_ready_queue: ?Fiber.Queue = null; - for (events_buffer[0..n]) |event| switch (@as(Completion.UserData, @enumFromInt(event.udata))) { + for (events_buffer[0..n]) |event| switch (@as(Completion.UserData, @fromBackingInt(@intCast(event.udata)))) { .unused => unreachable, // bad submission queued? .wakeup => {}, .cleanup => @panic("failed to notify other threads that we are exiting"), @@ -522,7 +522,7 @@ const SwitchMessage = struct { .flags = std.c.EV.ADD | std.c.EV.ONESHOT, .fflags = std.c.NOTE.TRIGGER, .data = 0, - .udata = @intFromEnum(Completion.UserData.exit), + .udata = @backingInt(Completion.UserData.exit), }, }; _ = kevent(each_thread.kq_fd, &changes, &.{}, null) catch |err| { diff --git a/lib/std/Io/Reader.zig b/lib/std/Io/Reader.zig index 7e5a70518da53bb20d8723d401b98c82eec7dd20..68cae96c836d7cab147c327afd06588c118d784c 100644 --- a/lib/std/Io/Reader.zig +++ b/lib/std/Io/Reader.zig @@ -174,7 +174,7 @@ pub fn stream(r: *Reader, w: *Writer, limit: Limit) StreamError!usize { return n; } const n = try r.vtable.stream(r, w, limit); - assert(n <= @intFromEnum(limit)); + assert(n <= @backingInt(limit)); return n; } @@ -189,7 +189,7 @@ pub fn discard(r: *Reader, limit: Limit) Error!usize { } else .unlimited; r.seek = r.end; const n = try r.vtable.discard(r, remaining); - assert(n <= @intFromEnum(remaining)); + assert(n <= @backingInt(remaining)); return buffered_len + n; } @@ -204,11 +204,11 @@ pub fn defaultDiscard(r: *Reader, limit: Limit) Error!usize { }; // If `stream` wrote to `r.buffer` without going through the writer, // we need to discard as much of the buffered data as possible. - const remaining = @intFromEnum(limit) - n; + const remaining = @backingInt(limit) - n; const buffered_n_to_discard = @min(remaining, r.end - r.seek); n += buffered_n_to_discard; r.seek += buffered_n_to_discard; - assert(n <= @intFromEnum(limit)); + assert(n <= @backingInt(limit)); return n; } @@ -1010,17 +1010,17 @@ pub fn streamDelimiterLimit( delimiter: u8, limit: Limit, ) StreamDelimiterLimitError!usize { - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); while (remaining != 0) { const available = Limit.limited(remaining).slice(r.peekGreedy(1) catch |err| switch (err) { error.ReadFailed => |e| return e, - error.EndOfStream => return @intFromEnum(limit) - remaining, + error.EndOfStream => return @backingInt(limit) - remaining, }); if (std.mem.findScalar(u8, available, delimiter)) |delimiter_index| { try w.writeAll(available[0..delimiter_index]); r.toss(delimiter_index); remaining -= delimiter_index; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } try w.writeAll(available); r.toss(available.len); @@ -1081,16 +1081,16 @@ pub const DiscardDelimiterLimitError = error{ /// Succeeds if stream ends before delimiter found. End of stream can be /// detected by checking if the delimiter is buffered. pub fn discardDelimiterLimit(r: *Reader, delimiter: u8, limit: Limit) DiscardDelimiterLimitError!usize { - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); while (remaining != 0) { const available = Limit.limited(remaining).slice(r.peekGreedy(1) catch |err| switch (err) { error.ReadFailed => |e| return e, - error.EndOfStream => return @intFromEnum(limit) - remaining, + error.EndOfStream => return @backingInt(limit) - remaining, }); if (std.mem.findScalar(u8, available, delimiter)) |delimiter_index| { r.toss(delimiter_index); remaining -= delimiter_index; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } r.toss(available.len); remaining -= available.len; @@ -1704,7 +1704,7 @@ test takeEnum { const E1 = enum(u8) { a, b, c }; const E2 = enum(u16) { _ }; try testing.expectEqual(E1.c, try r.takeEnum(E1, .little)); - try testing.expectEqual(@as(E2, @enumFromInt(0x0001)), try r.takeEnum(E2, .big)); + try testing.expectEqual(@as(E2, @fromBackingInt(@intCast(0x0001))), try r.takeEnum(E2, .big)); } test readSliceShort { diff --git a/lib/std/Io/Reader/Limited.zig b/lib/std/Io/Reader/Limited.zig index d9831333072d650427fbf6662f50bea585cf54bb..bc372de06b1e023638f648c8cbd7533f3fd7dec3 100644 --- a/lib/std/Io/Reader/Limited.zig +++ b/lib/std/Io/Reader/Limited.zig @@ -40,11 +40,11 @@ test stream { var fixed: std.Io.Reader = .fixed(&orig_buf); var limit_buf: [1]u8 = undefined; - var limited: std.Io.Reader.Limited = .init(&fixed, @enumFromInt(4), &limit_buf); + var limited: std.Io.Reader.Limited = .init(&fixed, @fromBackingInt(@intCast(4)), &limit_buf); var result_buf: [10]u8 = undefined; var fixed_writer: std.Io.Writer = .fixed(&result_buf); - const streamed = try limited.interface.stream(&fixed_writer, @enumFromInt(7)); + const streamed = try limited.interface.stream(&fixed_writer, @fromBackingInt(@intCast(7))); try std.testing.expect(streamed == 4); try std.testing.expectEqualStrings("test", result_buf[0..streamed]); diff --git a/lib/std/Io/Threaded.zig b/lib/std/Io/Threaded.zig index 8b4ba775b6443e570ac9dbeb558c6d249f880c48..b02453c1e34cacd3f5b8417156a63022d11f8a89 100644 --- a/lib/std/Io/Threaded.zig +++ b/lib/std/Io/Threaded.zig @@ -581,7 +581,7 @@ const Group = struct { var it = t.worker_threads.load(.acquire); // acquire `Thread` values while (it) |thread| : (it = thread.next) { // This non-mutating RMW exists for ordering reasons: see comment in `Group.Task.start` for reasons. - _ = thread.status.fetchOr(.{ .cancelation = @enumFromInt(0), .awaitable = .null }, .release); + _ = thread.status.fetchOr(.{ .cancelation = @fromBackingInt(@intCast(0)), .awaitable = .null }, .release); if (thread.cancelAwaitable(.fromGroup(g.ptr))) any_blocked = true; } return any_blocked; @@ -1019,7 +1019,7 @@ const Thread = struct { }; syscall.finish(); if (status >= 0) return; - switch (@as(c.E, @enumFromInt(-status))) { + switch (@as(c.E, @fromBackingInt(@intCast(-status)))) { .INTR => {}, // spurious wake // Address of the futex was paged out. This is unlikely, but possible in theory, and // pthread/libdispatch on darwin bother to handle it. In this case we'll return @@ -1030,7 +1030,7 @@ const Thread = struct { } }, .freebsd => { - const flags = @intFromEnum(std.c.UMTX_OP.WAIT_UINT_PRIVATE); + const flags = @backingInt(std.c.UMTX_OP.WAIT_UINT_PRIVATE); var tm_size: usize = 0; var tm: std.c._umtx_time = undefined; var tm_ptr: ?*const std.c._umtx_time = null; @@ -1147,7 +1147,7 @@ const Thread = struct { while (true) { const status = c.__ulock_wake(flags, ptr, 0); if (status >= 0) return; - switch (@as(c.E, @enumFromInt(-status))) { + switch (@as(c.E, @fromBackingInt(@intCast(-status)))) { .INTR, .CANCELED => continue, // spurious wake() .FAULT => unreachable, // __ulock_wake doesn't generate EFAULT according to darwin pthread_cond_t .NOENT => return, // nothing was woken up @@ -1159,7 +1159,7 @@ const Thread = struct { .freebsd => { const rc = std.c._umtx_op( @intFromPtr(ptr), - @intFromEnum(std.c.UMTX_OP.WAKE_PRIVATE), + @backingInt(std.c.UMTX_OP.WAKE_PRIVATE), @as(c_ulong, @min(max_waiters, std.math.maxInt(c_int))), 0, // there is no timeout struct 0, // there is no timeout struct pointer @@ -1283,9 +1283,9 @@ const Thread = struct { .linux => { const pid: posix.pid_t = pid: { const cached_pid = @atomicLoad(Pid, &t.pid, .monotonic); - if (cached_pid != .unknown) break :pid @intFromEnum(cached_pid); + if (cached_pid != .unknown) break :pid @backingInt(cached_pid); const pid = std.os.linux.getpid(); - @atomicStore(Pid, &t.pid, @enumFromInt(pid), .monotonic); + @atomicStore(Pid, &t.pid, @fromBackingInt(@intCast(pid)), .monotonic); break :pid pid; }; return switch (std.os.linux.tgkill(pid, @bitCast(thread.id), .IO)) { @@ -1352,7 +1352,7 @@ const Syscall = struct { .unblocked => {}, } switch (thread.status.fetchOr(.{ - .cancelation = @enumFromInt(0b011), + .cancelation = @fromBackingInt(@intCast(0b011)), .awaitable = .null, }, .monotonic).cancelation) { .parked => unreachable, @@ -1372,7 +1372,7 @@ const Syscall = struct { fn checkCancel(s: Syscall) Io.Cancelable!void { const thread = s.thread orelse return; switch (thread.status.fetchOr(.{ - .cancelation = @enumFromInt(0b010), + .cancelation = @fromBackingInt(@intCast(0b010)), .awaitable = .null, }, .monotonic).cancelation) { .none => unreachable, @@ -1389,7 +1389,7 @@ const Syscall = struct { fn finish(s: Syscall) void { const thread = s.thread orelse return; switch (thread.status.fetchXor(.{ - .cancelation = @enumFromInt(0b011), + .cancelation = @fromBackingInt(@intCast(0b011)), .awaitable = .null, }, .monotonic).cancelation) { .none => unreachable, @@ -1474,7 +1474,7 @@ const AlertableSyscall = struct { .unblocked => {}, } const old_status = thread.status.fetchOr(.{ - .cancelation = @enumFromInt(0b010), + .cancelation = @fromBackingInt(@intCast(0b010)), .awaitable = .null, }, .monotonic); switch (old_status.cancelation) { @@ -1497,7 +1497,7 @@ const AlertableSyscall = struct { comptime assert(is_windows); const thread = s.thread orelse return; const old_status = thread.status.fetchOr(.{ - .cancelation = @enumFromInt(0b010), + .cancelation = @fromBackingInt(@intCast(0b010)), .awaitable = .null, }, .monotonic); switch (old_status.cancelation) { @@ -1520,7 +1520,7 @@ const AlertableSyscall = struct { comptime assert(is_windows); const thread = s.thread orelse return; switch (thread.status.fetchXor(.{ - .cancelation = @enumFromInt(0b010), + .cancelation = @fromBackingInt(@intCast(0b010)), .awaitable = .null, }, .monotonic).cancelation) { .none => unreachable, @@ -2094,7 +2094,7 @@ fn async( const busy_count = t.busy_count; - if (busy_count >= @intFromEnum(t.async_limit)) { + if (busy_count >= @backingInt(t.async_limit)) { mutexUnlock(&t.mutex); future.destroy(gpa); start(context.ptr, result.ptr); @@ -2147,7 +2147,7 @@ fn concurrent( const busy_count = t.busy_count; - if (busy_count >= @intFromEnum(t.concurrent_limit)) + if (busy_count >= @backingInt(t.concurrent_limit)) return error.ConcurrencyUnavailable; t.busy_count = busy_count + 1; @@ -2191,7 +2191,7 @@ fn groupAsync( const busy_count = t.busy_count; - if (busy_count >= @intFromEnum(t.async_limit)) { + if (busy_count >= @backingInt(t.async_limit)) { mutexUnlock(&t.mutex); task.destroy(gpa); return groupAsyncEager(start, context.ptr); @@ -2255,7 +2255,7 @@ fn groupConcurrent( const busy_count = t.busy_count; - if (busy_count >= @intFromEnum(t.concurrent_limit)) + if (busy_count >= @backingInt(t.concurrent_limit)) return error.ConcurrencyUnavailable; t.busy_count = busy_count + 1; @@ -2382,7 +2382,7 @@ fn recancel(userdata: ?*anyopaque) void { fn recancelInner() void { const thread = Thread.current.?; // called `recancel` but was not canceled switch (thread.status.fetchXor(.{ - .cancelation = @enumFromInt(0b001), + .cancelation = @fromBackingInt(@intCast(0b001)), .awaitable = .null, }, .monotonic).cancelation) { .canceled => {}, @@ -5347,7 +5347,7 @@ fn dirOpenDirHaiku( syscall.finish(); return .{ .handle = rc }; } - switch (@as(posix.E, @enumFromInt(rc))) { + switch (@as(posix.E, @fromBackingInt(@intCast(rc)))) { .INTR => { try syscall.checkCancel(); continue; @@ -5826,7 +5826,7 @@ fn dirReadHaiku(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir const syscall: Syscall = try .start(); while (true) { const rc = posix.system._kern_rewind_dir(dr.dir.handle); - switch (@as(posix.E, @enumFromInt(@min(rc, 0)))) { + switch (@as(posix.E, @fromBackingInt(@intCast(@min(rc, 0))))) { .SUCCESS => { syscall.finish(); break; @@ -5848,7 +5848,7 @@ fn dirReadHaiku(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir const syscall: Syscall = try .start(); const n: usize = while (true) { const rc = posix.system._kern_read_dir(dr.dir.handle, dr.buffer.ptr, dr.buffer.len, @truncate(dr.buffer.len / @sizeOf(posix.system.DirEnt))); - switch (@as(posix.E, @enumFromInt(@min(rc, 0)))) { + switch (@as(posix.E, @fromBackingInt(@intCast(@min(rc, 0))))) { .SUCCESS => { syscall.finish(); break @intCast(rc); @@ -5891,7 +5891,7 @@ fn dirReadHaiku(userdata: ?*anyopaque, dr: *Dir.Reader, buffer: []Dir.Entry) Dir const syscall: Syscall = try .start(); while (true) { const rc = posix.system._kern_read_stat(dr.dir.handle, name, false, &stat, @sizeOf(std.c.Stat)); - switch (@as(posix.E, @enumFromInt(@min(rc, 0)))) { + switch (@as(posix.E, @fromBackingInt(@intCast(@min(rc, 0))))) { .SUCCESS => { syscall.finish(); break; @@ -6819,7 +6819,7 @@ fn dirRealPathFilePosix(userdata: ?*anyopaque, dir: Dir, sub_path: []const u8, o assert(redundant_pointer == out_buffer.ptr); return std.mem.indexOfScalar(u8, out_buffer, 0) orelse out_buffer.len; } - const err: posix.E = @enumFromInt(std.c._errno().*); + const err: posix.E = @fromBackingInt(@intCast(std.c._errno().*)); if (err == .INTR) { try syscall.checkCancel(); continue; @@ -10477,7 +10477,7 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut if (std.c.realpath(argv0, &resolved_buf)) |p| { assert(p == &resolved_buf); break syscall.finish(); - } else switch (@as(std.c.E, @enumFromInt(std.c._errno().*))) { + } else switch (@as(std.c.E, @fromBackingInt(@intCast(std.c._errno().*)))) { .INTR => { try syscall.checkCancel(); continue; @@ -10520,7 +10520,7 @@ fn processExecutablePath(userdata: ?*anyopaque, out_buffer: []u8) process.Execut if (std.c.realpath(resolved_path, &resolved_buf)) |p| { assert(p == &resolved_buf); break syscall.finish(); - } else switch (@as(std.c.E, @enumFromInt(std.c._errno().*))) { + } else switch (@as(std.c.E, @fromBackingInt(@intCast(std.c._errno().*)))) { .INTR => { try syscall.checkCancel(); continue; @@ -10979,12 +10979,12 @@ fn fileWriteFileStreaming( ) File.Writer.WriteFileError!usize { const t: *Threaded = @ptrCast(@alignCast(userdata)); const reader_buffered = file_reader.interface.buffered(); - if (reader_buffered.len >= @intFromEnum(limit)) { + if (reader_buffered.len >= @backingInt(limit)) { const n = try fileWriteStreaming(t, file, header, &.{limit.slice(reader_buffered)}, 1); file_reader.interface.toss(n -| header.len); return n; } - const file_limit = @intFromEnum(limit) - reader_buffered.len; + const file_limit = @backingInt(limit) - reader_buffered.len; const out_fd = file.handle; const in_fd = file_reader.file.handle; @@ -11186,7 +11186,7 @@ fn fileWriteFileStreaming( .positional => o: { const size = file_reader.getSize() catch return 0; off = std.math.cast(std.os.linux.off_t, file_reader.pos) orelse return error.ReadFailed; - break :o .{ &off, @min(@intFromEnum(limit), size - file_reader.pos, max_count) }; + break :o .{ &off, @min(@backingInt(limit), size - file_reader.pos, max_count) }; }, .streaming => .{ null, limit.minInt(max_count) }, .streaming_simple, .positional_simple => break :sf, @@ -11258,7 +11258,7 @@ fn fileWriteFileStreaming( file_reader.interface.toss(n -| header.len); return n; } - var len: usize = @intFromEnum(limit); + var len: usize = @backingInt(limit); var off_in: i64 = undefined; const off_in_ptr: ?*i64 = switch (file_reader.mode) { .positional_simple, .streaming_simple => return error.Unimplemented, @@ -11318,7 +11318,7 @@ fn fileWriteFileStreaming( .freebsd => n: { const syscall: Syscall = try .start(); while (true) { - const rc = std.c.copy_file_range(in_fd, off_in_ptr, out_fd, null, @intFromEnum(limit), 0); + const rc = std.c.copy_file_range(in_fd, off_in_ptr, out_fd, null, @backingInt(limit), 0); switch (std.c.errno(rc)) { .SUCCESS => { syscall.finish(); @@ -11392,7 +11392,7 @@ fn fileWriteFilePositional( ) File.WriteFilePositionalError!usize { const t: *Threaded = @ptrCast(@alignCast(userdata)); const reader_buffered = file_reader.interface.buffered(); - if (reader_buffered.len >= @intFromEnum(limit)) { + if (reader_buffered.len >= @backingInt(limit)) { const n = try fileWritePositional(t, file, header, &.{limit.slice(reader_buffered)}, 1, offset); file_reader.interface.toss(n -| header.len); return n; @@ -11419,7 +11419,7 @@ fn fileWriteFilePositional( file_reader.interface.toss(n -| header.len); return n; } - var len: usize = @min(@intFromEnum(limit), std.math.maxInt(usize) - offset); + var len: usize = @min(@backingInt(limit), std.math.maxInt(usize) - offset); var off_in: i64 = undefined; const off_in_ptr: ?*i64 = switch (file_reader.mode) { .positional_simple, .streaming_simple => return error.Unimplemented, @@ -11481,7 +11481,7 @@ fn fileWriteFilePositional( .freebsd => n: { const syscall: Syscall = try .start(); while (true) { - const rc = std.c.copy_file_range(in_fd, off_in_ptr, out_fd, &off_out, @intFromEnum(limit), 0); + const rc = std.c.copy_file_range(in_fd, off_in_ptr, out_fd, &off_out, @backingInt(limit), 0); switch (std.c.errno(rc)) { .SUCCESS => { syscall.finish(); @@ -11751,7 +11751,7 @@ fn sleepPosix(timeout: Io.Timeout) Io.Cancelable!void { .deadline => true, } }, ×pec, ×pec); // POSIX-standard libc clock_nanosleep() returns *positive* errno values directly - switch (if (builtin.link_libc) @as(posix.E, @enumFromInt(rc)) else posix.errno(rc)) { + switch (if (builtin.link_libc) @as(posix.E, @fromBackingInt(@intCast(rc))) else posix.errno(rc)) { .INTR => { try syscall.checkCancel(); continue; @@ -13525,7 +13525,7 @@ fn netInterfaceNameResolve( .INVALID_PARAMETER => unreachable, else => |err| return windows.unexpectedError(err), } - return .{ .index = @intFromEnum(index) }; + return .{ .index = @backingInt(index) }; } if (builtin.link_libc) { @@ -13588,7 +13588,7 @@ fn netInterfaceName(userdata: ?*anyopaque, interface: net.Interface) net.Interfa } try Thread.checkCancel(); var luid: windows.NET.LUID = undefined; - switch (ConvertInterfaceIndexToLuid.?(@enumFromInt(interface.index), &luid)) { + switch (ConvertInterfaceIndexToLuid.?(@fromBackingInt(@intCast(interface.index)), &luid)) { .SUCCESS => {}, .FILE_NOT_FOUND => return error.InterfaceNotFound, .INVALID_PARAMETER => unreachable, @@ -13884,7 +13884,7 @@ fn netLookupFallible( const syscall: Syscall = try .start(); while (true) { switch (posix.system.getaddrinfo(name_c.ptr, port_c.ptr, &hints, &res)) { - @as(posix.system.EAI, @enumFromInt(0)) => { + @as(posix.system.EAI, @fromBackingInt(@intCast(0))) => { syscall.finish(); break; }, @@ -14029,7 +14029,7 @@ fn processCurrentPath(userdata: ?*anyopaque, buffer: []u8) process.CurrentPathEr const err: posix.E = if (builtin.link_libc) err: { const c_err = if (std.c.getcwd(buffer.ptr, buffer.len)) |_| 0 else std.c._errno().*; - break :err @enumFromInt(c_err); + break :err @fromBackingInt(@intCast(c_err)); } else err: { break :err posix.errno(posix.system.getcwd(buffer.ptr, buffer.len)); }; @@ -14223,12 +14223,12 @@ pub fn posixSocketModeProtocol(family: posix.sa_family_t, mode: net.Socket.Mode, .raw => posix.SOCK.RAW, .rdm => if (@hasDecl(posix.SOCK, "RDM")) posix.SOCK.RDM else return error.OptionUnsupported, }, - if (protocol) |p| @intFromEnum(p) else if (is_windows) switch (family) { + if (protocol) |p| @backingInt(p) else if (is_windows) switch (family) { posix.AF.UNIX => switch (mode) { .stream => 0, else => return error.ProtocolUnsupportedByAddressFamily, }, - posix.AF.INET, posix.AF.INET6 => @intFromEnum(@as(net.Protocol, switch (mode) { + posix.AF.INET, posix.AF.INET6 => @backingInt(@as(net.Protocol, switch (mode) { .stream => .tcp, .dgram => .udp, else => return error.ProtocolUnsupportedByAddressFamily, @@ -14824,7 +14824,7 @@ fn writeResolutionQuery(q: *[280]u8, op: u4, dname: []const u8, class: u8, ty: H if (j - i - 1 > 62) unreachable; q[i - 1] = @intCast(j - i); } - q[i + 1] = @intFromEnum(ty); + q[i + 1] = @backingInt(ty); q[i + 3] = class; return n; } @@ -15299,8 +15299,8 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void { fn childKillWindows(t: *Threaded, child: *process.Child, exit_code: windows.UINT) !void { _ = t; // TODO cancelation const handle = child.id.?; - _ = windows.ntdll.RtlReportSilentProcessExit(handle, @enumFromInt(exit_code)); - switch (windows.ntdll.NtTerminateProcess(handle, @enumFromInt(exit_code))) { + _ = windows.ntdll.RtlReportSilentProcessExit(handle, @fromBackingInt(@intCast(exit_code))); + switch (windows.ntdll.NtTerminateProcess(handle, @fromBackingInt(@intCast(exit_code)))) { .SUCCESS, .PROCESS_IS_TERMINATING => { const infinite_timeout: windows.LARGE_INTEGER = std.math.minInt(windows.LARGE_INTEGER); _ = windows.ntdll.NtWaitForSingleObject(handle, .FALSE, &infinite_timeout); @@ -15344,7 +15344,7 @@ fn childWaitWindows(child: *process.Child) process.Child.WaitError!process.Child @sizeOf(windows.PROCESS.BASIC_INFORMATION), null, )) { - .SUCCESS => .{ .exited = @as(u8, @truncate(@intFromEnum(info.ExitStatus))) }, + .SUCCESS => .{ .exited = @as(u8, @truncate(@backingInt(info.ExitStatus))) }, else => .{ .unknown = 0 }, }; @@ -15424,11 +15424,11 @@ fn childWaitPosix(child: *process.Child) process.Child.WaitError!process.Child.T syscall.finish(); if (ru_ptr) |p| child.resource_usage_statistics.rusage = p.*; const status: u32 = @bitCast(info.fields.common.second.sigchld.status); - const code: linux.CLD = @enumFromInt(info.code); + const code: linux.CLD = @fromBackingInt(@intCast(info.code)); return switch (code) { .EXITED => .{ .exited = @truncate(status) }, - .KILLED, .DUMPED => .{ .signal = @enumFromInt(status) }, - .TRAPPED, .STOPPED => .{ .stopped = @enumFromInt(status) }, + .KILLED, .DUMPED => .{ .signal = @fromBackingInt(@intCast(status)) }, + .TRAPPED, .STOPPED => .{ .stopped = @fromBackingInt(@intCast(status)) }, _, .CONTINUED => .{ .unknown = status }, }; }, @@ -16254,7 +16254,7 @@ fn windowsCreateProcessPathExt( // fails to spawn, in which case we still want to try the PATHEXT appended versions. unappended_exists = true; } else if (windowsCreateProcessSupportsExtension(filename[app_name_len..])) |pathext_ext| { - pathext_seen[@intFromEnum(pathext_ext)] = true; + pathext_seen[@backingInt(pathext_ext)] = true; any_pathext_seen = true; } } @@ -16327,7 +16327,7 @@ fn windowsCreateProcessPathExt( var ext_it = std.mem.tokenizeScalar(u16, pathext, ';'); while (ext_it.next()) |ext| { const ext_enum = windowsCreateProcessSupportsExtension(ext) orelse continue; - if (!pathext_seen[@intFromEnum(ext_enum)]) continue; + if (!pathext_seen[@backingInt(ext_enum)]) continue; dir_buf.shrinkRetainingCapacity(dir_path_len); if (dir_path_len != 0) switch (dir_buf.items[dir_buf.items.len - 1]) { @@ -16451,10 +16451,10 @@ fn windowsCreateProcessSupportsExtension(ext: []const u16) ?process.WindowsExten // Ensures keeping this function in sync with the enum. const field_names = @typeInfo(process.WindowsExtension).@"enum".field_names; assert(field_names.len == 4); - assert(@intFromEnum(process.WindowsExtension.bat) == 0); - assert(@intFromEnum(process.WindowsExtension.cmd) == 1); - assert(@intFromEnum(process.WindowsExtension.com) == 2); - assert(@intFromEnum(process.WindowsExtension.exe) == 3); + assert(@backingInt(process.WindowsExtension.bat) == 0); + assert(@backingInt(process.WindowsExtension.cmd) == 1); + assert(@backingInt(process.WindowsExtension.com) == 2); + assert(@backingInt(process.WindowsExtension.exe) == 3); } if (ext.len != 4) return null; @@ -17509,7 +17509,7 @@ const parking_futex = struct { } thread.futex_waiter = &waiter; const old_status = thread.status.fetchOr( - .{ .cancelation = @enumFromInt(0b001), .awaitable = .null }, + .{ .cancelation = @fromBackingInt(@intCast(0b001)), .awaitable = .null }, .release, // release `thread.futex_waiter` ); switch (old_status.cancelation) { @@ -17547,7 +17547,7 @@ const parking_futex = struct { error.Timeout => { // We're not out of the woods yet: an unpark could race with the timeout. const old_status = waiter.thread_status.fetchAnd( - .{ .cancelation = @enumFromInt(0b110), .awaitable = .all_ones }, + .{ .cancelation = @fromBackingInt(@intCast(0b110)), .awaitable = .all_ones }, .monotonic, ); switch (old_status.cancelation) { @@ -17604,7 +17604,7 @@ const parking_futex = struct { it = waiter.node.next; if (waiter.address != @intFromPtr(ptr)) continue; const old_status = waiter.thread_status.fetchAnd( - .{ .cancelation = @enumFromInt(0b110), .awaitable = .all_ones }, + .{ .cancelation = @fromBackingInt(@intCast(0b110)), .awaitable = .all_ones }, .monotonic, ); switch (old_status.cancelation) { @@ -17669,7 +17669,7 @@ const parking_sleep = struct { thread.futex_waiter = null; { const old_status = thread.status.fetchOr( - .{ .cancelation = @enumFromInt(0b001), .awaitable = .null }, + .{ .cancelation = @fromBackingInt(@intCast(0b001)), .awaitable = .null }, .release, // release `thread.futex_waiter` ); switch (old_status.cancelation) { @@ -17696,7 +17696,7 @@ const parking_sleep = struct { error.Timeout => { // We're not out of the woods yet: an unpark could race with the timeout. const old_status = thread.status.fetchAnd( - .{ .cancelation = @enumFromInt(0b110), .awaitable = .all_ones }, + .{ .cancelation = @fromBackingInt(@intCast(0b110)), .awaitable = .all_ones }, .monotonic, ); switch (old_status.cancelation) { @@ -17747,12 +17747,12 @@ const ParkingMutex = struct { _, /// Returns the head of the waiter list. Illegal to call if `s == .unlocked`. fn waiter(s: State) ?*Waiter { - return @ptrFromInt(@intFromEnum(s)); + return @ptrFromInt(@backingInt(s)); } /// Returns a locked state where `w` is contending the lock. /// If `w` is `null`, returns `.locked_once`. fn fromWaiter(w: ?*Waiter) State { - return @enumFromInt(@intFromPtr(w)); + return @fromBackingInt(@intCast(@intFromPtr(w))); } }; const Waiter = struct { @@ -18316,7 +18316,7 @@ fn createFileMap( if (rc != std.c.MAP_FAILED) { break @as([*]align(page_align) u8, @ptrCast(@alignCast(rc)))[0..len]; } - break :e @enumFromInt(posix.system._errno().*); + break :e @fromBackingInt(@intCast(posix.system._errno().*)); } else e: { const err = posix.errno(rc); if (err == .SUCCESS) { @@ -18409,7 +18409,7 @@ fn fileMemoryMapSetLength( syscall.finish(); const err: posix.E = if (builtin.link_libc) e: { if (rc != std.c.MAP_FAILED) break @as([*]align(page_align) u8, @ptrCast(@alignCast(rc)))[0..new_len]; - break :e @enumFromInt(posix.system._errno().*); + break :e @fromBackingInt(@intCast(posix.system._errno().*)); } else e: { const err = posix.errno(rc); if (err == .SUCCESS) break @as([*]align(page_align) u8, @ptrFromInt(rc))[0..new_len]; @@ -18733,7 +18733,7 @@ fn deviceIoControl(o: *const Io.Operation.DeviceIoControl) Io.Cancelable!Io.Oper }, else => |err| { syscall.finish(); - return -@as(i32, @intFromEnum(err)); + return -@as(i32, @backingInt(err)); }, } } @@ -18782,7 +18782,7 @@ fn eventWait(event: *Io.Event) void { .is_set => return, }; while (true) { - Thread.futexWaitUncancelable(@ptrCast(event), @intFromEnum(Io.Event.waiting), null); + Thread.futexWaitUncancelable(@ptrCast(event), @backingInt(Io.Event.waiting), null); switch (@atomicLoad(Io.Event, event, .acquire)) { .unset => unreachable, // `reset` called before pending `wait` returned .waiting => continue, @@ -18881,10 +18881,10 @@ pub fn mutexLock(m: *Io.Mutex) void { return; }; if (initial_state == .contended) { - Thread.futexWaitUncancelable(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null); + Thread.futexWaitUncancelable(@ptrCast(&m.state.raw), @backingInt(Io.Mutex.State.contended), null); } while (m.state.swap(.contended, .acquire) != .unlocked) { - Thread.futexWaitUncancelable(@ptrCast(&m.state.raw), @intFromEnum(Io.Mutex.State.contended), null); + Thread.futexWaitUncancelable(@ptrCast(&m.state.raw), @backingInt(Io.Mutex.State.contended), null); } } diff --git a/lib/std/Io/Uring.zig b/lib/std/Io/Uring.zig index 436406174b5643ef3c50df54e8e65b12ba5bd597..c2c7e57edff411b2c469519858391f3d1eb0724d 100644 --- a/lib/std/Io/Uring.zig +++ b/lib/std/Io/Uring.zig @@ -177,11 +177,11 @@ const Fiber = struct { _, fn subWrap(lhs: Awaiting, rhs: Awaiting) Awaiting { - return @enumFromInt(@intFromEnum(lhs) -% @intFromEnum(rhs)); + return @fromBackingInt(@intCast(@backingInt(lhs) -% @backingInt(rhs))); } fn fromIoUringFd(fd: fd_t) Awaiting { - const awaiting: Awaiting = @enumFromInt(fd); + const awaiting: Awaiting = @fromBackingInt(@intCast(fd)); switch (awaiting) { .nothing, .group => unreachable, _ => return awaiting, @@ -191,7 +191,7 @@ const Fiber = struct { fn toIoUringFd(awaiting: Awaiting) fd_t { switch (awaiting) { .nothing, .group => unreachable, - _ => return @intFromEnum(awaiting), + _ => return @backingInt(awaiting), } } }; @@ -217,7 +217,7 @@ const Fiber = struct { const unblocked: CancelProtection = .{ .user = .unblocked, .acknowledged = false }; fn check(cancel_protection: CancelProtection) Io.CancelProtection { - return @enumFromInt(@intFromBool(cancel_protection != unblocked)); + return @fromBackingInt(@intCast(@intFromBool(cancel_protection != unblocked))); } fn acknowledge(cancel_protection: *CancelProtection) void { @@ -359,7 +359,7 @@ const Fiber = struct { Fiber.CancelStatus, &fiber.cancel_status, .Or, - .{ .requested = true, .awaiting = @enumFromInt(0) }, + .{ .requested = true, .awaiting = @fromBackingInt(@intCast(0)) }, .acquire, ); assert(!cancel_status.requested); @@ -385,7 +385,7 @@ const Fiber = struct { .addr = @intFromPtr(fiber), .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.wakeup), + .user_data = @backingInt(Completion.Userdata.wakeup), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -397,10 +397,10 @@ const Fiber = struct { .ioprio = 0, .fd = awaiting_io_uring_fd, .off = @intFromPtr(fiber) | 0b01, - .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA), + .addr = @backingInt(linux.IORING_MSG_RING_COMMAND.DATA), .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.cleanup), + .user_data = @backingInt(Completion.Userdata.cleanup), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -537,11 +537,11 @@ const CachedFd = struct { _, fn fromFd(fd: fd_t) Once { - return @enumFromInt(@as(u31, @intCast(fd))); + return @fromBackingInt(@intCast(@as(u31, @intCast(fd)))); } fn toFd(once: Once) fd_t { - return @as(u31, @intCast(@intFromEnum(once))); + return @as(u31, @intCast(@backingInt(once))); } }; @@ -552,8 +552,8 @@ const CachedFd = struct { .uninitialized => {}, .initializing => unreachable, _ => |fd| { - assert(@intFromEnum(fd) >= 0); - _ = linux.close(@intFromEnum(fd)); + assert(@backingInt(fd) >= 0); + _ = linux.close(@backingInt(fd)); cached_fd.* = .init; }, } @@ -573,7 +573,7 @@ const CachedFd = struct { .initializing => try futexWait( ev, @ptrCast(&cached_fd.once), - @bitCast(@intFromEnum(once)), + @bitCast(@backingInt(once)), .none, ), _ => |fd| { @@ -997,11 +997,11 @@ fn schedule(ev: *Evented, thread: *Thread, ready_queue: Fiber.Queue) bool { .flags = linux.IOSQE_CQE_SKIP_SUCCESS, .ioprio = 0, .fd = idle_search_thread.io_uring.fd, - .off = @intFromEnum(Completion.Userdata.wakeup), - .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA), + .off = @backingInt(Completion.Userdata.wakeup), + .addr = @backingInt(linux.IORING_MSG_RING_COMMAND.DATA), .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.wakeup), + .user_data = @backingInt(Completion.Userdata.wakeup), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -1164,7 +1164,7 @@ fn idle(ev: *Evented, thread: *Thread) void { if (cqes.len == 0) break; for (cqes) |cqe| if (cqe.flags & linux.IORING_CQE_F_SKIP == 0) switch (@as( Completion.Userdata, - @enumFromInt(cqe.user_data), + @fromBackingInt(@intCast(cqe.user_data)), )) { .unused => unreachable, // bad submission queued? .wakeup => {}, @@ -1204,7 +1204,7 @@ fn idle(ev: *Evented, thread: *Thread) void { .addr = cqe.user_data & ~@as(usize, 0b11), .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.wakeup), + .user_data = @backingInt(Completion.Userdata.wakeup), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -1337,11 +1337,11 @@ const SwitchMessage = struct { .flags = linux.IOSQE_CQE_SKIP_SUCCESS, .ioprio = 0, .fd = each_thread.io_uring.fd, - .off = @intFromEnum(Completion.Userdata.exit), - .addr = @intFromEnum(linux.IORING_MSG_RING_COMMAND.DATA), + .off = @backingInt(Completion.Userdata.exit), + .addr = @backingInt(linux.IORING_MSG_RING_COMMAND.DATA), .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.cleanup), + .user_data = @backingInt(Completion.Userdata.cleanup), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -1986,7 +1986,7 @@ fn futexWait( else => 0, .boot => linux.IORING_TIMEOUT_BOOTTIME, }), - .user_data = @intFromEnum(Completion.Userdata.wakeup), + .user_data = @backingInt(Completion.Userdata.wakeup), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -2052,7 +2052,7 @@ fn futexWake(userdata: ?*anyopaque, ptr: *const u32, max_waiters: u32) void { .addr = @intFromPtr(ptr), .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.futex_wake), + .user_data = @backingInt(Completion.Userdata.futex_wake), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -2188,7 +2188,7 @@ fn deviceIoControl( switch (linux.errno(rc)) { .SUCCESS => return @bitCast(@as(u32, @truncate(rc))), .INTR => {}, - else => |err| return -@as(i32, @intFromEnum(err)), + else => |err| return -@as(i32, @backingInt(err)), } } } @@ -2547,7 +2547,7 @@ fn batchCancel(userdata: ?*anyopaque, batch: *Io.Batch) void { .addr = @intFromPtr(&pending.userdata) | 0b10, .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.wakeup), + .user_data = @backingInt(Completion.Userdata.wakeup), .buf_index = 0, .personality = 0, .splice_fd_in = 0, @@ -4701,7 +4701,7 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr .fd = pid, .off = @intFromPtr(&info), .addr = 0, - .len = @intFromEnum(linux.P.PID), + .len = @backingInt(linux.P.PID), .rw_flags = 0, .user_data = @intFromPtr(maybe_sync.cancel_region.fiber), .buf_index = 0, @@ -4737,11 +4737,11 @@ fn childWait(userdata: ?*anyopaque, child: *process.Child) process.Child.WaitErr } } const status: u32 = @bitCast(info.fields.common.second.sigchld.status); - const code: linux.CLD = @enumFromInt(info.code); + const code: linux.CLD = @fromBackingInt(@intCast(info.code)); return switch (code) { .EXITED => .{ .exited = @truncate(status) }, - .KILLED, .DUMPED => .{ .signal = @enumFromInt(status) }, - .TRAPPED, .STOPPED => .{ .stopped = @enumFromInt(status) }, + .KILLED, .DUMPED => .{ .signal = @fromBackingInt(@intCast(status)) }, + .TRAPPED, .STOPPED => .{ .stopped = @fromBackingInt(@intCast(status)) }, _, .CONTINUED => .{ .unknown = status }, }; }, @@ -4782,7 +4782,7 @@ fn childKill(userdata: ?*anyopaque, child: *process.Child) void { .fd = pid, .off = @intFromPtr(&info), .addr = 0, - .len = @intFromEnum(linux.P.PID), + .len = @backingInt(linux.P.PID), .rw_flags = 0, .user_data = @intFromPtr(maybe_sync.cancel_region.fiber), .buf_index = 0, @@ -5370,7 +5370,7 @@ fn closeAsync(ev: *Evented, fd: fd_t) void { .addr = 0, .len = 0, .rw_flags = 0, - .user_data = @intFromEnum(Completion.Userdata.close), + .user_data = @backingInt(Completion.Userdata.close), .buf_index = 0, .personality = 0, .splice_fd_in = 0, diff --git a/lib/std/Io/Writer.zig b/lib/std/Io/Writer.zig index c5dd1f6bae8a7dce41a8ff26692e73fc43c65ba3..ca9564edff39fe329f5114aa2a2fba41c4a6fe02 100644 --- a/lib/std/Io/Writer.zig +++ b/lib/std/Io/Writer.zig @@ -164,7 +164,7 @@ pub fn countSplat(data: []const []const u8, splat: usize) usize { } pub fn countSendFileLowerBound(n: usize, file_reader: *File.Reader, limit: Limit) ?usize { - const total: u64 = @min(@intFromEnum(limit), file_reader.getSize() catch return null); + const total: u64 = @min(@backingInt(limit), file_reader.getSize() catch return null); return std.math.lossyCast(usize, total + n); } @@ -220,7 +220,7 @@ pub fn writeSplatHeaderLimit( splat: usize, limit: Limit, ) Error!usize { - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); { const copy_len = @min(header.len, w.buffer.len - w.end, remaining); if (header.len - copy_len != 0) return writeSplatHeaderLimitFinish(w, header, data, splat, remaining); @@ -230,7 +230,7 @@ pub fn writeSplatHeaderLimit( } for (data[0 .. data.len - 1], 0..) |buf, i| { const copy_len = @min(buf.len, w.buffer.len - w.end, remaining); - if (buf.len - copy_len != 0) return @intFromEnum(limit) - remaining + + if (buf.len - copy_len != 0) return @backingInt(limit) - remaining + try writeSplatHeaderLimitFinish(w, &.{}, data[i..], splat, remaining); @memcpy(w.buffer[w.end..][0..copy_len], buf[0..copy_len]); w.end += copy_len; @@ -239,7 +239,7 @@ pub fn writeSplatHeaderLimit( const pattern = data[data.len - 1]; const splat_n = pattern.len * splat; if (splat_n > @min(w.buffer.len - w.end, remaining)) { - const buffered_n = @intFromEnum(limit) - remaining; + const buffered_n = @backingInt(limit) - remaining; const written = try writeSplatHeaderLimitFinish(w, &.{}, data[data.len - 1 ..][0..1], splat, remaining); return buffered_n + written; } @@ -250,7 +250,7 @@ pub fn writeSplatHeaderLimit( } remaining -= splat_n; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } fn writeSplatHeaderLimitFinish( @@ -998,7 +998,7 @@ pub fn sendFileAll(w: *Writer, file_reader: *File.Reader, limit: Limit) FileAllE // Explicitly assert it here as well to ensure the assert is hit even if // the fallback path is not taken. assert(w.buffer.len > 0); - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); while (remaining > 0) { const n = sendFile(w, file_reader, .limited(remaining)) catch |err| switch (err) { error.EndOfStream => break, @@ -1011,7 +1011,7 @@ pub fn sendFileAll(w: *Writer, file_reader: *File.Reader, limit: Limit) FileAllE }; remaining -= n; } - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } /// Equivalent to `sendFileAll` but uses direct `pread` and `read` calls on @@ -1021,14 +1021,14 @@ pub fn sendFileAll(w: *Writer, file_reader: *File.Reader, limit: Limit) FileAllE /// /// Asserts nonzero buffer capacity. pub fn sendFileReadingAll(w: *Writer, file_reader: *File.Reader, limit: Limit) FileAllError!usize { - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); while (remaining > 0) { remaining -= sendFileReading(w, file_reader, .limited(remaining)) catch |err| switch (err) { error.EndOfStream => break, else => |e| return e, }; } - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } pub fn alignBuffer( @@ -1105,7 +1105,7 @@ pub fn printValue( .float, .comptime_float => return printFloat(w, value, options.toNumber(.decimal, .lower)), .int, .comptime_int => return printInt(w, value, 10, .lower, options), .@"struct" => return value.formatNumber(w, options.toNumber(.decimal, .lower)), - .@"enum" => return printInt(w, @intFromEnum(value), 10, .lower, options), + .@"enum" => return printInt(w, @backingInt(value), 10, .lower, options), .vector => return printVector(w, fmt, options, value, max_depth), else => invalidFmtError(fmt, value), }, @@ -1113,14 +1113,14 @@ pub fn printValue( 'u' => return w.printUnicodeCodepoint(value), 'b' => switch (@typeInfo(T)) { .int, .comptime_int => return printInt(w, value, 2, .lower, options), - .@"enum" => return printInt(w, @intFromEnum(value), 2, .lower, options), + .@"enum" => return printInt(w, @backingInt(value), 2, .lower, options), .@"struct" => return value.formatNumber(w, options.toNumber(.binary, .lower)), .vector => return printVector(w, fmt, options, value, max_depth), else => invalidFmtError(fmt, value), }, 'o' => switch (@typeInfo(T)) { .int, .comptime_int => return printInt(w, value, 8, .lower, options), - .@"enum" => return printInt(w, @intFromEnum(value), 8, .lower, options), + .@"enum" => return printInt(w, @backingInt(value), 8, .lower, options), .@"struct" => return value.formatNumber(w, options.toNumber(.octal, .lower)), .vector => return printVector(w, fmt, options, value, max_depth), else => invalidFmtError(fmt, value), @@ -1128,7 +1128,7 @@ pub fn printValue( 'x' => switch (@typeInfo(T)) { .float, .comptime_float => return printFloatHexOptions(w, value, options.toNumber(.hex, .lower)), .int, .comptime_int => return printInt(w, value, 16, .lower, options), - .@"enum" => return printInt(w, @intFromEnum(value), 16, .lower, options), + .@"enum" => return printInt(w, @backingInt(value), 16, .lower, options), .@"struct" => return value.formatNumber(w, options.toNumber(.hex, .lower)), .pointer => |info| switch (info.size) { .one, .slice => { @@ -1153,7 +1153,7 @@ pub fn printValue( 'X' => switch (@typeInfo(T)) { .float, .comptime_float => return printFloatHexOptions(w, value, options.toNumber(.hex, .upper)), .int, .comptime_int => return printInt(w, value, 16, .upper, options), - .@"enum" => return printInt(w, @intFromEnum(value), 16, .upper, options), + .@"enum" => return printInt(w, @backingInt(value), 16, .upper, options), .@"struct" => return value.formatNumber(w, options.toNumber(.hex, .upper)), .pointer => |info| switch (info.size) { .one, .slice => { @@ -1472,7 +1472,7 @@ fn printEnumNonexhaustive(w: *Writer, value: anytype) Error!void { return; } try w.writeAll("@enumFromInt("); - try w.printInt(@intFromEnum(value), 10, .lower, .{}); + try w.printInt(@backingInt(value), 10, .lower, .{}); try w.writeByte(')'); } diff --git a/lib/std/Io/net/HostName.zig b/lib/std/Io/net/HostName.zig index 6249e47dfcda57c603d42042094abbde235a62b1..8c5717d56d13f7dc5bc861cdfbda7cbb81816860 100644 --- a/lib/std/Io/net/HostName.zig +++ b/lib/std/Io/net/HostName.zig @@ -277,7 +277,7 @@ pub const DnsResponse = struct { if (i + 10 + len > r.len) return error.InvalidDnsPacket; defer dr.bytes_index = i + 10 + len; return .{ - .rr = @enumFromInt(r[i + 1]), + .rr = @fromBackingInt(@intCast(r[i + 1])), .packet = r, .data_off = i + 10, .data_len = len, diff --git a/lib/std/Progress.zig b/lib/std/Progress.zig index b0f1b5f9a9011427e48c83c334c602c69c6f42c2..1c49983d54db855297db8fb2d37d6d560a8116d8 100644 --- a/lib/std/Progress.zig +++ b/lib/std/Progress.zig @@ -226,7 +226,7 @@ pub const Node = struct { fn unwrap(i: @This()) ?Index { return switch (i) { .unused, .none => return null, - else => @enumFromInt(@intFromEnum(i)), + else => @fromBackingInt(@intCast(@backingInt(i))), }; } }; @@ -238,12 +238,12 @@ pub const Node = struct { pub fn unwrap(i: @This()) ?Index { if (i == .none) return null; - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } fn toParent(i: @This()) Parent { - assert(@intFromEnum(i) != @intFromEnum(Parent.unused)); - return @enumFromInt(@intFromEnum(i)); + assert(@backingInt(i) != @backingInt(Parent.unused)); + return @fromBackingInt(@intCast(@backingInt(i))); } }; @@ -252,13 +252,13 @@ pub const Node = struct { _, fn toParent(i: @This()) Parent { - assert(@intFromEnum(i) != @intFromEnum(Parent.unused)); - assert(@intFromEnum(i) != @intFromEnum(Parent.none)); - return @enumFromInt(@intFromEnum(i)); + assert(@backingInt(i) != @backingInt(Parent.unused)); + assert(@backingInt(i) != @backingInt(Parent.none)); + return @fromBackingInt(@intCast(@backingInt(i))); } pub fn toOptional(i: @This()) OptionalIndex { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } }; @@ -303,7 +303,7 @@ pub const Node = struct { return Node.none; } - return init(@enumFromInt(free_index), parent, name, estimated_total_items); + return init(@fromBackingInt(@intCast(free_index)), parent, name, estimated_total_items); } pub fn startFmt(node: Node, estimated_total_items: usize, comptime format: []const u8, args: anytype) Node { @@ -458,19 +458,19 @@ pub const Node = struct { } fn storageByIndex(index: Node.Index) *Node.Storage { - return &global_progress.node_storage[@intFromEnum(index)]; + return &global_progress.node_storage[@backingInt(index)]; } fn parentByIndex(index: Node.Index) *Node.Parent { - return &global_progress.node_parents[@intFromEnum(index)]; + return &global_progress.node_parents[@backingInt(index)]; } fn freelistNextByIndex(index: Node.Index) *Node.OptionalIndex { - return &global_progress.node_freelist_next[@intFromEnum(index)]; + return &global_progress.node_freelist_next[@backingInt(index)]; } fn init(free_index: Index, parent: Parent, name: []const u8, estimated_total_items: usize) Node { - assert(parent == .none or @intFromEnum(parent) < node_storage_buffer_len); + assert(parent == .none or @backingInt(parent) < node_storage_buffer_len); const storage = storageByIndex(free_index); @atomicStore(u32, &storage.completed_count, 0, .monotonic); @@ -595,7 +595,7 @@ pub fn start(io: Io, options: Options) Node { @memset(&global_progress.node_parents, .unused); @memset(&global_progress.ipc, .{ .locked = false, .valid = false, .generation = 0 }); - const root_node = Node.init(@enumFromInt(0), .none, options.root_name, options.estimated_total_items); + const root_node = Node.init(@fromBackingInt(@intCast(0)), .none, options.root_name, options.estimated_total_items); global_progress.node_end_index = 1; assert(options.draw_buffer.len >= 200); @@ -1063,7 +1063,7 @@ fn serialize(io: Io, serialized_buffer: *Serialized.Buffer) !Serialized { dest_storage.completed_count = @atomicLoad(u32, &storage_ptr.completed_count, .monotonic); serialized_buffer.parents[serialized_len] = parent; - map_entry.* = @enumFromInt(serialized_len); + map_entry.* = @fromBackingInt(@intCast(serialized_len)); if (maybe_ipc_start == null and dest_storage.getIpcIndex() != null) maybe_ipc_start = serialized_len; serialized_len += 1; } @@ -1073,7 +1073,7 @@ fn serialize(io: Io, serialized_buffer: *Serialized.Buffer) !Serialized { parent.* = switch (parent.*) { .unused => unreachable, .none => .none, - _ => |p| map[@intFromEnum(p)].toParent(), + _ => |p| map[@backingInt(p)].toParent(), }; } @@ -1173,11 +1173,11 @@ fn serialize(io: Io, serialized_buffer: *Serialized.Buffer) !Serialized { prev_parents[serialized_len..][0..nodes_len], ) |*parent, prev_parent| parent.* = switch (prev_parent) { .none, .unused => .none, - _ => if (@intFromEnum(prev_parent) == ipc_data.main_index) - @enumFromInt(main_index) - else if (@intFromEnum(prev_parent) >= start_index and - @intFromEnum(prev_parent) < start_index + nodes_len) - @enumFromInt(@intFromEnum(prev_parent) - start_index + serialized_len) + _ => if (@backingInt(prev_parent) == ipc_data.main_index) + @fromBackingInt(@intCast(main_index)) + else if (@backingInt(prev_parent) >= start_index and + @backingInt(prev_parent) < start_index + nodes_len) + @fromBackingInt(@intCast(@backingInt(prev_parent) - start_index + serialized_len)) else .none, }; @@ -1228,12 +1228,12 @@ fn serialize(io: Io, serialized_buffer: *Serialized.Buffer) !Serialized { // Fix bad data so the rest of the code does not see `unused`. .none, .unused => .none, // Root node is being mounted here. - @as(Node.Parent, @enumFromInt(0)) => @enumFromInt(main_index), + @as(Node.Parent, @fromBackingInt(@intCast(0))) => @fromBackingInt(@intCast(main_index)), // Other nodes mounted at the end. // Don't trust child data; if the data is outside the expected range, // ignore the data. This also handles the case when data was truncated. - _ => if (@intFromEnum(prev_parent) <= nodes_len) - @enumFromInt(@intFromEnum(prev_parent) - 1 + serialized_len) + _ => if (@backingInt(prev_parent) <= nodes_len) + @fromBackingInt(@intCast(@backingInt(prev_parent) - 1 + serialized_len)) else .none, }; @@ -1290,13 +1290,13 @@ fn computeRedraw(io: Io, serialized_buffer: *Serialized.Buffer) !struct { []u8, @memset(children, .{ .child = .none, .sibling = .none }); for (serialized.parents, 0..) |parent, child_index_usize| { - const child_index: Node.Index = @enumFromInt(child_index_usize); + const child_index: Node.Index = @fromBackingInt(@intCast(child_index_usize)); assert(parent != .unused); const parent_index = parent.unwrap() orelse continue; - const children_node = &children[@intFromEnum(parent_index)]; + const children_node = &children[@backingInt(parent_index)]; if (children_node.child.unwrap()) |existing_child_index| { - const existing_child = &children[@intFromEnum(existing_child_index)]; - children[@intFromEnum(child_index)].sibling = existing_child.sibling; + const existing_child = &children[@backingInt(existing_child_index)]; + children[@backingInt(child_index)].sibling = existing_child.sibling; existing_child.sibling = child_index.toOptional(); } else { children_node.child = child_index.toOptional(); @@ -1325,14 +1325,14 @@ fn computeRedraw(io: Io, serialized_buffer: *Serialized.Buffer) !struct { []u8, .windows_api => {}, } - const root_node_index: Node.Index = @enumFromInt(0); + const root_node_index: Node.Index = @fromBackingInt(@intCast(0)); i, const nl_n = computeNode(buf, i, 0, serialized, children, root_node_index); if (global_progress.terminal_mode == .ansi_escape_codes) { { // Set progress state https://conemu.github.io/en/AnsiEscapeCodes.html#ConEmu_specific_OSC const root_storage = &serialized.storage[0]; - const storage = if (root_storage.name[0] != 0 or children[0].child == .none) root_storage else &serialized.storage[@intFromEnum(children[0].child)]; + const storage = if (root_storage.name[0] != 0 or children[0].child == .none) root_storage else &serialized.storage[@backingInt(children[0].child)]; const estimated_total = storage.estimated_total_count; const completed_items = storage.completed_count; const status = @atomicLoad(Status, &global_progress.status, .monotonic); @@ -1395,15 +1395,15 @@ fn computePrefix( node_index: Node.Index, ) usize { var i = start_i; - const parent_index = serialized.parents[@intFromEnum(node_index)].unwrap() orelse return i; - if (serialized.parents[@intFromEnum(parent_index)] == .none) return i; - if (@intFromEnum(serialized.parents[@intFromEnum(parent_index)]) == 0 and + const parent_index = serialized.parents[@backingInt(node_index)].unwrap() orelse return i; + if (serialized.parents[@backingInt(parent_index)] == .none) return i; + if (@backingInt(serialized.parents[@backingInt(parent_index)]) == 0 and serialized.storage[0].name[0] == 0) { return i; } i = computePrefix(buf, i, nl_n, serialized, children, parent_index); - if (children[@intFromEnum(parent_index)].sibling == .none) { + if (children[@backingInt(parent_index)].sibling == .none) { const prefix = " "; const upper_bound_len = prefix.len + lineUpperBoundLen(nl_n); if (i + upper_bound_len > buf.len) return buf.len; @@ -1442,24 +1442,24 @@ fn computeNode( if (i + lineUpperBoundLen(nl_n) > buf.len) return .{ start_i, start_nl_n }; - const storage = &serialized.storage[@intFromEnum(node_index)]; + const storage = &serialized.storage[@backingInt(node_index)]; const estimated_total = storage.estimated_total_count; const completed_items = storage.completed_count; const name = if (std.mem.findScalar(u8, &storage.name, 0)) |end| storage.name[0..end] else &storage.name; - const parent = serialized.parents[@intFromEnum(node_index)]; + const parent = serialized.parents[@backingInt(node_index)]; if (parent != .none) p: { - if (@intFromEnum(parent) == 0 and serialized.storage[0].name[0] == 0) { + if (@backingInt(parent) == 0 and serialized.storage[0].name[0] == 0) { break :p; } - if (children[@intFromEnum(node_index)].sibling == .none) { + if (children[@backingInt(node_index)].sibling == .none) { i = appendTreeSymbol(.langle, buf, i); } else { i = appendTreeSymbol(.tee, buf, i); } } - const is_empty_root = @intFromEnum(node_index) == 0 and serialized.storage[0].name[0] == 0; + const is_empty_root = @backingInt(node_index) == 0 and serialized.storage[0].name[0] == 0; if (!is_empty_root) { if (name.len != 0 or estimated_total > 0) { if (estimated_total > 0) { @@ -1492,13 +1492,13 @@ fn computeNode( } if (global_progress.withinRowLimit(nl_n)) { - if (children[@intFromEnum(node_index)].child.unwrap()) |child| { + if (children[@backingInt(node_index)].child.unwrap()) |child| { i, nl_n = computeNode(buf, i, nl_n, serialized, children, child); } } if (global_progress.withinRowLimit(nl_n)) { - if (children[@intFromEnum(node_index)].sibling.unwrap()) |sibling| { + if (children[@backingInt(node_index)].sibling.unwrap()) |sibling| { i, nl_n = computeNode(buf, i, nl_n, serialized, children, sibling); } } diff --git a/lib/std/Target.zig b/lib/std/Target.zig index c22bc4387fa6d80596bfa3da1c077d7770bce75f..e9105c4737318576719795cd67e70e6b05d293e4 100644 --- a/lib/std/Target.zig +++ b/lib/std/Target.zig @@ -286,7 +286,7 @@ pub const Os = struct { /// Returns whether the first version `ver` is newer (greater) than or equal to the second version `ver`. pub inline fn isAtLeast(ver: WindowsVersion, min_ver: WindowsVersion) bool { - return @intFromEnum(ver) >= @intFromEnum(min_ver); + return @backingInt(ver) >= @backingInt(min_ver); } pub const Range = struct { @@ -294,23 +294,23 @@ pub const Os = struct { max: WindowsVersion, pub inline fn includesVersion(range: Range, ver: WindowsVersion) bool { - return @intFromEnum(ver) >= @intFromEnum(range.min) and - @intFromEnum(ver) <= @intFromEnum(range.max); + return @backingInt(ver) >= @backingInt(range.min) and + @backingInt(ver) <= @backingInt(range.max); } /// Checks if system is guaranteed to be at least `version` or older than `version`. /// Returns `null` if a runtime check is required. pub inline fn isAtLeast(range: Range, min_ver: WindowsVersion) ?bool { - if (@intFromEnum(range.min) >= @intFromEnum(min_ver)) return true; - if (@intFromEnum(range.max) < @intFromEnum(min_ver)) return false; + if (@backingInt(range.min) >= @backingInt(min_ver)) return true; + if (@backingInt(range.max) < @backingInt(min_ver)) return false; return null; } }; pub fn parse(str: []const u8) !WindowsVersion { return std.meta.stringToEnum(WindowsVersion, str) orelse - @enumFromInt(std.fmt.parseInt(u32, str, 0) catch - return error.InvalidOperatingSystemVersion); + @fromBackingInt(@intCast(std.fmt.parseInt(u32, str, 0) catch + return error.InvalidOperatingSystemVersion)); } /// This function is defined to serialize a Zig source code representation of this @@ -1320,20 +1320,20 @@ pub const Cpu = struct { pub fn featureSet(features: []const F) Set { var x = Set.empty; for (features) |feature| { - x.addFeature(@intFromEnum(feature)); + x.addFeature(@backingInt(feature)); } return x; } /// Returns true if the specified feature is enabled. pub fn featureSetHas(set: Set, feature: F) bool { - return set.isEnabled(@intFromEnum(feature)); + return set.isEnabled(@backingInt(feature)); } /// Returns true if any specified feature is enabled. pub fn featureSetHasAny(set: Set, features: anytype) bool { inline for (features) |feature| { - if (set.isEnabled(@intFromEnum(@as(F, feature)))) return true; + if (set.isEnabled(@backingInt(@as(F, feature)))) return true; } return false; } @@ -1341,7 +1341,7 @@ pub const Cpu = struct { /// Returns true if every specified feature is enabled. pub fn featureSetHasAll(set: Set, features: anytype) bool { inline for (features) |feature| { - if (!set.isEnabled(@intFromEnum(@as(F, feature)))) return false; + if (!set.isEnabled(@backingInt(@as(F, feature)))) return false; } return true; } @@ -2119,14 +2119,14 @@ pub const Cpu = struct { /// Returns true if `feature` is enabled. pub fn has(cpu: Cpu, comptime family: Arch.Family, feature: @field(Target, @tagName(family)).Feature) bool { if (family != cpu.arch.family()) return false; - return cpu.features.isEnabled(@intFromEnum(feature)); + return cpu.features.isEnabled(@backingInt(feature)); } /// Returns true if any feature in `features` is enabled. pub fn hasAny(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool { if (family != cpu.arch.family()) return false; for (features) |feature| { - if (cpu.features.isEnabled(@intFromEnum(feature))) return true; + if (cpu.features.isEnabled(@backingInt(feature))) return true; } return false; } @@ -2135,7 +2135,7 @@ pub const Cpu = struct { pub fn hasAll(cpu: Cpu, comptime family: Arch.Family, features: []const @field(Target, @tagName(family)).Feature) bool { if (family != cpu.arch.family()) return false; for (features) |feature| { - if (!cpu.features.isEnabled(@intFromEnum(feature))) return false; + if (!cpu.features.isEnabled(@backingInt(feature))) return false; } return true; } diff --git a/lib/std/Target/aarch64.zig b/lib/std/Target/aarch64.zig index dbd1b5273f5b6f7aa6b2800d1ac96d1430dd7f9a..eb02c7d17ab450361a359d99bc146c1e1d0ae4d5 100644 --- a/lib/std/Target/aarch64.zig +++ b/lib/std/Target/aarch64.zig @@ -294,7 +294,7 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.a320)] = .{ + result[@backingInt(Feature.a320)] = .{ .llvm_name = "a320", .description = "Cortex-A320 ARM processors", .dependencies = featureSet(&[_]Feature{ @@ -306,214 +306,214 @@ pub const all_features = blk: { .use_wzr_to_vec_move, }), }; - result[@intFromEnum(Feature.addr_lsl_slow_14)] = .{ + result[@backingInt(Feature.addr_lsl_slow_14)] = .{ .llvm_name = "addr-lsl-slow-14", .description = "Address operands with shift amount of 1 or 4 are slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.aes)] = .{ + result[@backingInt(Feature.aes)] = .{ .llvm_name = "aes", .description = "Enable AES support", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.aggressive_fma)] = .{ + result[@backingInt(Feature.aggressive_fma)] = .{ .llvm_name = "aggressive-fma", .description = "Enable Aggressive FMA for floating-point.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.aggressive_interleaving)] = .{ + result[@backingInt(Feature.aggressive_interleaving)] = .{ .llvm_name = "aggressive-interleaving", .description = "Make use of aggressive interleaving during vectorization", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.alternate_sextload_cvt_f32_pattern)] = .{ + result[@backingInt(Feature.alternate_sextload_cvt_f32_pattern)] = .{ .llvm_name = "alternate-sextload-cvt-f32-pattern", .description = "Use alternative pattern for sextload convert to f32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.altnzcv)] = .{ + result[@backingInt(Feature.altnzcv)] = .{ .llvm_name = "altnzcv", .description = "Enable alternative NZCV format for floating point comparisons", .dependencies = featureSet(&[_]Feature{ .flagm, }), }; - result[@intFromEnum(Feature.alu_lsl_fast)] = .{ + result[@backingInt(Feature.alu_lsl_fast)] = .{ .llvm_name = "alu-lsl-fast", .description = "Add/Sub operations with lsl shift <= 4 are cheap", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.am)] = .{ + result[@backingInt(Feature.am)] = .{ .llvm_name = "am", .description = "Enable Armv8.4-A Activity Monitors extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.amvs)] = .{ + result[@backingInt(Feature.amvs)] = .{ .llvm_name = "amvs", .description = "Enable Armv8.6-A Activity Monitors Virtualization support", .dependencies = featureSet(&[_]Feature{ .am, }), }; - result[@intFromEnum(Feature.arith_bcc_fusion)] = .{ + result[@backingInt(Feature.arith_bcc_fusion)] = .{ .llvm_name = "arith-bcc-fusion", .description = "CPU fuses arithmetic+bcc operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.arith_cbz_fusion)] = .{ + result[@backingInt(Feature.arith_cbz_fusion)] = .{ .llvm_name = "arith-cbz-fusion", .description = "CPU fuses arithmetic + cbz/cbnz operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ascend_store_address)] = .{ + result[@backingInt(Feature.ascend_store_address)] = .{ .llvm_name = "ascend-store-address", .description = "Schedule vector stores by ascending address", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.avoid_ldapur)] = .{ + result[@backingInt(Feature.avoid_ldapur)] = .{ .llvm_name = "avoid-ldapur", .description = "Prefer add+ldapr to offset ldapur", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.balance_fp_ops)] = .{ + result[@backingInt(Feature.balance_fp_ops)] = .{ .llvm_name = "balance-fp-ops", .description = "balance mix of odd and even D-registers for fp multiply(-accumulate) ops", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bf16)] = .{ + result[@backingInt(Feature.bf16)] = .{ .llvm_name = "bf16", .description = "Enable BFloat16 Extension", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.brbe)] = .{ + result[@backingInt(Feature.brbe)] = .{ .llvm_name = "brbe", .description = "Enable Branch Record Buffer Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bti)] = .{ + result[@backingInt(Feature.bti)] = .{ .llvm_name = "bti", .description = "Enable Branch Target Identification", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.btie)] = .{ + result[@backingInt(Feature.btie)] = .{ .llvm_name = "btie", .description = "Enable Enhanced Branch Target Identification extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x10)] = .{ + result[@backingInt(Feature.call_saved_x10)] = .{ .llvm_name = "call-saved-x10", .description = "Make X10 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x11)] = .{ + result[@backingInt(Feature.call_saved_x11)] = .{ .llvm_name = "call-saved-x11", .description = "Make X11 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x12)] = .{ + result[@backingInt(Feature.call_saved_x12)] = .{ .llvm_name = "call-saved-x12", .description = "Make X12 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x13)] = .{ + result[@backingInt(Feature.call_saved_x13)] = .{ .llvm_name = "call-saved-x13", .description = "Make X13 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x14)] = .{ + result[@backingInt(Feature.call_saved_x14)] = .{ .llvm_name = "call-saved-x14", .description = "Make X14 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x15)] = .{ + result[@backingInt(Feature.call_saved_x15)] = .{ .llvm_name = "call-saved-x15", .description = "Make X15 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x18)] = .{ + result[@backingInt(Feature.call_saved_x18)] = .{ .llvm_name = "call-saved-x18", .description = "Make X18 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x8)] = .{ + result[@backingInt(Feature.call_saved_x8)] = .{ .llvm_name = "call-saved-x8", .description = "Make X8 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_saved_x9)] = .{ + result[@backingInt(Feature.call_saved_x9)] = .{ .llvm_name = "call-saved-x9", .description = "Make X9 callee saved.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ccdp)] = .{ + result[@backingInt(Feature.ccdp)] = .{ .llvm_name = "ccdp", .description = "Enable Armv8.5-A Cache Clean to Point of Deep Persistence", .dependencies = featureSet(&[_]Feature{ .ccpp, }), }; - result[@intFromEnum(Feature.ccidx)] = .{ + result[@backingInt(Feature.ccidx)] = .{ .llvm_name = "ccidx", .description = "Enable Armv8.3-A Extend of the CCSIDR number of sets", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ccpp)] = .{ + result[@backingInt(Feature.ccpp)] = .{ .llvm_name = "ccpp", .description = "Enable Armv8.2-A data Cache Clean to Point of Persistence", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.chk)] = .{ + result[@backingInt(Feature.chk)] = .{ .llvm_name = "chk", .description = "Enable Armv8.0-A Check Feature Status Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.clrbhb)] = .{ + result[@backingInt(Feature.clrbhb)] = .{ .llvm_name = "clrbhb", .description = "Enable Clear BHB instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cmh)] = .{ + result[@backingInt(Feature.cmh)] = .{ .llvm_name = "cmh", .description = "Enable Armv9.7-A Contention Management Hints", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cmp_bcc_fusion)] = .{ + result[@backingInt(Feature.cmp_bcc_fusion)] = .{ .llvm_name = "cmp-bcc-fusion", .description = "CPU fuses cmp+bcc operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cmpbr)] = .{ + result[@backingInt(Feature.cmpbr)] = .{ .llvm_name = "cmpbr", .description = "Enable Armv9.6-A base compare and branch instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.complxnum)] = .{ + result[@backingInt(Feature.complxnum)] = .{ .llvm_name = "complxnum", .description = "Enable Armv8.3-A Floating-point complex number support", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.contextidr_el2)] = .{ + result[@backingInt(Feature.contextidr_el2)] = .{ .llvm_name = "CONTEXTIDREL2", .description = "Enable RW operand Context ID Register (EL2)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cpa)] = .{ + result[@backingInt(Feature.cpa)] = .{ .llvm_name = "cpa", .description = "Enable Armv9.5-A Checked Pointer Arithmetic", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.crc)] = .{ + result[@backingInt(Feature.crc)] = .{ .llvm_name = "crc", .description = "Enable Armv8.0-A CRC-32 checksum instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.crypto)] = .{ + result[@backingInt(Feature.crypto)] = .{ .llvm_name = "crypto", .description = "Enable cryptographic instructions", .dependencies = featureSet(&[_]Feature{ @@ -521,98 +521,98 @@ pub const all_features = blk: { .sha2, }), }; - result[@intFromEnum(Feature.cssc)] = .{ + result[@backingInt(Feature.cssc)] = .{ .llvm_name = "cssc", .description = "Enable Common Short Sequence Compression (CSSC) instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.d128)] = .{ + result[@backingInt(Feature.d128)] = .{ .llvm_name = "d128", .description = "Enable Armv9.4-A 128-bit Page Table Descriptors, System Registers and instructions", .dependencies = featureSet(&[_]Feature{ .lse128, }), }; - result[@intFromEnum(Feature.disable_fast_inc_vl)] = .{ + result[@backingInt(Feature.disable_fast_inc_vl)] = .{ .llvm_name = "disable-fast-inc-vl", .description = "Do not prefer INC/DEC, ALL, { 1, 2, 4 } over ADDVL", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_latency_sched_heuristic)] = .{ + result[@backingInt(Feature.disable_latency_sched_heuristic)] = .{ .llvm_name = "disable-latency-sched-heuristic", .description = "Disable latency scheduling heuristic", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_ldp)] = .{ + result[@backingInt(Feature.disable_ldp)] = .{ .llvm_name = "disable-ldp", .description = "Do not emit ldp", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_maximize_scalable_bandwidth)] = .{ + result[@backingInt(Feature.disable_maximize_scalable_bandwidth)] = .{ .llvm_name = "disable-maximize-scalable-bandwidth", .description = "Determine the maximum scalable vector length for a loop by the largest scalar type rather than the smallest", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_stp)] = .{ + result[@backingInt(Feature.disable_stp)] = .{ .llvm_name = "disable-stp", .description = "Do not emit stp", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_unpredicated_ld_st_lower)] = .{ + result[@backingInt(Feature.disable_unpredicated_ld_st_lower)] = .{ .llvm_name = "disable-unpredicated-ld-st-lower", .description = "Disable lowering unpredicated loads/stores as LDR/STR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dit)] = .{ + result[@backingInt(Feature.dit)] = .{ .llvm_name = "dit", .description = "Enable Armv8.4-A Data Independent Timing instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dotprod)] = .{ + result[@backingInt(Feature.dotprod)] = .{ .llvm_name = "dotprod", .description = "Enable dot product support", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.ecv)] = .{ + result[@backingInt(Feature.ecv)] = .{ .llvm_name = "ecv", .description = "Enable enhanced counter virtualization extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.el2vmsa)] = .{ + result[@backingInt(Feature.el2vmsa)] = .{ .llvm_name = "el2vmsa", .description = "Enable Exception Level 2 Virtual Memory System Architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.el3)] = .{ + result[@backingInt(Feature.el3)] = .{ .llvm_name = "el3", .description = "Enable Exception Level 3", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.enable_select_opt)] = .{ + result[@backingInt(Feature.enable_select_opt)] = .{ .llvm_name = "enable-select-opt", .description = "Enable the select optimize pass for select loop heuristics", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ete)] = .{ + result[@backingInt(Feature.ete)] = .{ .llvm_name = "ete", .description = "Enable Embedded Trace Extension", .dependencies = featureSet(&[_]Feature{ .trbe, }), }; - result[@intFromEnum(Feature.execute_only)] = .{ + result[@backingInt(Feature.execute_only)] = .{ .llvm_name = "execute-only", .description = "Enable the generation of execute only code.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.exynos_cheap_as_move)] = .{ + result[@backingInt(Feature.exynos_cheap_as_move)] = .{ .llvm_name = "exynos-cheap-as-move", .description = "Use Exynos specific handling of cheap instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.f16f32dot)] = .{ + result[@backingInt(Feature.f16f32dot)] = .{ .llvm_name = "f16f32dot", .description = "Enable Armv9.7-A Advanced SIMD half-precision dot product accumulate to single-precision", .dependencies = featureSet(&[_]Feature{ @@ -620,7 +620,7 @@ pub const all_features = blk: { .neon, }), }; - result[@intFromEnum(Feature.f16f32mm)] = .{ + result[@backingInt(Feature.f16f32mm)] = .{ .llvm_name = "f16f32mm", .description = "Enable Armv9.7-A Advanced SIMD half-precision matrix multiply-accumulate to single-precision", .dependencies = featureSet(&[_]Feature{ @@ -628,7 +628,7 @@ pub const all_features = blk: { .neon, }), }; - result[@intFromEnum(Feature.f16mm)] = .{ + result[@backingInt(Feature.f16mm)] = .{ .llvm_name = "f16mm", .description = "Enable Armv9.7-A non-widening half-precision matrix multiply-accumulate", .dependencies = featureSet(&[_]Feature{ @@ -636,67 +636,67 @@ pub const all_features = blk: { .neon, }), }; - result[@intFromEnum(Feature.f32mm)] = .{ + result[@backingInt(Feature.f32mm)] = .{ .llvm_name = "f32mm", .description = "Enable Matrix Multiply FP32 Extension", .dependencies = featureSet(&[_]Feature{ .sve, }), }; - result[@intFromEnum(Feature.f64mm)] = .{ + result[@backingInt(Feature.f64mm)] = .{ .llvm_name = "f64mm", .description = "Enable Matrix Multiply FP64 Extension", .dependencies = featureSet(&[_]Feature{ .sve, }), }; - result[@intFromEnum(Feature.f8f16mm)] = .{ + result[@backingInt(Feature.f8f16mm)] = .{ .llvm_name = "f8f16mm", .description = "Enable Armv9.6-A FP8 to Half-Precision Matrix Multiplication", .dependencies = featureSet(&[_]Feature{ .fp8, }), }; - result[@intFromEnum(Feature.f8f32mm)] = .{ + result[@backingInt(Feature.f8f32mm)] = .{ .llvm_name = "f8f32mm", .description = "Enable Armv9.6-A FP8 to Single-Precision Matrix Multiplication", .dependencies = featureSet(&[_]Feature{ .fp8, }), }; - result[@intFromEnum(Feature.faminmax)] = .{ + result[@backingInt(Feature.faminmax)] = .{ .llvm_name = "faminmax", .description = "Enable FAMIN and FAMAX instructions", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.fgt)] = .{ + result[@backingInt(Feature.fgt)] = .{ .llvm_name = "fgt", .description = "Enable fine grained virtualization traps extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_cortex_a53_835769)] = .{ + result[@backingInt(Feature.fix_cortex_a53_835769)] = .{ .llvm_name = "fix-cortex-a53-835769", .description = "Mitigate Cortex-A53 Erratum 835769", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.flagm)] = .{ + result[@backingInt(Feature.flagm)] = .{ .llvm_name = "flagm", .description = "Enable Armv8.4-A Flag Manipulation instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fmv)] = .{ + result[@backingInt(Feature.fmv)] = .{ .llvm_name = "fmv", .description = "Enable Function Multi Versioning support.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.force_32bit_jump_tables)] = .{ + result[@backingInt(Feature.force_32bit_jump_tables)] = .{ .llvm_name = "force-32bit-jump-tables", .description = "Force jump table entries to be 32-bits wide except at MinSize", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp16fml)] = .{ + result[@backingInt(Feature.fp16fml)] = .{ .llvm_name = "fp16fml", .description = "Enable FP16 FML instructions", .dependencies = featureSet(&[_]Feature{ @@ -704,59 +704,59 @@ pub const all_features = blk: { .neon, }), }; - result[@intFromEnum(Feature.fp8)] = .{ + result[@backingInt(Feature.fp8)] = .{ .llvm_name = "fp8", .description = "Enable FP8 instructions", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.fp8dot2)] = .{ + result[@backingInt(Feature.fp8dot2)] = .{ .llvm_name = "fp8dot2", .description = "Enable FP8 2-way dot instructions", .dependencies = featureSet(&[_]Feature{ .fp8, }), }; - result[@intFromEnum(Feature.fp8dot4)] = .{ + result[@backingInt(Feature.fp8dot4)] = .{ .llvm_name = "fp8dot4", .description = "Enable FP8 4-way dot instructions", .dependencies = featureSet(&[_]Feature{ .fp8, }), }; - result[@intFromEnum(Feature.fp8fma)] = .{ + result[@backingInt(Feature.fp8fma)] = .{ .llvm_name = "fp8fma", .description = "Enable Armv9.5-A FP8 multiply-add instructions", .dependencies = featureSet(&[_]Feature{ .fp8, }), }; - result[@intFromEnum(Feature.fp_armv8)] = .{ + result[@backingInt(Feature.fp_armv8)] = .{ .llvm_name = "fp-armv8", .description = "Enable Armv8.0-A Floating Point Extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpac)] = .{ + result[@backingInt(Feature.fpac)] = .{ .llvm_name = "fpac", .description = "Enable Armv8.3-A Pointer Authentication Faulting enhancement", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fprcvt)] = .{ + result[@backingInt(Feature.fprcvt)] = .{ .llvm_name = "fprcvt", .description = "Enable Armv9.6-A base convert instructions for SIMD&FP scalar register operands of different input and output sizes", .dependencies = featureSet(&[_]Feature{ .fp_armv8, }), }; - result[@intFromEnum(Feature.fptoint)] = .{ + result[@backingInt(Feature.fptoint)] = .{ .llvm_name = "fptoint", .description = "Enable FRInt[32|64][Z|X] instructions that round a floating-point number to an integer (in FP format) forcing it to fit into a 32- or 64-bit int", .dependencies = featureSet(&[_]Feature{ .fp_armv8, }), }; - result[@intFromEnum(Feature.fujitsu_monaka)] = .{ + result[@backingInt(Feature.fujitsu_monaka)] = .{ .llvm_name = "fujitsu-monaka", .description = "Fujitsu FUJITSU-MONAKA processors", .dependencies = featureSet(&[_]Feature{ @@ -766,190 +766,190 @@ pub const all_features = blk: { .use_postra_scheduler, }), }; - result[@intFromEnum(Feature.fullfp16)] = .{ + result[@backingInt(Feature.fullfp16)] = .{ .llvm_name = "fullfp16", .description = "Enable half-precision floating-point data processing", .dependencies = featureSet(&[_]Feature{ .fp_armv8, }), }; - result[@intFromEnum(Feature.fuse_address)] = .{ + result[@backingInt(Feature.fuse_address)] = .{ .llvm_name = "fuse-address", .description = "CPU fuses address generation and memory operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_addsub_2reg_const1)] = .{ + result[@backingInt(Feature.fuse_addsub_2reg_const1)] = .{ .llvm_name = "fuse-addsub-2reg-const1", .description = "CPU fuses (a + b + 1) and (a - b - 1)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_adrp_add)] = .{ + result[@backingInt(Feature.fuse_adrp_add)] = .{ .llvm_name = "fuse-adrp-add", .description = "CPU fuses adrp+add operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_aes)] = .{ + result[@backingInt(Feature.fuse_aes)] = .{ .llvm_name = "fuse-aes", .description = "CPU fuses AES crypto operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_arith_logic)] = .{ + result[@backingInt(Feature.fuse_arith_logic)] = .{ .llvm_name = "fuse-arith-logic", .description = "CPU fuses arithmetic and logic operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_crypto_eor)] = .{ + result[@backingInt(Feature.fuse_crypto_eor)] = .{ .llvm_name = "fuse-crypto-eor", .description = "CPU fuses AES/PMULL and EOR operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_csel)] = .{ + result[@backingInt(Feature.fuse_csel)] = .{ .llvm_name = "fuse-csel", .description = "CPU can fuse CMP and CSEL operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_cset)] = .{ + result[@backingInt(Feature.fuse_cset)] = .{ .llvm_name = "fuse-cset", .description = "CPU can fuse CMP and CSET operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_literals)] = .{ + result[@backingInt(Feature.fuse_literals)] = .{ .llvm_name = "fuse-literals", .description = "CPU fuses literal generation operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gcie)] = .{ + result[@backingInt(Feature.gcie)] = .{ .llvm_name = "gcie", .description = "Enable GICv5 (Generic Interrupt Controller) CPU Interface Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gcs)] = .{ + result[@backingInt(Feature.gcs)] = .{ .llvm_name = "gcs", .description = "Enable Armv9.4-A Guarded Call Stack Extension", .dependencies = featureSet(&[_]Feature{ .chk, }), }; - result[@intFromEnum(Feature.harden_sls_blr)] = .{ + result[@backingInt(Feature.harden_sls_blr)] = .{ .llvm_name = "harden-sls-blr", .description = "Harden against straight line speculation across BLR instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.harden_sls_nocomdat)] = .{ + result[@backingInt(Feature.harden_sls_nocomdat)] = .{ .llvm_name = "harden-sls-nocomdat", .description = "Generate thunk code for SLS mitigation in the normal text section", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.harden_sls_retbr)] = .{ + result[@backingInt(Feature.harden_sls_retbr)] = .{ .llvm_name = "harden-sls-retbr", .description = "Harden against straight line speculation across RET and BR instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hbc)] = .{ + result[@backingInt(Feature.hbc)] = .{ .llvm_name = "hbc", .description = "Enable Armv8.8-A Hinted Conditional Branches Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hcx)] = .{ + result[@backingInt(Feature.hcx)] = .{ .llvm_name = "hcx", .description = "Enable Armv8.7-A HCRX_EL2 system register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.i8mm)] = .{ + result[@backingInt(Feature.i8mm)] = .{ .llvm_name = "i8mm", .description = "Enable Matrix Multiply Int8 Extension", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.ite)] = .{ + result[@backingInt(Feature.ite)] = .{ .llvm_name = "ite", .description = "Enable Armv9.4-A Instrumentation Extension", .dependencies = featureSet(&[_]Feature{ .ete, }), }; - result[@intFromEnum(Feature.jsconv)] = .{ + result[@backingInt(Feature.jsconv)] = .{ .llvm_name = "jsconv", .description = "Enable Armv8.3-A JavaScript FP conversion instructions", .dependencies = featureSet(&[_]Feature{ .fp_armv8, }), }; - result[@intFromEnum(Feature.ldp_aligned_only)] = .{ + result[@backingInt(Feature.ldp_aligned_only)] = .{ .llvm_name = "ldp-aligned-only", .description = "In order to emit ldp, first check if the load will be aligned to 2 * element_size", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lor)] = .{ + result[@backingInt(Feature.lor)] = .{ .llvm_name = "lor", .description = "Enable Armv8.1-A Limited Ordering Regions extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ls64)] = .{ + result[@backingInt(Feature.ls64)] = .{ .llvm_name = "ls64", .description = "Enable Armv8.7-A LD64B/ST64B Accelerator Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lscp)] = .{ + result[@backingInt(Feature.lscp)] = .{ .llvm_name = "lscp", .description = "Enable Armv9.7-A Load-acquire and store-release pair extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lse)] = .{ + result[@backingInt(Feature.lse)] = .{ .llvm_name = "lse", .description = "Enable Armv8.1-A Large System Extension (LSE) atomic instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lse128)] = .{ + result[@backingInt(Feature.lse128)] = .{ .llvm_name = "lse128", .description = "Enable Armv9.4-A 128-bit Atomic instructions", .dependencies = featureSet(&[_]Feature{ .lse, }), }; - result[@intFromEnum(Feature.lse2)] = .{ + result[@backingInt(Feature.lse2)] = .{ .llvm_name = "lse2", .description = "Enable Armv8.4-A Large System Extension 2 (LSE2) atomicity rules", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lsfe)] = .{ + result[@backingInt(Feature.lsfe)] = .{ .llvm_name = "lsfe", .description = "Enable Armv9.6-A base Atomic floating-point in-memory instructions", .dependencies = featureSet(&[_]Feature{ .fp_armv8, }), }; - result[@intFromEnum(Feature.lsui)] = .{ + result[@backingInt(Feature.lsui)] = .{ .llvm_name = "lsui", .description = "Enable Armv9.6-A unprivileged load/store instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lut)] = .{ + result[@backingInt(Feature.lut)] = .{ .llvm_name = "lut", .description = "Enable Lookup Table instructions", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.max_interleave_factor_4)] = .{ + result[@backingInt(Feature.max_interleave_factor_4)] = .{ .llvm_name = "max-interleave-factor-4", .description = "Set the MaxInterleaveFactor to 4 (from the default 2)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mec)] = .{ + result[@backingInt(Feature.mec)] = .{ .llvm_name = "mec", .description = "Enable Memory Encryption Contexts Extension", .dependencies = featureSet(&[_]Feature{ .rme, }), }; - result[@intFromEnum(Feature.mops)] = .{ + result[@backingInt(Feature.mops)] = .{ .llvm_name = "mops", .description = "Enable Armv8.8-A memcpy and memset acceleration instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mops_go)] = .{ + result[@backingInt(Feature.mops_go)] = .{ .llvm_name = "mops-go", .description = "Enable memset acceleration granule only", .dependencies = featureSet(&[_]Feature{ @@ -957,71 +957,71 @@ pub const all_features = blk: { .mte, }), }; - result[@intFromEnum(Feature.mpam)] = .{ + result[@backingInt(Feature.mpam)] = .{ .llvm_name = "mpam", .description = "Enable Armv8.4-A Memory system Partitioning and Monitoring extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mpamv2)] = .{ + result[@backingInt(Feature.mpamv2)] = .{ .llvm_name = "mpamv2", .description = "Enable Armv9.7-A MPAMv2 Lookaside Buffer Invalidate instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mte)] = .{ + result[@backingInt(Feature.mte)] = .{ .llvm_name = "mte", .description = "Enable Memory Tagging Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mtetc)] = .{ + result[@backingInt(Feature.mtetc)] = .{ .llvm_name = "mtetc", .description = "Enable Virtual Memory Tagging Extension", .dependencies = featureSet(&[_]Feature{ .mte, }), }; - result[@intFromEnum(Feature.neon)] = .{ + result[@backingInt(Feature.neon)] = .{ .llvm_name = "neon", .description = "Enable Advanced SIMD instructions", .dependencies = featureSet(&[_]Feature{ .fp_armv8, }), }; - result[@intFromEnum(Feature.nmi)] = .{ + result[@backingInt(Feature.nmi)] = .{ .llvm_name = "nmi", .description = "Enable Armv8.8-A Non-maskable Interrupts", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_bti_at_return_twice)] = .{ + result[@backingInt(Feature.no_bti_at_return_twice)] = .{ .llvm_name = "no-bti-at-return-twice", .description = "Don't place a BTI instruction after a return-twice", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_neg_immediates)] = .{ + result[@backingInt(Feature.no_neg_immediates)] = .{ .llvm_name = "no-neg-immediates", .description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_sve_fp_ld1r)] = .{ + result[@backingInt(Feature.no_sve_fp_ld1r)] = .{ .llvm_name = "no-sve-fp-ld1r", .description = "Avoid using LD1RX instructions for FP", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_zcz_fpr64)] = .{ + result[@backingInt(Feature.no_zcz_fpr64)] = .{ .llvm_name = "no-zcz-fpr64", .description = "Has no zero-cycle zeroing instructions for FPR64 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nv)] = .{ + result[@backingInt(Feature.nv)] = .{ .llvm_name = "nv", .description = "Enable Armv8.4-A Nested Virtualization Enchancement", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.occmo)] = .{ + result[@backingInt(Feature.occmo)] = .{ .llvm_name = "occmo", .description = "Enable Armv9.6-A Outer cacheable cache maintenance operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.olympus)] = .{ + result[@backingInt(Feature.olympus)] = .{ .llvm_name = "olympus", .description = "NVIDIA Olympus processors", .dependencies = featureSet(&[_]Feature{ @@ -1036,288 +1036,288 @@ pub const all_features = blk: { .use_postra_scheduler, }), }; - result[@intFromEnum(Feature.outline_atomics)] = .{ + result[@backingInt(Feature.outline_atomics)] = .{ .llvm_name = "outline-atomics", .description = "Enable out of line atomics to support LSE instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pan)] = .{ + result[@backingInt(Feature.pan)] = .{ .llvm_name = "pan", .description = "Enable Armv8.1-A Privileged Access-Never extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pan_rwv)] = .{ + result[@backingInt(Feature.pan_rwv)] = .{ .llvm_name = "pan-rwv", .description = "Enable Armv8.2-A PAN s1e1R and s1e1W Variants", .dependencies = featureSet(&[_]Feature{ .pan, }), }; - result[@intFromEnum(Feature.pauth)] = .{ + result[@backingInt(Feature.pauth)] = .{ .llvm_name = "pauth", .description = "Enable Armv8.3-A Pointer Authentication extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pauth_lr)] = .{ + result[@backingInt(Feature.pauth_lr)] = .{ .llvm_name = "pauth-lr", .description = "Enable Armv9.5-A PAC enhancements", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pcdphint)] = .{ + result[@backingInt(Feature.pcdphint)] = .{ .llvm_name = "pcdphint", .description = "Enable Armv9.6-A Producer Consumer Data Placement hints", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.perfmon)] = .{ + result[@backingInt(Feature.perfmon)] = .{ .llvm_name = "perfmon", .description = "Enable Armv8.0-A PMUv3 Performance Monitors extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.poe2)] = .{ + result[@backingInt(Feature.poe2)] = .{ .llvm_name = "poe2", .description = "Enable Stage 1 Permission Overlays Extension 2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pops)] = .{ + result[@backingInt(Feature.pops)] = .{ .llvm_name = "pops", .description = "Enable Armv9.6-A Point Of Physical Storage (PoPS) DC instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.predictable_select_expensive)] = .{ + result[@backingInt(Feature.predictable_select_expensive)] = .{ .llvm_name = "predictable-select-expensive", .description = "Prefer likely predicted branches over selects", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.predres)] = .{ + result[@backingInt(Feature.predres)] = .{ .llvm_name = "predres", .description = "Enable Armv8.5-A execution and data prediction invalidation instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prfm_slc_target)] = .{ + result[@backingInt(Feature.prfm_slc_target)] = .{ .llvm_name = "prfm-slc-target", .description = "Enable SLC target for PRFM instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rand)] = .{ + result[@backingInt(Feature.rand)] = .{ .llvm_name = "rand", .description = "Enable Random Number generation instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ras)] = .{ + result[@backingInt(Feature.ras)] = .{ .llvm_name = "ras", .description = "Enable Armv8.0-A Reliability, Availability and Serviceability Extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rasv2)] = .{ + result[@backingInt(Feature.rasv2)] = .{ .llvm_name = "rasv2", .description = "Enable Armv8.9-A Reliability, Availability and Serviceability Extensions", .dependencies = featureSet(&[_]Feature{ .ras, }), }; - result[@intFromEnum(Feature.rcpc)] = .{ + result[@backingInt(Feature.rcpc)] = .{ .llvm_name = "rcpc", .description = "Enable support for RCPC extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rcpc3)] = .{ + result[@backingInt(Feature.rcpc3)] = .{ .llvm_name = "rcpc3", .description = "Enable Armv8.9-A RCPC instructions for A64 and Advanced SIMD and floating-point instruction set", .dependencies = featureSet(&[_]Feature{ .rcpc_immo, }), }; - result[@intFromEnum(Feature.rcpc_immo)] = .{ + result[@backingInt(Feature.rcpc_immo)] = .{ .llvm_name = "rcpc-immo", .description = "Enable Armv8.4-A RCPC instructions with Immediate Offsets", .dependencies = featureSet(&[_]Feature{ .rcpc, }), }; - result[@intFromEnum(Feature.rdm)] = .{ + result[@backingInt(Feature.rdm)] = .{ .llvm_name = "rdm", .description = "Enable Armv8.1-A Rounding Double Multiply Add/Subtract instructions", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.reserve_lr_for_ra)] = .{ + result[@backingInt(Feature.reserve_lr_for_ra)] = .{ .llvm_name = "reserve-lr-for-ra", .description = "Reserve LR for call use only", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x1)] = .{ + result[@backingInt(Feature.reserve_x1)] = .{ .llvm_name = "reserve-x1", .description = "Reserve X1, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x10)] = .{ + result[@backingInt(Feature.reserve_x10)] = .{ .llvm_name = "reserve-x10", .description = "Reserve X10, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x11)] = .{ + result[@backingInt(Feature.reserve_x11)] = .{ .llvm_name = "reserve-x11", .description = "Reserve X11, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x12)] = .{ + result[@backingInt(Feature.reserve_x12)] = .{ .llvm_name = "reserve-x12", .description = "Reserve X12, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x13)] = .{ + result[@backingInt(Feature.reserve_x13)] = .{ .llvm_name = "reserve-x13", .description = "Reserve X13, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x14)] = .{ + result[@backingInt(Feature.reserve_x14)] = .{ .llvm_name = "reserve-x14", .description = "Reserve X14, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x15)] = .{ + result[@backingInt(Feature.reserve_x15)] = .{ .llvm_name = "reserve-x15", .description = "Reserve X15, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x18)] = .{ + result[@backingInt(Feature.reserve_x18)] = .{ .llvm_name = "reserve-x18", .description = "Reserve X18, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x2)] = .{ + result[@backingInt(Feature.reserve_x2)] = .{ .llvm_name = "reserve-x2", .description = "Reserve X2, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x20)] = .{ + result[@backingInt(Feature.reserve_x20)] = .{ .llvm_name = "reserve-x20", .description = "Reserve X20, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x21)] = .{ + result[@backingInt(Feature.reserve_x21)] = .{ .llvm_name = "reserve-x21", .description = "Reserve X21, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x22)] = .{ + result[@backingInt(Feature.reserve_x22)] = .{ .llvm_name = "reserve-x22", .description = "Reserve X22, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x23)] = .{ + result[@backingInt(Feature.reserve_x23)] = .{ .llvm_name = "reserve-x23", .description = "Reserve X23, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x24)] = .{ + result[@backingInt(Feature.reserve_x24)] = .{ .llvm_name = "reserve-x24", .description = "Reserve X24, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x25)] = .{ + result[@backingInt(Feature.reserve_x25)] = .{ .llvm_name = "reserve-x25", .description = "Reserve X25, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x26)] = .{ + result[@backingInt(Feature.reserve_x26)] = .{ .llvm_name = "reserve-x26", .description = "Reserve X26, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x27)] = .{ + result[@backingInt(Feature.reserve_x27)] = .{ .llvm_name = "reserve-x27", .description = "Reserve X27, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x28)] = .{ + result[@backingInt(Feature.reserve_x28)] = .{ .llvm_name = "reserve-x28", .description = "Reserve X28, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x3)] = .{ + result[@backingInt(Feature.reserve_x3)] = .{ .llvm_name = "reserve-x3", .description = "Reserve X3, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x4)] = .{ + result[@backingInt(Feature.reserve_x4)] = .{ .llvm_name = "reserve-x4", .description = "Reserve X4, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x5)] = .{ + result[@backingInt(Feature.reserve_x5)] = .{ .llvm_name = "reserve-x5", .description = "Reserve X5, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x6)] = .{ + result[@backingInt(Feature.reserve_x6)] = .{ .llvm_name = "reserve-x6", .description = "Reserve X6, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x7)] = .{ + result[@backingInt(Feature.reserve_x7)] = .{ .llvm_name = "reserve-x7", .description = "Reserve X7, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x9)] = .{ + result[@backingInt(Feature.reserve_x9)] = .{ .llvm_name = "reserve-x9", .description = "Reserve X9, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rme)] = .{ + result[@backingInt(Feature.rme)] = .{ .llvm_name = "rme", .description = "Enable Realm Management Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sb)] = .{ + result[@backingInt(Feature.sb)] = .{ .llvm_name = "sb", .description = "Enable Armv8.5-A Speculation Barrier", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sel2)] = .{ + result[@backingInt(Feature.sel2)] = .{ .llvm_name = "sel2", .description = "Enable Armv8.4-A Secure Exception Level 2 extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sha2)] = .{ + result[@backingInt(Feature.sha2)] = .{ .llvm_name = "sha2", .description = "Enable SHA1 and SHA256 support", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.sha3)] = .{ + result[@backingInt(Feature.sha3)] = .{ .llvm_name = "sha3", .description = "Enable SHA512 and SHA3 support", .dependencies = featureSet(&[_]Feature{ .sha2, }), }; - result[@intFromEnum(Feature.slow_misaligned_128store)] = .{ + result[@backingInt(Feature.slow_misaligned_128store)] = .{ .llvm_name = "slow-misaligned-128store", .description = "Misaligned 128 bit stores are slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_paired_128)] = .{ + result[@backingInt(Feature.slow_paired_128)] = .{ .llvm_name = "slow-paired-128", .description = "Paired 128 bit loads and stores are slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_strqro_store)] = .{ + result[@backingInt(Feature.slow_strqro_store)] = .{ .llvm_name = "slow-strqro-store", .description = "STR of Q register with register offset is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm4)] = .{ + result[@backingInt(Feature.sm4)] = .{ .llvm_name = "sm4", .description = "Enable SM3 and SM4 support", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.sme)] = .{ + result[@backingInt(Feature.sme)] = .{ .llvm_name = "sme", .description = "Enable Scalable Matrix Extension (SME)", .dependencies = featureSet(&[_]Feature{ @@ -1325,35 +1325,35 @@ pub const all_features = blk: { .fullfp16, }), }; - result[@intFromEnum(Feature.sme2)] = .{ + result[@backingInt(Feature.sme2)] = .{ .llvm_name = "sme2", .description = "Enable Scalable Matrix Extension 2 (SME2) instructions", .dependencies = featureSet(&[_]Feature{ .sme, }), }; - result[@intFromEnum(Feature.sme2p1)] = .{ + result[@backingInt(Feature.sme2p1)] = .{ .llvm_name = "sme2p1", .description = "Enable Scalable Matrix Extension 2.1 instructions", .dependencies = featureSet(&[_]Feature{ .sme2, }), }; - result[@intFromEnum(Feature.sme2p2)] = .{ + result[@backingInt(Feature.sme2p2)] = .{ .llvm_name = "sme2p2", .description = "Enable Armv9.6-A Scalable Matrix Extension 2.2 instructions", .dependencies = featureSet(&[_]Feature{ .sme2p1, }), }; - result[@intFromEnum(Feature.sme2p3)] = .{ + result[@backingInt(Feature.sme2p3)] = .{ .llvm_name = "sme2p3", .description = "Enable Armv9.7-A Scalable Matrix Extension 2.3 instructions", .dependencies = featureSet(&[_]Feature{ .sme2p2, }), }; - result[@intFromEnum(Feature.sme_b16b16)] = .{ + result[@backingInt(Feature.sme_b16b16)] = .{ .llvm_name = "sme-b16b16", .description = "Enable SME2.1 ZA-targeting non-widening BFloat16 instructions", .dependencies = featureSet(&[_]Feature{ @@ -1361,21 +1361,21 @@ pub const all_features = blk: { .sve_b16b16, }), }; - result[@intFromEnum(Feature.sme_f16f16)] = .{ + result[@backingInt(Feature.sme_f16f16)] = .{ .llvm_name = "sme-f16f16", .description = "Enable SME non-widening Float16 instructions", .dependencies = featureSet(&[_]Feature{ .sme2, }), }; - result[@intFromEnum(Feature.sme_f64f64)] = .{ + result[@backingInt(Feature.sme_f64f64)] = .{ .llvm_name = "sme-f64f64", .description = "Enable Scalable Matrix Extension (SME) F64F64 instructions", .dependencies = featureSet(&[_]Feature{ .sme, }), }; - result[@intFromEnum(Feature.sme_f8f16)] = .{ + result[@backingInt(Feature.sme_f8f16)] = .{ .llvm_name = "sme-f8f16", .description = "Enable Scalable Matrix Extension (SME) F8F16 instructions", .dependencies = featureSet(&[_]Feature{ @@ -1383,7 +1383,7 @@ pub const all_features = blk: { .sme2, }), }; - result[@intFromEnum(Feature.sme_f8f32)] = .{ + result[@backingInt(Feature.sme_f8f32)] = .{ .llvm_name = "sme-f8f32", .description = "Enable Scalable Matrix Extension (SME) F8F32 instructions", .dependencies = featureSet(&[_]Feature{ @@ -1391,7 +1391,7 @@ pub const all_features = blk: { .sme2, }), }; - result[@intFromEnum(Feature.sme_fa64)] = .{ + result[@backingInt(Feature.sme_fa64)] = .{ .llvm_name = "sme-fa64", .description = "Enable the full A64 instruction set in streaming SVE mode", .dependencies = featureSet(&[_]Feature{ @@ -1399,62 +1399,62 @@ pub const all_features = blk: { .sve2, }), }; - result[@intFromEnum(Feature.sme_i16i64)] = .{ + result[@backingInt(Feature.sme_i16i64)] = .{ .llvm_name = "sme-i16i64", .description = "Enable Scalable Matrix Extension (SME) I16I64 instructions", .dependencies = featureSet(&[_]Feature{ .sme, }), }; - result[@intFromEnum(Feature.sme_lutv2)] = .{ + result[@backingInt(Feature.sme_lutv2)] = .{ .llvm_name = "sme-lutv2", .description = "Enable Scalable Matrix Extension (SME) LUTv2 instructions", .dependencies = featureSet(&[_]Feature{ .sme2, }), }; - result[@intFromEnum(Feature.sme_mop4)] = .{ + result[@backingInt(Feature.sme_mop4)] = .{ .llvm_name = "sme-mop4", .description = "Enable SME Quarter-tile outer product instructions", .dependencies = featureSet(&[_]Feature{ .sme2, }), }; - result[@intFromEnum(Feature.sme_tmop)] = .{ + result[@backingInt(Feature.sme_tmop)] = .{ .llvm_name = "sme-tmop", .description = "Enable SME Structured sparsity outer product instructions.", .dependencies = featureSet(&[_]Feature{ .sme2, }), }; - result[@intFromEnum(Feature.spe)] = .{ + result[@backingInt(Feature.spe)] = .{ .llvm_name = "spe", .description = "Enable Statistical Profiling extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.spe_eef)] = .{ + result[@backingInt(Feature.spe_eef)] = .{ .llvm_name = "spe-eef", .description = "Enable extra register in the Statistical Profiling Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.specres2)] = .{ + result[@backingInt(Feature.specres2)] = .{ .llvm_name = "specres2", .description = "Enable Speculation Restriction Instruction", .dependencies = featureSet(&[_]Feature{ .predres, }), }; - result[@intFromEnum(Feature.specrestrict)] = .{ + result[@backingInt(Feature.specrestrict)] = .{ .llvm_name = "specrestrict", .description = "Enable architectural speculation restriction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssbs)] = .{ + result[@backingInt(Feature.ssbs)] = .{ .llvm_name = "ssbs", .description = "Enable Speculative Store Bypass Safe bit", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssve_aes)] = .{ + result[@backingInt(Feature.ssve_aes)] = .{ .llvm_name = "ssve-aes", .description = "Enable Armv9.6-A SVE AES support in streaming SVE mode", .dependencies = featureSet(&[_]Feature{ @@ -1462,7 +1462,7 @@ pub const all_features = blk: { .sve_aes, }), }; - result[@intFromEnum(Feature.ssve_bitperm)] = .{ + result[@backingInt(Feature.ssve_bitperm)] = .{ .llvm_name = "ssve-bitperm", .description = "Enable Armv9.6-A SVE BitPerm support in streaming SVE mode", .dependencies = featureSet(&[_]Feature{ @@ -1470,14 +1470,14 @@ pub const all_features = blk: { .sve_bitperm, }), }; - result[@intFromEnum(Feature.ssve_fexpa)] = .{ + result[@backingInt(Feature.ssve_fexpa)] = .{ .llvm_name = "ssve-fexpa", .description = "Enable SVE FEXPA instruction in Streaming SVE mode", .dependencies = featureSet(&[_]Feature{ .sme2, }), }; - result[@intFromEnum(Feature.ssve_fp8dot2)] = .{ + result[@backingInt(Feature.ssve_fp8dot2)] = .{ .llvm_name = "ssve-fp8dot2", .description = "Enable SVE2 FP8 2-way dot product instructions", .dependencies = featureSet(&[_]Feature{ @@ -1485,7 +1485,7 @@ pub const all_features = blk: { .sme2, }), }; - result[@intFromEnum(Feature.ssve_fp8dot4)] = .{ + result[@backingInt(Feature.ssve_fp8dot4)] = .{ .llvm_name = "ssve-fp8dot4", .description = "Enable SVE2 FP8 4-way dot product instructions", .dependencies = featureSet(&[_]Feature{ @@ -1493,7 +1493,7 @@ pub const all_features = blk: { .sme2, }), }; - result[@intFromEnum(Feature.ssve_fp8fma)] = .{ + result[@backingInt(Feature.ssve_fp8fma)] = .{ .llvm_name = "ssve-fp8fma", .description = "Enable SVE2 FP8 multiply-add instructions", .dependencies = featureSet(&[_]Feature{ @@ -1501,36 +1501,36 @@ pub const all_features = blk: { .sme2, }), }; - result[@intFromEnum(Feature.store_pair_suppress)] = .{ + result[@backingInt(Feature.store_pair_suppress)] = .{ .llvm_name = "store-pair-suppress", .description = "Enable Store Pair Suppression heuristics", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.stp_aligned_only)] = .{ + result[@backingInt(Feature.stp_aligned_only)] = .{ .llvm_name = "stp-aligned-only", .description = "In order to emit stp, first check if the store will be aligned to 2 * element_size", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.strict_align)] = .{ + result[@backingInt(Feature.strict_align)] = .{ .llvm_name = "strict-align", .description = "Disallow all unaligned memory access", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sve)] = .{ + result[@backingInt(Feature.sve)] = .{ .llvm_name = "sve", .description = "Enable Scalable Vector Extension (SVE) instructions", .dependencies = featureSet(&[_]Feature{ .fullfp16, }), }; - result[@intFromEnum(Feature.sve2)] = .{ + result[@backingInt(Feature.sve2)] = .{ .llvm_name = "sve2", .description = "Enable Scalable Vector Extension 2 (SVE2) instructions", .dependencies = featureSet(&[_]Feature{ .sve, }), }; - result[@intFromEnum(Feature.sve2_aes)] = .{ + result[@backingInt(Feature.sve2_aes)] = .{ .llvm_name = "sve2-aes", .description = "Shorthand for +sve2+sve-aes", .dependencies = featureSet(&[_]Feature{ @@ -1538,7 +1538,7 @@ pub const all_features = blk: { .sve_aes, }), }; - result[@intFromEnum(Feature.sve2_bitperm)] = .{ + result[@backingInt(Feature.sve2_bitperm)] = .{ .llvm_name = "sve2-bitperm", .description = "Shorthand for +sve2+sve-bitperm", .dependencies = featureSet(&[_]Feature{ @@ -1546,7 +1546,7 @@ pub const all_features = blk: { .sve_bitperm, }), }; - result[@intFromEnum(Feature.sve2_sha3)] = .{ + result[@backingInt(Feature.sve2_sha3)] = .{ .llvm_name = "sve2-sha3", .description = "Shorthand for +sve2+sve-sha3", .dependencies = featureSet(&[_]Feature{ @@ -1554,7 +1554,7 @@ pub const all_features = blk: { .sve_sha3, }), }; - result[@intFromEnum(Feature.sve2_sm4)] = .{ + result[@backingInt(Feature.sve2_sm4)] = .{ .llvm_name = "sve2-sm4", .description = "Shorthand for +sve2+sve-sm4", .dependencies = featureSet(&[_]Feature{ @@ -1562,173 +1562,173 @@ pub const all_features = blk: { .sve_sm4, }), }; - result[@intFromEnum(Feature.sve2p1)] = .{ + result[@backingInt(Feature.sve2p1)] = .{ .llvm_name = "sve2p1", .description = "Enable Scalable Vector Extension 2.1 instructions", .dependencies = featureSet(&[_]Feature{ .sve2, }), }; - result[@intFromEnum(Feature.sve2p2)] = .{ + result[@backingInt(Feature.sve2p2)] = .{ .llvm_name = "sve2p2", .description = "Enable Armv9.6-A Scalable Vector Extension 2.2 instructions", .dependencies = featureSet(&[_]Feature{ .sve2p1, }), }; - result[@intFromEnum(Feature.sve2p3)] = .{ + result[@backingInt(Feature.sve2p3)] = .{ .llvm_name = "sve2p3", .description = "Enable Armv9.7-A Scalable Vector Extension 2.3 instructions", .dependencies = featureSet(&[_]Feature{ .sve2p2, }), }; - result[@intFromEnum(Feature.sve_aes)] = .{ + result[@backingInt(Feature.sve_aes)] = .{ .llvm_name = "sve-aes", .description = "Enable SVE AES and quadword SVE polynomial multiply instructions", .dependencies = featureSet(&[_]Feature{ .aes, }), }; - result[@intFromEnum(Feature.sve_aes2)] = .{ + result[@backingInt(Feature.sve_aes2)] = .{ .llvm_name = "sve-aes2", .description = "Enable Armv9.6-A SVE multi-vector AES and multi-vector quadword polynomial multiply instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sve_b16b16)] = .{ + result[@backingInt(Feature.sve_b16b16)] = .{ .llvm_name = "sve-b16b16", .description = "Enable SVE2 non-widening and SME2 Z-targeting non-widening BFloat16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sve_b16mm)] = .{ + result[@backingInt(Feature.sve_b16mm)] = .{ .llvm_name = "sve-b16mm", .description = "Enable Armv9.7-A SVE non-widening BFloat16 matrix multiply-accumulate", .dependencies = featureSet(&[_]Feature{ .sve, }), }; - result[@intFromEnum(Feature.sve_bfscale)] = .{ + result[@backingInt(Feature.sve_bfscale)] = .{ .llvm_name = "sve-bfscale", .description = "Enable Armv9.6-A SVE BFloat16 scaling instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sve_bitperm)] = .{ + result[@backingInt(Feature.sve_bitperm)] = .{ .llvm_name = "sve-bitperm", .description = "Enable bit permutation SVE2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sve_f16f32mm)] = .{ + result[@backingInt(Feature.sve_f16f32mm)] = .{ .llvm_name = "sve-f16f32mm", .description = "Enable Armv9.6-A FP16 to FP32 Matrix Multiply instructions", .dependencies = featureSet(&[_]Feature{ .sve, }), }; - result[@intFromEnum(Feature.sve_sha3)] = .{ + result[@backingInt(Feature.sve_sha3)] = .{ .llvm_name = "sve-sha3", .description = "Enable SVE SHA3 instructions", .dependencies = featureSet(&[_]Feature{ .sha3, }), }; - result[@intFromEnum(Feature.sve_sm4)] = .{ + result[@backingInt(Feature.sve_sm4)] = .{ .llvm_name = "sve-sm4", .description = "Enable SVE SM4 instructions", .dependencies = featureSet(&[_]Feature{ .sm4, }), }; - result[@intFromEnum(Feature.tagged_globals)] = .{ + result[@backingInt(Feature.tagged_globals)] = .{ .llvm_name = "tagged-globals", .description = "Use an instruction sequence for taking the address of a global that allows a memory tag in the upper address bits", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tev)] = .{ + result[@backingInt(Feature.tev)] = .{ .llvm_name = "tev", .description = "Enable TIndex Exception-like Vector instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.the)] = .{ + result[@backingInt(Feature.the)] = .{ .llvm_name = "the", .description = "Enable Armv8.9-A Translation Hardening Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tlb_rmi)] = .{ + result[@backingInt(Feature.tlb_rmi)] = .{ .llvm_name = "tlb-rmi", .description = "Enable Armv8.4-A TLB Range and Maintenance instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tlbid)] = .{ + result[@backingInt(Feature.tlbid)] = .{ .llvm_name = "tlbid", .description = "Enable Armv9.7-A TLBI Domains extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tlbiw)] = .{ + result[@backingInt(Feature.tlbiw)] = .{ .llvm_name = "tlbiw", .description = "Enable Armv9.5-A TLBI VMALL for Dirty State", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tpidr_el1)] = .{ + result[@backingInt(Feature.tpidr_el1)] = .{ .llvm_name = "tpidr-el1", .description = "Permit use of TPIDR_EL1 for the TLS base", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tpidr_el2)] = .{ + result[@backingInt(Feature.tpidr_el2)] = .{ .llvm_name = "tpidr-el2", .description = "Permit use of TPIDR_EL2 for the TLS base", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tpidr_el3)] = .{ + result[@backingInt(Feature.tpidr_el3)] = .{ .llvm_name = "tpidr-el3", .description = "Permit use of TPIDR_EL3 for the TLS base", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tpidrro_el0)] = .{ + result[@backingInt(Feature.tpidrro_el0)] = .{ .llvm_name = "tpidrro-el0", .description = "Permit use of TPIDRRO_EL0 for the TLS base", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tracev8_4)] = .{ + result[@backingInt(Feature.tracev8_4)] = .{ .llvm_name = "tracev8.4", .description = "Enable Armv8.4-A Trace extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.trbe)] = .{ + result[@backingInt(Feature.trbe)] = .{ .llvm_name = "trbe", .description = "Enable Trace Buffer Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.uaops)] = .{ + result[@backingInt(Feature.uaops)] = .{ .llvm_name = "uaops", .description = "Enable Armv8.2-A UAO PState", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_experimental_zeroing_pseudos)] = .{ + result[@backingInt(Feature.use_experimental_zeroing_pseudos)] = .{ .llvm_name = "use-experimental-zeroing-pseudos", .description = "Hint to the compiler that the MOVPRFX instruction is merged with destructive operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_fixed_over_scalable_if_equal_cost)] = .{ + result[@backingInt(Feature.use_fixed_over_scalable_if_equal_cost)] = .{ .llvm_name = "use-fixed-over-scalable-if-equal-cost", .description = "Prefer fixed width loop vectorization over scalable if the cost-model assigns equal costs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_postra_scheduler)] = .{ + result[@backingInt(Feature.use_postra_scheduler)] = .{ .llvm_name = "use-postra-scheduler", .description = "Schedule again after register allocation", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_reciprocal_square_root)] = .{ + result[@backingInt(Feature.use_reciprocal_square_root)] = .{ .llvm_name = "use-reciprocal-square-root", .description = "Use the reciprocal square root approximation", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_wzr_to_vec_move)] = .{ + result[@backingInt(Feature.use_wzr_to_vec_move)] = .{ .llvm_name = "use-wzr-to-vec-move", .description = "Move from WZR to insert 0 into vector registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v8_1a)] = .{ + result[@backingInt(Feature.v8_1a)] = .{ .llvm_name = "v8.1a", .description = "Support ARM v8.1a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1741,7 +1741,7 @@ pub const all_features = blk: { .vh, }), }; - result[@intFromEnum(Feature.v8_2a)] = .{ + result[@backingInt(Feature.v8_2a)] = .{ .llvm_name = "v8.2a", .description = "Support ARM v8.2a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1752,7 +1752,7 @@ pub const all_features = blk: { .v8_1a, }), }; - result[@intFromEnum(Feature.v8_3a)] = .{ + result[@backingInt(Feature.v8_3a)] = .{ .llvm_name = "v8.3a", .description = "Support ARM v8.3a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1764,7 +1764,7 @@ pub const all_features = blk: { .v8_2a, }), }; - result[@intFromEnum(Feature.v8_4a)] = .{ + result[@backingInt(Feature.v8_4a)] = .{ .llvm_name = "v8.4a", .description = "Support ARM v8.4a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1782,7 +1782,7 @@ pub const all_features = blk: { .v8_3a, }), }; - result[@intFromEnum(Feature.v8_5a)] = .{ + result[@backingInt(Feature.v8_5a)] = .{ .llvm_name = "v8.5a", .description = "Support ARM v8.5a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1797,7 +1797,7 @@ pub const all_features = blk: { .v8_4a, }), }; - result[@intFromEnum(Feature.v8_6a)] = .{ + result[@backingInt(Feature.v8_6a)] = .{ .llvm_name = "v8.6a", .description = "Support ARM v8.6a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1809,7 +1809,7 @@ pub const all_features = blk: { .v8_5a, }), }; - result[@intFromEnum(Feature.v8_7a)] = .{ + result[@backingInt(Feature.v8_7a)] = .{ .llvm_name = "v8.7a", .description = "Support ARM v8.7a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1820,7 +1820,7 @@ pub const all_features = blk: { .xs, }), }; - result[@intFromEnum(Feature.v8_8a)] = .{ + result[@backingInt(Feature.v8_8a)] = .{ .llvm_name = "v8.8a", .description = "Support ARM v8.8a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1830,7 +1830,7 @@ pub const all_features = blk: { .v8_7a, }), }; - result[@intFromEnum(Feature.v8_9a)] = .{ + result[@backingInt(Feature.v8_9a)] = .{ .llvm_name = "v8.9a", .description = "Support ARM v8.9a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1843,7 +1843,7 @@ pub const all_features = blk: { .v8_8a, }), }; - result[@intFromEnum(Feature.v8a)] = .{ + result[@backingInt(Feature.v8a)] = .{ .llvm_name = "v8a", .description = "Support ARM v8a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1852,7 +1852,7 @@ pub const all_features = blk: { .neon, }), }; - result[@intFromEnum(Feature.v8r)] = .{ + result[@backingInt(Feature.v8r)] = .{ .llvm_name = "v8r", .description = "Support ARM v8r architecture", .dependencies = featureSet(&[_]Feature{ @@ -1881,7 +1881,7 @@ pub const all_features = blk: { .uaops, }), }; - result[@intFromEnum(Feature.v9_1a)] = .{ + result[@backingInt(Feature.v9_1a)] = .{ .llvm_name = "v9.1a", .description = "Support ARM v9.1a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1890,7 +1890,7 @@ pub const all_features = blk: { .v9a, }), }; - result[@intFromEnum(Feature.v9_2a)] = .{ + result[@backingInt(Feature.v9_2a)] = .{ .llvm_name = "v9.2a", .description = "Support ARM v9.2a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1899,7 +1899,7 @@ pub const all_features = blk: { .v9_1a, }), }; - result[@intFromEnum(Feature.v9_3a)] = .{ + result[@backingInt(Feature.v9_3a)] = .{ .llvm_name = "v9.3a", .description = "Support ARM v9.3a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1907,7 +1907,7 @@ pub const all_features = blk: { .v9_2a, }), }; - result[@intFromEnum(Feature.v9_4a)] = .{ + result[@backingInt(Feature.v9_4a)] = .{ .llvm_name = "v9.4a", .description = "Support ARM v9.4a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1916,7 +1916,7 @@ pub const all_features = blk: { .v9_3a, }), }; - result[@intFromEnum(Feature.v9_5a)] = .{ + result[@backingInt(Feature.v9_5a)] = .{ .llvm_name = "v9.5a", .description = "Support ARM v9.5a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1926,7 +1926,7 @@ pub const all_features = blk: { .v9_4a, }), }; - result[@intFromEnum(Feature.v9_6a)] = .{ + result[@backingInt(Feature.v9_6a)] = .{ .llvm_name = "v9.6a", .description = "Support ARM v9.6a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1936,7 +1936,7 @@ pub const all_features = blk: { .v9_5a, }), }; - result[@intFromEnum(Feature.v9_7a)] = .{ + result[@backingInt(Feature.v9_7a)] = .{ .llvm_name = "v9.7a", .description = "Support ARM v9.7a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1946,7 +1946,7 @@ pub const all_features = blk: { .v9_6a, }), }; - result[@intFromEnum(Feature.v9a)] = .{ + result[@backingInt(Feature.v9a)] = .{ .llvm_name = "v9a", .description = "Support ARM v9a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1954,64 +1954,64 @@ pub const all_features = blk: { .v8_5a, }), }; - result[@intFromEnum(Feature.vh)] = .{ + result[@backingInt(Feature.vh)] = .{ .llvm_name = "vh", .description = "Enable Armv8.1-A Virtual Host extension", .dependencies = featureSet(&[_]Feature{ .contextidr_el2, }), }; - result[@intFromEnum(Feature.wfxt)] = .{ + result[@backingInt(Feature.wfxt)] = .{ .llvm_name = "wfxt", .description = "Enable Armv8.7-A WFET and WFIT instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xs)] = .{ + result[@backingInt(Feature.xs)] = .{ .llvm_name = "xs", .description = "Enable Armv8.7-A limited-TLB-maintenance instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcm_fpr128)] = .{ + result[@backingInt(Feature.zcm_fpr128)] = .{ .llvm_name = "zcm-fpr128", .description = "Has zero-cycle register moves for FPR128 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcm_fpr32)] = .{ + result[@backingInt(Feature.zcm_fpr32)] = .{ .llvm_name = "zcm-fpr32", .description = "Has zero-cycle register moves for FPR32 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcm_fpr64)] = .{ + result[@backingInt(Feature.zcm_fpr64)] = .{ .llvm_name = "zcm-fpr64", .description = "Has zero-cycle register moves for FPR64 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcm_gpr32)] = .{ + result[@backingInt(Feature.zcm_gpr32)] = .{ .llvm_name = "zcm-gpr32", .description = "Has zero-cycle register moves for GPR32 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcm_gpr64)] = .{ + result[@backingInt(Feature.zcm_gpr64)] = .{ .llvm_name = "zcm-gpr64", .description = "Has zero-cycle register moves for GPR64 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcz_fp_workaround)] = .{ + result[@backingInt(Feature.zcz_fp_workaround)] = .{ .llvm_name = "zcz-fp-workaround", .description = "The zero-cycle floating-point zeroing instruction has a bug", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcz_fpr128)] = .{ + result[@backingInt(Feature.zcz_fpr128)] = .{ .llvm_name = "zcz-fpr128", .description = "Has zero-cycle zeroing instructions for FPR128 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcz_gpr32)] = .{ + result[@backingInt(Feature.zcz_gpr32)] = .{ .llvm_name = "zcz-gpr32", .description = "Has zero-cycle zeroing instructions for GPR32 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcz_gpr64)] = .{ + result[@backingInt(Feature.zcz_gpr64)] = .{ .llvm_name = "zcz-gpr64", .description = "Has zero-cycle zeroing instructions for GPR64 registers", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/alpha.zig b/lib/std/Target/alpha.zig index 9403735aa97c4f0962ebc0035cc50d3cd42e6dc2..77ae33b0c419342d5d7645a850691f02f49db991 100644 --- a/lib/std/Target/alpha.zig +++ b/lib/std/Target/alpha.zig @@ -20,22 +20,22 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.bwx)] = .{ + result[@backingInt(Feature.bwx)] = .{ .llvm_name = null, .description = "Enable byte/word extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cix)] = .{ + result[@backingInt(Feature.cix)] = .{ .llvm_name = null, .description = "Enable counting extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix)] = .{ + result[@backingInt(Feature.fix)] = .{ .llvm_name = null, .description = "Enable floating point move and square root extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.max)] = .{ + result[@backingInt(Feature.max)] = .{ .llvm_name = null, .description = "Enable motion video extensions", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/amdgcn.zig b/lib/std/Target/amdgcn.zig index 7f7355dacac67dfef7525c5390d62009bba4e89c..b5b9108213a0c7fd3bc5abddbd7aca3ee90cbca1 100644 --- a/lib/std/Target/amdgcn.zig +++ b/lib/std/Target/amdgcn.zig @@ -271,556 +271,556 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"1024_addressable_vgprs")] = .{ + result[@backingInt(Feature.@"1024_addressable_vgprs")] = .{ .llvm_name = "1024-addressable-vgprs", .description = "Has 1024 addressable VGPRs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"16_bit_insts")] = .{ + result[@backingInt(Feature.@"16_bit_insts")] = .{ .llvm_name = "16-bit-insts", .description = "Has i16/f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"45_bit_num_records_buffer_resource")] = .{ + result[@backingInt(Feature.@"45_bit_num_records_buffer_resource")] = .{ .llvm_name = "45-bit-num-records-buffer-resource", .description = "The buffer resource (V#) supports 45-bit num_records", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"64_bit_literals")] = .{ + result[@backingInt(Feature.@"64_bit_literals")] = .{ .llvm_name = "64-bit-literals", .description = "Can use 64-bit literals with single DWORD instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.a16)] = .{ + result[@backingInt(Feature.a16)] = .{ .llvm_name = "a16", .description = "Support A16 for 16-bit coordinates/gradients/lod/clamp/mip image operands", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.add_min_max_insts)] = .{ + result[@backingInt(Feature.add_min_max_insts)] = .{ .llvm_name = "add-min-max-insts", .description = "Has v_add_{min|max}_{i|u}32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.add_no_carry_insts)] = .{ + result[@backingInt(Feature.add_no_carry_insts)] = .{ .llvm_name = "add-no-carry-insts", .description = "Have VALU add/sub instructions without carry out", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.add_sub_u64_insts)] = .{ + result[@backingInt(Feature.add_sub_u64_insts)] = .{ .llvm_name = "add-sub-u64-insts", .description = "Has v_add_u64 and v_sub_u64 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.addressablelocalmemorysize163840)] = .{ + result[@backingInt(Feature.addressablelocalmemorysize163840)] = .{ .llvm_name = "addressablelocalmemorysize163840", .description = "The size of local memory in bytes", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.addressablelocalmemorysize32768)] = .{ + result[@backingInt(Feature.addressablelocalmemorysize32768)] = .{ .llvm_name = "addressablelocalmemorysize32768", .description = "The size of local memory in bytes", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.addressablelocalmemorysize327680)] = .{ + result[@backingInt(Feature.addressablelocalmemorysize327680)] = .{ .llvm_name = "addressablelocalmemorysize327680", .description = "The size of local memory in bytes", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.addressablelocalmemorysize65536)] = .{ + result[@backingInt(Feature.addressablelocalmemorysize65536)] = .{ .llvm_name = "addressablelocalmemorysize65536", .description = "The size of local memory in bytes", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.agent_scope_fine_grained_remote_memory_atomics)] = .{ + result[@backingInt(Feature.agent_scope_fine_grained_remote_memory_atomics)] = .{ .llvm_name = "agent-scope-fine-grained-remote-memory-atomics", .description = "Agent (device) scoped atomic operations, excluding those directly supported by PCIe (i.e. integer atomic add, exchange, and compare-and-swap), are functional for allocations in host or peer device memory.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.allocate1_5xvgprs)] = .{ + result[@backingInt(Feature.allocate1_5xvgprs)] = .{ .llvm_name = "allocate1_5xvgprs", .description = "Has 50% more physical VGPRs and 50% larger allocation granule", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.aperture_regs)] = .{ + result[@backingInt(Feature.aperture_regs)] = .{ .llvm_name = "aperture-regs", .description = "Has Memory Aperture Base and Size Registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.architected_flat_scratch)] = .{ + result[@backingInt(Feature.architected_flat_scratch)] = .{ .llvm_name = "architected-flat-scratch", .description = "Flat Scratch register is a readonly SPI initialized architected register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.architected_sgprs)] = .{ + result[@backingInt(Feature.architected_sgprs)] = .{ .llvm_name = "architected-sgprs", .description = "Enable the architected SGPRs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ashr_pk_insts)] = .{ + result[@backingInt(Feature.ashr_pk_insts)] = .{ .llvm_name = "ashr-pk-insts", .description = "Has Arithmetic Shift Pack instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.assembler_permissive_wavesize)] = .{ + result[@backingInt(Feature.assembler_permissive_wavesize)] = .{ .llvm_name = "assembler-permissive-wavesize", .description = "allow parsing wave32 and wave64 variants of instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.atomic_buffer_global_pk_add_f16_insts)] = .{ + result[@backingInt(Feature.atomic_buffer_global_pk_add_f16_insts)] = .{ .llvm_name = "atomic-buffer-global-pk-add-f16-insts", .description = "Has buffer_atomic_pk_add_f16 and global_atomic_pk_add_f16 instructions that can return original value", .dependencies = featureSet(&[_]Feature{ .flat_global_insts, }), }; - result[@intFromEnum(Feature.atomic_buffer_global_pk_add_f16_no_rtn_insts)] = .{ + result[@backingInt(Feature.atomic_buffer_global_pk_add_f16_no_rtn_insts)] = .{ .llvm_name = "atomic-buffer-global-pk-add-f16-no-rtn-insts", .description = "Has buffer_atomic_pk_add_f16 and global_atomic_pk_add_f16 instructions that don't return original value", .dependencies = featureSet(&[_]Feature{ .flat_global_insts, }), }; - result[@intFromEnum(Feature.atomic_buffer_pk_add_bf16_inst)] = .{ + result[@backingInt(Feature.atomic_buffer_pk_add_bf16_inst)] = .{ .llvm_name = "atomic-buffer-pk-add-bf16-inst", .description = "Has buffer_atomic_pk_add_bf16 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.atomic_csub_no_rtn_insts)] = .{ + result[@backingInt(Feature.atomic_csub_no_rtn_insts)] = .{ .llvm_name = "atomic-csub-no-rtn-insts", .description = "Has buffer_atomic_csub and global_atomic_csub instructions that don't return original value", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.atomic_ds_pk_add_16_insts)] = .{ + result[@backingInt(Feature.atomic_ds_pk_add_16_insts)] = .{ .llvm_name = "atomic-ds-pk-add-16-insts", .description = "Has ds_pk_add_bf16, ds_pk_add_f16, ds_pk_add_rtn_bf16, ds_pk_add_rtn_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.atomic_fadd_no_rtn_insts)] = .{ + result[@backingInt(Feature.atomic_fadd_no_rtn_insts)] = .{ .llvm_name = "atomic-fadd-no-rtn-insts", .description = "Has buffer_atomic_add_f32 and global_atomic_add_f32 instructions that don't return original value", .dependencies = featureSet(&[_]Feature{ .flat_global_insts, }), }; - result[@intFromEnum(Feature.atomic_fadd_rtn_insts)] = .{ + result[@backingInt(Feature.atomic_fadd_rtn_insts)] = .{ .llvm_name = "atomic-fadd-rtn-insts", .description = "Has buffer_atomic_add_f32 and global_atomic_add_f32 instructions that return original value", .dependencies = featureSet(&[_]Feature{ .flat_global_insts, }), }; - result[@intFromEnum(Feature.atomic_flat_pk_add_16_insts)] = .{ + result[@backingInt(Feature.atomic_flat_pk_add_16_insts)] = .{ .llvm_name = "atomic-flat-pk-add-16-insts", .description = "Has flat_atomic_pk_add_f16 and flat_atomic_pk_add_bf16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.atomic_fmin_fmax_flat_f32)] = .{ + result[@backingInt(Feature.atomic_fmin_fmax_flat_f32)] = .{ .llvm_name = "atomic-fmin-fmax-flat-f32", .description = "Has flat memory instructions for atomicrmw fmin/fmax for float", .dependencies = featureSet(&[_]Feature{ .flat_address_space, }), }; - result[@intFromEnum(Feature.atomic_fmin_fmax_flat_f64)] = .{ + result[@backingInt(Feature.atomic_fmin_fmax_flat_f64)] = .{ .llvm_name = "atomic-fmin-fmax-flat-f64", .description = "Has flat memory instructions for atomicrmw fmin/fmax for double", .dependencies = featureSet(&[_]Feature{ .flat_address_space, }), }; - result[@intFromEnum(Feature.atomic_fmin_fmax_global_f32)] = .{ + result[@backingInt(Feature.atomic_fmin_fmax_global_f32)] = .{ .llvm_name = "atomic-fmin-fmax-global-f32", .description = "Has global/buffer instructions for atomicrmw fmin/fmax for float", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.atomic_fmin_fmax_global_f64)] = .{ + result[@backingInt(Feature.atomic_fmin_fmax_global_f64)] = .{ .llvm_name = "atomic-fmin-fmax-global-f64", .description = "Has global/buffer instructions for atomicrmw fmin/fmax for float", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.atomic_global_pk_add_bf16_inst)] = .{ + result[@backingInt(Feature.atomic_global_pk_add_bf16_inst)] = .{ .llvm_name = "atomic-global-pk-add-bf16-inst", .description = "Has global_atomic_pk_add_bf16 instruction", .dependencies = featureSet(&[_]Feature{ .flat_global_insts, }), }; - result[@intFromEnum(Feature.auto_waitcnt_before_barrier)] = .{ + result[@backingInt(Feature.auto_waitcnt_before_barrier)] = .{ .llvm_name = "auto-waitcnt-before-barrier", .description = "Hardware automatically inserts waitcnt before barrier", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.back_off_barrier)] = .{ + result[@backingInt(Feature.back_off_barrier)] = .{ .llvm_name = "back-off-barrier", .description = "Hardware supports backing off s_barrier if an exception occurs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bf16_cvt_insts)] = .{ + result[@backingInt(Feature.bf16_cvt_insts)] = .{ .llvm_name = "bf16-cvt-insts", .description = "Has bf16 conversion instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bf16_pk_insts)] = .{ + result[@backingInt(Feature.bf16_pk_insts)] = .{ .llvm_name = "bf16-pk-insts", .description = "Has bf16 packed instructions (fma, add, mul, max, min)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bf16_trans_insts)] = .{ + result[@backingInt(Feature.bf16_trans_insts)] = .{ .llvm_name = "bf16-trans-insts", .description = "Has bf16 transcendental instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bf8_cvt_scale_insts)] = .{ + result[@backingInt(Feature.bf8_cvt_scale_insts)] = .{ .llvm_name = "bf8-cvt-scale-insts", .description = "Has bf8 conversion scale instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bitop3_insts)] = .{ + result[@backingInt(Feature.bitop3_insts)] = .{ .llvm_name = "bitop3-insts", .description = "Has v_bitop3_b32/v_bitop3_b16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.block_vgpr_csr)] = .{ + result[@backingInt(Feature.block_vgpr_csr)] = .{ .llvm_name = "block-vgpr-csr", .description = "Use block load/store for VGPR callee saved registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bvh_dual_bvh_8_insts)] = .{ + result[@backingInt(Feature.bvh_dual_bvh_8_insts)] = .{ .llvm_name = "bvh-dual-bvh-8-insts", .description = "Has image_bvh_dual_intersect_ray and image_bvh8_intersect_ray instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ci_insts)] = .{ + result[@backingInt(Feature.ci_insts)] = .{ .llvm_name = "ci-insts", .description = "Additional instructions for CI+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.clusters)] = .{ + result[@backingInt(Feature.clusters)] = .{ .llvm_name = "clusters", .description = "Has clusters of workgroups support", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cube_insts)] = .{ + result[@backingInt(Feature.cube_insts)] = .{ .llvm_name = "cube-insts", .description = "Has v_cube* instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cumode)] = .{ + result[@backingInt(Feature.cumode)] = .{ .llvm_name = "cumode", .description = "Enable CU wavefront execution mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cvt_fp8_vop1_bug)] = .{ + result[@backingInt(Feature.cvt_fp8_vop1_bug)] = .{ .llvm_name = "cvt-fp8-vop1-bug", .description = "FP8/BF8 VOP1 form of conversion to F32 is unreliable", .dependencies = featureSet(&[_]Feature{ .fp8_conversion_insts, }), }; - result[@intFromEnum(Feature.cvt_norm_insts)] = .{ + result[@backingInt(Feature.cvt_norm_insts)] = .{ .llvm_name = "cvt-norm-insts", .description = "Has v_cvt_norm* instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cvt_pk_f16_f32_inst)] = .{ + result[@backingInt(Feature.cvt_pk_f16_f32_inst)] = .{ .llvm_name = "cvt-pk-f16-f32-inst", .description = "Has cvt_pk_f16_f32 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cvt_pknorm_vop2_insts)] = .{ + result[@backingInt(Feature.cvt_pknorm_vop2_insts)] = .{ .llvm_name = "cvt-pknorm-vop2-insts", .description = "Has v_cvt_pk_norm_*f32 instructions/Has v_cvt_pk_norm_*_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cvt_pknorm_vop3_insts)] = .{ + result[@backingInt(Feature.cvt_pknorm_vop3_insts)] = .{ .llvm_name = "cvt-pknorm-vop3-insts", .description = "Has v_cvt_pk_norm_*f32 instructions/Has v_cvt_pk_norm_*_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.d16_write_vgpr32)] = .{ + result[@backingInt(Feature.d16_write_vgpr32)] = .{ .llvm_name = "d16-write-vgpr32", .description = "D16 instructions potentially have 32-bit data dependencies", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.default_component_broadcast)] = .{ + result[@backingInt(Feature.default_component_broadcast)] = .{ .llvm_name = "default-component-broadcast", .description = "BUFFER/IMAGE store instructions set unspecified components to x component (GFX12)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.default_component_zero)] = .{ + result[@backingInt(Feature.default_component_zero)] = .{ .llvm_name = "default-component-zero", .description = "BUFFER/IMAGE store instructions set unspecified components to zero (before GFX12)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dl_insts)] = .{ + result[@backingInt(Feature.dl_insts)] = .{ .llvm_name = "dl-insts", .description = "Has v_fmac_f32 and v_xnor_b32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot10_insts)] = .{ + result[@backingInt(Feature.dot10_insts)] = .{ .llvm_name = "dot10-insts", .description = "Has v_dot2_f32_f16 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot11_insts)] = .{ + result[@backingInt(Feature.dot11_insts)] = .{ .llvm_name = "dot11-insts", .description = "Has v_dot4_f32_fp8_fp8, v_dot4_f32_fp8_bf8, v_dot4_f32_bf8_fp8, v_dot4_f32_bf8_bf8 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot12_insts)] = .{ + result[@backingInt(Feature.dot12_insts)] = .{ .llvm_name = "dot12-insts", .description = "Has v_dot2_f32_bf16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot13_insts)] = .{ + result[@backingInt(Feature.dot13_insts)] = .{ .llvm_name = "dot13-insts", .description = "Has v_dot2c_f32_bf16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot1_insts)] = .{ + result[@backingInt(Feature.dot1_insts)] = .{ .llvm_name = "dot1-insts", .description = "Has v_dot4_i32_i8 and v_dot8_i32_i4 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot2_insts)] = .{ + result[@backingInt(Feature.dot2_insts)] = .{ .llvm_name = "dot2-insts", .description = "Has v_dot2_i32_i16, v_dot2_u32_u16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot3_insts)] = .{ + result[@backingInt(Feature.dot3_insts)] = .{ .llvm_name = "dot3-insts", .description = "Has v_dot8c_i32_i4 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot4_insts)] = .{ + result[@backingInt(Feature.dot4_insts)] = .{ .llvm_name = "dot4-insts", .description = "Has v_dot2c_i32_i16 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot5_insts)] = .{ + result[@backingInt(Feature.dot5_insts)] = .{ .llvm_name = "dot5-insts", .description = "Has v_dot2c_f32_f16 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot6_insts)] = .{ + result[@backingInt(Feature.dot6_insts)] = .{ .llvm_name = "dot6-insts", .description = "Has v_dot4c_i32_i8 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot7_insts)] = .{ + result[@backingInt(Feature.dot7_insts)] = .{ .llvm_name = "dot7-insts", .description = "Has v_dot4_u32_u8, v_dot8_u32_u4 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot8_insts)] = .{ + result[@backingInt(Feature.dot8_insts)] = .{ .llvm_name = "dot8-insts", .description = "Has v_dot4_i32_iu8, v_dot8_i32_iu4 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dot9_insts)] = .{ + result[@backingInt(Feature.dot9_insts)] = .{ .llvm_name = "dot9-insts", .description = "Has v_dot2_f16_f16, v_dot2_bf16_bf16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dpp)] = .{ + result[@backingInt(Feature.dpp)] = .{ .llvm_name = "dpp", .description = "Support DPP (Data Parallel Primitives) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dpp8)] = .{ + result[@backingInt(Feature.dpp8)] = .{ .llvm_name = "dpp8", .description = "Support DPP8 (Data Parallel Primitives) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dpp_64bit)] = .{ + result[@backingInt(Feature.dpp_64bit)] = .{ .llvm_name = "dpp-64bit", .description = "Support DPP (Data Parallel Primitives) extension in DP ALU", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dpp_src1_sgpr)] = .{ + result[@backingInt(Feature.dpp_src1_sgpr)] = .{ .llvm_name = "dpp-src1-sgpr", .description = "Support SGPR for Src1 of DPP instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ds128)] = .{ + result[@backingInt(Feature.ds128)] = .{ .llvm_name = "enable-ds128", .description = "Use ds_{read|write}_b128", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ds_src2_insts)] = .{ + result[@backingInt(Feature.ds_src2_insts)] = .{ .llvm_name = "ds-src2-insts", .description = "Has ds_*_src2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.emulated_system_scope_atomics)] = .{ + result[@backingInt(Feature.emulated_system_scope_atomics)] = .{ .llvm_name = "emulated-system-scope-atomics", .description = "System scope atomics unsupported by the PCI-e are emulated in HW via CAS loop and functional.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.extended_image_insts)] = .{ + result[@backingInt(Feature.extended_image_insts)] = .{ .llvm_name = "extended-image-insts", .description = "Support mips != 0, lod != 0, gather4, and get_lod", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.f16bf16_to_fp6bf6_cvt_scale_insts)] = .{ + result[@backingInt(Feature.f16bf16_to_fp6bf6_cvt_scale_insts)] = .{ .llvm_name = "f16bf16-to-fp6bf6-cvt-scale-insts", .description = "Has f16bf16 to fp6bf6 conversion scale instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.f32_to_f16bf16_cvt_sr_insts)] = .{ + result[@backingInt(Feature.f32_to_f16bf16_cvt_sr_insts)] = .{ .llvm_name = "f32-to-f16bf16-cvt-sr-insts", .description = "Has f32 to f16bf16 conversion scale instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_denormal_f32)] = .{ + result[@backingInt(Feature.fast_denormal_f32)] = .{ .llvm_name = "fast-denormal-f32", .description = "Enabling denormals does not cause f32 instructions to run at f64 rates", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_fmaf)] = .{ + result[@backingInt(Feature.fast_fmaf)] = .{ .llvm_name = "fast-fmaf", .description = "Assuming f32 fma is at least as fast as mul + add", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.flat_address_space)] = .{ + result[@backingInt(Feature.flat_address_space)] = .{ .llvm_name = "flat-address-space", .description = "Support flat address space", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.flat_atomic_fadd_f32_inst)] = .{ + result[@backingInt(Feature.flat_atomic_fadd_f32_inst)] = .{ .llvm_name = "flat-atomic-fadd-f32-inst", .description = "Has flat_atomic_add_f32 instruction", .dependencies = featureSet(&[_]Feature{ .flat_address_space, }), }; - result[@intFromEnum(Feature.flat_buffer_global_fadd_f64_inst)] = .{ + result[@backingInt(Feature.flat_buffer_global_fadd_f64_inst)] = .{ .llvm_name = "flat-buffer-global-fadd-f64-inst", .description = "Has flat, buffer, and global instructions for f64 atomic fadd", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.flat_for_global)] = .{ + result[@backingInt(Feature.flat_for_global)] = .{ .llvm_name = "flat-for-global", .description = "Force to generate flat instruction for global", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.flat_global_insts)] = .{ + result[@backingInt(Feature.flat_global_insts)] = .{ .llvm_name = "flat-global-insts", .description = "Have global_* flat memory instructions", .dependencies = featureSet(&[_]Feature{ .flat_address_space, }), }; - result[@intFromEnum(Feature.flat_gvs_mode)] = .{ + result[@backingInt(Feature.flat_gvs_mode)] = .{ .llvm_name = "flat-gvs-mode", .description = "Have GVS addressing mode with flat_* instructions", .dependencies = featureSet(&[_]Feature{ .flat_address_space, }), }; - result[@intFromEnum(Feature.flat_inst_offsets)] = .{ + result[@backingInt(Feature.flat_inst_offsets)] = .{ .llvm_name = "flat-inst-offsets", .description = "Flat instructions have immediate offset addressing mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.flat_scratch)] = .{ + result[@backingInt(Feature.flat_scratch)] = .{ .llvm_name = "enable-flat-scratch", .description = "Use scratch_* flat memory instructions to access scratch", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.flat_scratch_insts)] = .{ + result[@backingInt(Feature.flat_scratch_insts)] = .{ .llvm_name = "flat-scratch-insts", .description = "Have scratch_* flat memory instructions", .dependencies = featureSet(&[_]Feature{ .flat_address_space, }), }; - result[@intFromEnum(Feature.flat_segment_offset_bug)] = .{ + result[@backingInt(Feature.flat_segment_offset_bug)] = .{ .llvm_name = "flat-segment-offset-bug", .description = "GFX10 bug where inst_offset is ignored when flat instructions access global memory", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fma_mix_bf16_insts)] = .{ + result[@backingInt(Feature.fma_mix_bf16_insts)] = .{ .llvm_name = "fma-mix-bf16-insts", .description = "Has v_fma_mix_f32_bf16, v_fma_mixlo_bf16, v_fma_mixhi_bf16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fma_mix_insts)] = .{ + result[@backingInt(Feature.fma_mix_insts)] = .{ .llvm_name = "fma-mix-insts", .description = "Has v_fma_mix_f32, v_fma_mixlo_f16, v_fma_mixhi_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fmacf64_inst)] = .{ + result[@backingInt(Feature.fmacf64_inst)] = .{ .llvm_name = "fmacf64-inst", .description = "Has v_fmac_f64 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fmaf)] = .{ + result[@backingInt(Feature.fmaf)] = .{ .llvm_name = "fmaf", .description = "Enable single precision FMA (not as fast as mul+add, but fused)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp4_cvt_scale_insts)] = .{ + result[@backingInt(Feature.fp4_cvt_scale_insts)] = .{ .llvm_name = "fp4-cvt-scale-insts", .description = "Has fp4 conversion scale instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp64)] = .{ + result[@backingInt(Feature.fp64)] = .{ .llvm_name = "fp64", .description = "Enable double precision operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp6bf6_cvt_scale_insts)] = .{ + result[@backingInt(Feature.fp6bf6_cvt_scale_insts)] = .{ .llvm_name = "fp6bf6-cvt-scale-insts", .description = "Has fp6 and bf6 conversion scale instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp8_conversion_insts)] = .{ + result[@backingInt(Feature.fp8_conversion_insts)] = .{ .llvm_name = "fp8-conversion-insts", .description = "Has fp8 and bf8 conversion instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp8_cvt_scale_insts)] = .{ + result[@backingInt(Feature.fp8_cvt_scale_insts)] = .{ .llvm_name = "fp8-cvt-scale-insts", .description = "Has fp8 conversion scale instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp8_insts)] = .{ + result[@backingInt(Feature.fp8_insts)] = .{ .llvm_name = "fp8-insts", .description = "Has fp8 and bf8 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp8e5m3_insts)] = .{ + result[@backingInt(Feature.fp8e5m3_insts)] = .{ .llvm_name = "fp8e5m3-insts", .description = "Has fp8 e5m3 format support", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.full_rate_64_ops)] = .{ + result[@backingInt(Feature.full_rate_64_ops)] = .{ .llvm_name = "full-rate-64-ops", .description = "Most fp64 instructions are full rate", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.g16)] = .{ + result[@backingInt(Feature.g16)] = .{ .llvm_name = "g16", .description = "Support G16 for 16-bit gradient image operands", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gcn3_encoding)] = .{ + result[@backingInt(Feature.gcn3_encoding)] = .{ .llvm_name = "gcn3-encoding", .description = "Encoding format for VI", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gds)] = .{ + result[@backingInt(Feature.gds)] = .{ .llvm_name = "gds", .description = "Has Global Data Share", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.get_wave_id_inst)] = .{ + result[@backingInt(Feature.get_wave_id_inst)] = .{ .llvm_name = "get-wave-id-inst", .description = "Has s_get_waveid_in_workgroup instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx10)] = .{ + result[@backingInt(Feature.gfx10)] = .{ .llvm_name = "gfx10", .description = "GFX10 GPU generation", .dependencies = featureSet(&[_]Feature{ @@ -883,27 +883,27 @@ pub const all_features = blk: { .vscnt, }), }; - result[@intFromEnum(Feature.gfx10_3_insts)] = .{ + result[@backingInt(Feature.gfx10_3_insts)] = .{ .llvm_name = "gfx10-3-insts", .description = "Additional instructions for GFX10.3", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx10_a_encoding)] = .{ + result[@backingInt(Feature.gfx10_a_encoding)] = .{ .llvm_name = "gfx10_a-encoding", .description = "Has BVH ray tracing instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx10_b_encoding)] = .{ + result[@backingInt(Feature.gfx10_b_encoding)] = .{ .llvm_name = "gfx10_b-encoding", .description = "Encoding format GFX10_B", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx10_insts)] = .{ + result[@backingInt(Feature.gfx10_insts)] = .{ .llvm_name = "gfx10-insts", .description = "Additional instructions for GFX10+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx11)] = .{ + result[@backingInt(Feature.gfx11)] = .{ .llvm_name = "gfx11", .description = "GFX11 GPU generation", .dependencies = featureSet(&[_]Feature{ @@ -962,12 +962,12 @@ pub const all_features = blk: { .vscnt, }), }; - result[@intFromEnum(Feature.gfx11_insts)] = .{ + result[@backingInt(Feature.gfx11_insts)] = .{ .llvm_name = "gfx11-insts", .description = "Additional instructions for GFX11+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx12)] = .{ + result[@backingInt(Feature.gfx12)] = .{ .llvm_name = "gfx12", .description = "GFX12 GPU generation", .dependencies = featureSet(&[_]Feature{ @@ -1019,27 +1019,27 @@ pub const all_features = blk: { .vscnt, }), }; - result[@intFromEnum(Feature.gfx1250_insts)] = .{ + result[@backingInt(Feature.gfx1250_insts)] = .{ .llvm_name = "gfx1250-insts", .description = "Additional instructions for GFX1250+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx12_insts)] = .{ + result[@backingInt(Feature.gfx12_insts)] = .{ .llvm_name = "gfx12-insts", .description = "Additional instructions for GFX12+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx7_gfx8_gfx9_insts)] = .{ + result[@backingInt(Feature.gfx7_gfx8_gfx9_insts)] = .{ .llvm_name = "gfx7-gfx8-gfx9-insts", .description = "Instructions shared in GFX7, GFX8, GFX9", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx8_insts)] = .{ + result[@backingInt(Feature.gfx8_insts)] = .{ .llvm_name = "gfx8-insts", .description = "Additional instructions for GFX8+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx9)] = .{ + result[@backingInt(Feature.gfx9)] = .{ .llvm_name = "gfx9", .description = "GFX9 GPU generation", .dependencies = featureSet(&[_]Feature{ @@ -1092,17 +1092,17 @@ pub const all_features = blk: { .xnack_support, }), }; - result[@intFromEnum(Feature.gfx90a_insts)] = .{ + result[@backingInt(Feature.gfx90a_insts)] = .{ .llvm_name = "gfx90a-insts", .description = "Additional instructions for GFX90A+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx940_insts)] = .{ + result[@backingInt(Feature.gfx940_insts)] = .{ .llvm_name = "gfx940-insts", .description = "Additional instructions for GFX940+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfx950_insts)] = .{ + result[@backingInt(Feature.gfx950_insts)] = .{ .llvm_name = "gfx950-insts", .description = "Additional instructions for GFX950+", .dependencies = featureSet(&[_]Feature{ @@ -1120,437 +1120,437 @@ pub const all_features = blk: { .permlane32_swap, }), }; - result[@intFromEnum(Feature.gfx9_insts)] = .{ + result[@backingInt(Feature.gfx9_insts)] = .{ .llvm_name = "gfx9-insts", .description = "Additional instructions for GFX9+", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.globally_addressable_scratch)] = .{ + result[@backingInt(Feature.globally_addressable_scratch)] = .{ .llvm_name = "globally-addressable-scratch", .description = "FLAT instructions can access scratch memory for any thread in any wave", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gws)] = .{ + result[@backingInt(Feature.gws)] = .{ .llvm_name = "gws", .description = "Has Global Wave Sync", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.half_rate_64_ops)] = .{ + result[@backingInt(Feature.half_rate_64_ops)] = .{ .llvm_name = "half-rate-64-ops", .description = "Most fp64 instructions are half rate instead of quarter", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ieee_minimum_maximum_insts)] = .{ + result[@backingInt(Feature.ieee_minimum_maximum_insts)] = .{ .llvm_name = "ieee-minimum-maximum-insts", .description = "Has v_minimum/maximum_f16/f32/f64, v_minimummaximum/maximumminimum_f16/f32 and v_pk_minimum/maximum_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.image_gather4_d16_bug)] = .{ + result[@backingInt(Feature.image_gather4_d16_bug)] = .{ .llvm_name = "image-gather4-d16-bug", .description = "Image Gather4 D16 hardware bug", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.image_insts)] = .{ + result[@backingInt(Feature.image_insts)] = .{ .llvm_name = "image-insts", .description = "Support image instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.image_store_d16_bug)] = .{ + result[@backingInt(Feature.image_store_d16_bug)] = .{ .llvm_name = "image-store-d16-bug", .description = "Image Store D16 hardware bug", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.inst_fwd_prefetch_bug)] = .{ + result[@backingInt(Feature.inst_fwd_prefetch_bug)] = .{ .llvm_name = "inst-fwd-prefetch-bug", .description = "S_INST_PREFETCH instruction causes shader to hang", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.int_clamp_insts)] = .{ + result[@backingInt(Feature.int_clamp_insts)] = .{ .llvm_name = "int-clamp-insts", .description = "Support clamp for integer destination", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.inv_2pi_inline_imm)] = .{ + result[@backingInt(Feature.inv_2pi_inline_imm)] = .{ .llvm_name = "inv-2pi-inline-imm", .description = "Has 1 / (2 * pi) as inline immediate", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.kernarg_preload)] = .{ + result[@backingInt(Feature.kernarg_preload)] = .{ .llvm_name = "kernarg-preload", .description = "Hardware supports preloading of kernel arguments in user SGPRs.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lds_barrier_arrive_atomic)] = .{ + result[@backingInt(Feature.lds_barrier_arrive_atomic)] = .{ .llvm_name = "lds-barrier-arrive-atomic", .description = "Has LDS barrier-arrive atomic instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lds_branch_vmem_war_hazard)] = .{ + result[@backingInt(Feature.lds_branch_vmem_war_hazard)] = .{ .llvm_name = "lds-branch-vmem-war-hazard", .description = "Switching between LDS and VMEM-tex not waiting VM_VSRC=0", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lds_misaligned_bug)] = .{ + result[@backingInt(Feature.lds_misaligned_bug)] = .{ .llvm_name = "lds-misaligned-bug", .description = "Some GFX10 bug with multi-dword LDS and flat access that is not naturally aligned in WGP mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ldsbankcount16)] = .{ + result[@backingInt(Feature.ldsbankcount16)] = .{ .llvm_name = "ldsbankcount16", .description = "The number of LDS banks per compute unit.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ldsbankcount32)] = .{ + result[@backingInt(Feature.ldsbankcount32)] = .{ .llvm_name = "ldsbankcount32", .description = "The number of LDS banks per compute unit.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lerp_inst)] = .{ + result[@backingInt(Feature.lerp_inst)] = .{ .llvm_name = "lerp-inst", .description = "Has v_lerp_u8 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.load_store_opt)] = .{ + result[@backingInt(Feature.load_store_opt)] = .{ .llvm_name = "load-store-opt", .description = "Enable SI load/store optimizer pass", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lshl_add_u64_inst)] = .{ + result[@backingInt(Feature.lshl_add_u64_inst)] = .{ .llvm_name = "lshl-add-u64-inst", .description = "Has v_lshl_add_u64 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mad_intra_fwd_bug)] = .{ + result[@backingInt(Feature.mad_intra_fwd_bug)] = .{ .llvm_name = "mad-intra-fwd-bug", .description = "MAD_U64/I64 intra instruction forwarding bug", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mad_mac_f32_insts)] = .{ + result[@backingInt(Feature.mad_mac_f32_insts)] = .{ .llvm_name = "mad-mac-f32-insts", .description = "Has v_mad_f32/v_mac_f32/v_madak_f32/v_madmk_f32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mad_mix_insts)] = .{ + result[@backingInt(Feature.mad_mix_insts)] = .{ .llvm_name = "mad-mix-insts", .description = "Has v_mad_mix_f32, v_mad_mixlo_f16, v_mad_mixhi_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mad_u32_inst)] = .{ + result[@backingInt(Feature.mad_u32_inst)] = .{ .llvm_name = "mad-u32-inst", .description = "Has v_mad_u32 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mai_insts)] = .{ + result[@backingInt(Feature.mai_insts)] = .{ .llvm_name = "mai-insts", .description = "Has mAI instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.max_hard_clause_length_32)] = .{ + result[@backingInt(Feature.max_hard_clause_length_32)] = .{ .llvm_name = "max-hard-clause-length-32", .description = "Maximum number of instructions in an explicit S_CLAUSE is 32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.max_hard_clause_length_63)] = .{ + result[@backingInt(Feature.max_hard_clause_length_63)] = .{ .llvm_name = "max-hard-clause-length-63", .description = "Maximum number of instructions in an explicit S_CLAUSE is 63", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.max_private_element_size_16)] = .{ + result[@backingInt(Feature.max_private_element_size_16)] = .{ .llvm_name = "max-private-element-size-16", .description = "Maximum private access size may be 16", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.max_private_element_size_4)] = .{ + result[@backingInt(Feature.max_private_element_size_4)] = .{ .llvm_name = "max-private-element-size-4", .description = "Maximum private access size may be 4", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.max_private_element_size_8)] = .{ + result[@backingInt(Feature.max_private_element_size_8)] = .{ .llvm_name = "max-private-element-size-8", .description = "Maximum private access size may be 8", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mcast_load_insts)] = .{ + result[@backingInt(Feature.mcast_load_insts)] = .{ .llvm_name = "mcast-load-insts", .description = "Has multicast load instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.memory_atomic_fadd_f32_denormal_support)] = .{ + result[@backingInt(Feature.memory_atomic_fadd_f32_denormal_support)] = .{ .llvm_name = "memory-atomic-fadd-f32-denormal-support", .description = "global/flat/buffer atomic fadd for float supports denormal handling", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mfma_inline_literal_bug)] = .{ + result[@backingInt(Feature.mfma_inline_literal_bug)] = .{ .llvm_name = "mfma-inline-literal-bug", .description = "MFMA cannot use inline literal as SrcC", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mimg_r128)] = .{ + result[@backingInt(Feature.mimg_r128)] = .{ .llvm_name = "mimg-r128", .description = "Support 128-bit texture resources", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.min3_max3_pkf16)] = .{ + result[@backingInt(Feature.min3_max3_pkf16)] = .{ .llvm_name = "min3-max3-pkf16", .description = "Has v_pk_min3_num_f16 and v_pk_max3_num_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.minimum3_maximum3_f16)] = .{ + result[@backingInt(Feature.minimum3_maximum3_f16)] = .{ .llvm_name = "minimum3-maximum3-f16", .description = "Has v_minimum3_f16 and v_maximum3_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.minimum3_maximum3_f32)] = .{ + result[@backingInt(Feature.minimum3_maximum3_f32)] = .{ .llvm_name = "minimum3-maximum3-f32", .description = "Has v_minimum3_f32 and v_maximum3_f32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.minimum3_maximum3_pkf16)] = .{ + result[@backingInt(Feature.minimum3_maximum3_pkf16)] = .{ .llvm_name = "minimum3-maximum3-pkf16", .description = "Has v_pk_minimum3_f16 and v_pk_maximum3_f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.movrel)] = .{ + result[@backingInt(Feature.movrel)] = .{ .llvm_name = "movrel", .description = "Has v_movrel*_b32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.msaa_load_dst_sel_bug)] = .{ + result[@backingInt(Feature.msaa_load_dst_sel_bug)] = .{ .llvm_name = "msaa-load-dst-sel-bug", .description = "MSAA loads not honoring dst_sel bug", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.negative_scratch_offset_bug)] = .{ + result[@backingInt(Feature.negative_scratch_offset_bug)] = .{ .llvm_name = "negative-scratch-offset-bug", .description = "Negative immediate offsets in scratch instructions with an SGPR offset page fault on GFX9", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.negative_unaligned_scratch_offset_bug)] = .{ + result[@backingInt(Feature.negative_unaligned_scratch_offset_bug)] = .{ .llvm_name = "negative-unaligned-scratch-offset-bug", .description = "Scratch instructions with a VGPR offset and a negative immediate offset that is not a multiple of 4 read wrong memory on GFX10", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_data_dep_hazard)] = .{ + result[@backingInt(Feature.no_data_dep_hazard)] = .{ .llvm_name = "no-data-dep-hazard", .description = "Does not need SW waitstates", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_sdst_cmpx)] = .{ + result[@backingInt(Feature.no_sdst_cmpx)] = .{ .llvm_name = "no-sdst-cmpx", .description = "V_CMPX does not write VCC/SGPR in addition to EXEC", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nsa_clause_bug)] = .{ + result[@backingInt(Feature.nsa_clause_bug)] = .{ .llvm_name = "nsa-clause-bug", .description = "MIMG-NSA in a hard clause has unpredictable results on GFX10.1", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nsa_encoding)] = .{ + result[@backingInt(Feature.nsa_encoding)] = .{ .llvm_name = "nsa-encoding", .description = "Support NSA encoding for image instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nsa_to_vmem_bug)] = .{ + result[@backingInt(Feature.nsa_to_vmem_bug)] = .{ .llvm_name = "nsa-to-vmem-bug", .description = "MIMG-NSA followed by VMEM fail if EXEC_LO or EXEC_HI equals zero", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.offset_3f_bug)] = .{ + result[@backingInt(Feature.offset_3f_bug)] = .{ .llvm_name = "offset-3f-bug", .description = "Branch offset of 3f hardware bug", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.packed_fp32_ops)] = .{ + result[@backingInt(Feature.packed_fp32_ops)] = .{ .llvm_name = "packed-fp32-ops", .description = "Support packed fp32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.packed_tid)] = .{ + result[@backingInt(Feature.packed_tid)] = .{ .llvm_name = "packed-tid", .description = "Workitem IDs are packed into v0 at kernel launch", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.partial_nsa_encoding)] = .{ + result[@backingInt(Feature.partial_nsa_encoding)] = .{ .llvm_name = "partial-nsa-encoding", .description = "Support partial NSA encoding for image instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.permlane16_swap)] = .{ + result[@backingInt(Feature.permlane16_swap)] = .{ .llvm_name = "permlane16-swap", .description = "Has v_permlane16_swap_b32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.permlane32_swap)] = .{ + result[@backingInt(Feature.permlane32_swap)] = .{ .llvm_name = "permlane32-swap", .description = "Has v_permlane32_swap_b32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pk_add_min_max_insts)] = .{ + result[@backingInt(Feature.pk_add_min_max_insts)] = .{ .llvm_name = "pk-add-min-max-insts", .description = "Has v_pk_add_{min|max}_{i|u}16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pk_fmac_f16_inst)] = .{ + result[@backingInt(Feature.pk_fmac_f16_inst)] = .{ .llvm_name = "pk-fmac-f16-inst", .description = "Has v_pk_fmac_f16 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.point_sample_accel)] = .{ + result[@backingInt(Feature.point_sample_accel)] = .{ .llvm_name = "point-sample-accel", .description = "Has point sample acceleration feature", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.precise_memory)] = .{ + result[@backingInt(Feature.precise_memory)] = .{ .llvm_name = "precise-memory", .description = "Enable precise memory mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.priv_enabled_trap2_nop_bug)] = .{ + result[@backingInt(Feature.priv_enabled_trap2_nop_bug)] = .{ .llvm_name = "priv-enabled-trap2-nop-bug", .description = "Hardware that runs with PRIV=1 interpreting 's_trap 2' as a nop bug", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prng_inst)] = .{ + result[@backingInt(Feature.prng_inst)] = .{ .llvm_name = "prng-inst", .description = "Has v_prng_b32 instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.promote_alloca)] = .{ + result[@backingInt(Feature.promote_alloca)] = .{ .llvm_name = "promote-alloca", .description = "Enable promote alloca pass", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prt_strict_null)] = .{ + result[@backingInt(Feature.prt_strict_null)] = .{ .llvm_name = "enable-prt-strict-null", .description = "Enable zeroing of result registers for sparse texture fetches", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pseudo_scalar_trans)] = .{ + result[@backingInt(Feature.pseudo_scalar_trans)] = .{ .llvm_name = "pseudo-scalar-trans", .description = "Has Pseudo Scalar Transcendental instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.qsad_insts)] = .{ + result[@backingInt(Feature.qsad_insts)] = .{ .llvm_name = "qsad-insts", .description = "Has v_qsad* instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.r128_a16)] = .{ + result[@backingInt(Feature.r128_a16)] = .{ .llvm_name = "r128-a16", .description = "Support gfx9-style A16 for 16-bit coordinates/gradients/lod/clamp/mip image operands, where a16 is aliased with r128", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.real_true16)] = .{ + result[@backingInt(Feature.real_true16)] = .{ .llvm_name = "real-true16", .description = "Use true 16-bit registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.relaxed_buffer_oob_mode)] = .{ + result[@backingInt(Feature.relaxed_buffer_oob_mode)] = .{ .llvm_name = "relaxed-buffer-oob-mode", .description = "Disable strict out-of-bounds buffer guarantees. An OOB access may potentially cause an adjacent access to be treated as if it were also OOB", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.required_export_priority)] = .{ + result[@backingInt(Feature.required_export_priority)] = .{ .llvm_name = "required-export-priority", .description = "Export priority must be explicitly manipulated on GFX11.5", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.requires_cov6)] = .{ + result[@backingInt(Feature.requires_cov6)] = .{ .llvm_name = "requires-cov6", .description = "Target Requires Code Object V6", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.restricted_soffset)] = .{ + result[@backingInt(Feature.restricted_soffset)] = .{ .llvm_name = "restricted-soffset", .description = "Has restricted SOffset (immediate not supported).", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.s_memrealtime)] = .{ + result[@backingInt(Feature.s_memrealtime)] = .{ .llvm_name = "s-memrealtime", .description = "Has s_memrealtime instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.s_memtime_inst)] = .{ + result[@backingInt(Feature.s_memtime_inst)] = .{ .llvm_name = "s-memtime-inst", .description = "Has s_memtime instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.s_wakeup_barrier_inst)] = .{ + result[@backingInt(Feature.s_wakeup_barrier_inst)] = .{ .llvm_name = "s-wakeup-barrier-inst", .description = "Has s_wakeup_barrier instruction.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sad_insts)] = .{ + result[@backingInt(Feature.sad_insts)] = .{ .llvm_name = "sad-insts", .description = "Has v_sad* instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.safe_cu_prefetch)] = .{ + result[@backingInt(Feature.safe_cu_prefetch)] = .{ .llvm_name = "safe-cu-prefetch", .description = "VMEM CU scope prefetches do not fail on illegal address", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.safe_smem_prefetch)] = .{ + result[@backingInt(Feature.safe_smem_prefetch)] = .{ .llvm_name = "safe-smem-prefetch", .description = "SMEM prefetches do not fail on illegal address", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.salu_float)] = .{ + result[@backingInt(Feature.salu_float)] = .{ .llvm_name = "salu-float", .description = "Has SALU floating point instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.scalar_atomics)] = .{ + result[@backingInt(Feature.scalar_atomics)] = .{ .llvm_name = "scalar-atomics", .description = "Has atomic scalar memory instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.scalar_dwordx3_loads)] = .{ + result[@backingInt(Feature.scalar_dwordx3_loads)] = .{ .llvm_name = "scalar-dwordx3-loads", .description = "Has 96-bit scalar load instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.scalar_flat_scratch_insts)] = .{ + result[@backingInt(Feature.scalar_flat_scratch_insts)] = .{ .llvm_name = "scalar-flat-scratch-insts", .description = "Have s_scratch_* flat memory instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.scalar_stores)] = .{ + result[@backingInt(Feature.scalar_stores)] = .{ .llvm_name = "scalar-stores", .description = "Has store scalar memory instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdwa)] = .{ + result[@backingInt(Feature.sdwa)] = .{ .llvm_name = "sdwa", .description = "Support SDWA (Sub-DWORD Addressing) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdwa_mav)] = .{ + result[@backingInt(Feature.sdwa_mav)] = .{ .llvm_name = "sdwa-mav", .description = "Support v_mac_f32/f16 with SDWA (Sub-DWORD Addressing) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdwa_omod)] = .{ + result[@backingInt(Feature.sdwa_omod)] = .{ .llvm_name = "sdwa-omod", .description = "Support OMod with SDWA (Sub-DWORD Addressing) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdwa_out_mods_vopc)] = .{ + result[@backingInt(Feature.sdwa_out_mods_vopc)] = .{ .llvm_name = "sdwa-out-mods-vopc", .description = "Support clamp for VOPC with SDWA (Sub-DWORD Addressing) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdwa_scalar)] = .{ + result[@backingInt(Feature.sdwa_scalar)] = .{ .llvm_name = "sdwa-scalar", .description = "Support scalar register with SDWA (Sub-DWORD Addressing) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdwa_sdst)] = .{ + result[@backingInt(Feature.sdwa_sdst)] = .{ .llvm_name = "sdwa-sdst", .description = "Support scalar dst for VOPC with SDWA (Sub-DWORD Addressing) extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sea_islands)] = .{ + result[@backingInt(Feature.sea_islands)] = .{ .llvm_name = "sea-islands", .description = "SEA_ISLANDS GPU generation", .dependencies = featureSet(&[_]Feature{ @@ -1583,42 +1583,42 @@ pub const all_features = blk: { .wavefrontsize64, }), }; - result[@intFromEnum(Feature.setprio_inc_wg_inst)] = .{ + result[@backingInt(Feature.setprio_inc_wg_inst)] = .{ .llvm_name = "setprio-inc-wg-inst", .description = "Has s_setprio_inc_wg instruction.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.setreg_vgpr_msb_fixup)] = .{ + result[@backingInt(Feature.setreg_vgpr_msb_fixup)] = .{ .llvm_name = "setreg-vgpr-msb-fixup", .description = "S_SETREG to MODE clobbers VGPR MSB bits, requires fixup", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sgpr_init_bug)] = .{ + result[@backingInt(Feature.sgpr_init_bug)] = .{ .llvm_name = "sgpr-init-bug", .description = "VI SGPR initialization bug requiring a fixed SGPR allocation size", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shader_cycles_hi_lo_registers)] = .{ + result[@backingInt(Feature.shader_cycles_hi_lo_registers)] = .{ .llvm_name = "shader-cycles-hi-lo-registers", .description = "Has SHADER_CYCLES_HI/LO hardware registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shader_cycles_register)] = .{ + result[@backingInt(Feature.shader_cycles_register)] = .{ .llvm_name = "shader-cycles-register", .description = "Has SHADER_CYCLES hardware register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.si_scheduler)] = .{ + result[@backingInt(Feature.si_scheduler)] = .{ .llvm_name = "si-scheduler", .description = "Enable SI Machine Scheduler", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smem_to_vector_write_hazard)] = .{ + result[@backingInt(Feature.smem_to_vector_write_hazard)] = .{ .llvm_name = "smem-to-vector-write-hazard", .description = "s_load_dword followed by v_cmp page faults", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.southern_islands)] = .{ + result[@backingInt(Feature.southern_islands)] = .{ .llvm_name = "southern-islands", .description = "SOUTHERN_ISLANDS GPU generation", .dependencies = featureSet(&[_]Feature{ @@ -1646,132 +1646,132 @@ pub const all_features = blk: { .wavefrontsize64, }), }; - result[@intFromEnum(Feature.sramecc)] = .{ + result[@backingInt(Feature.sramecc)] = .{ .llvm_name = "sramecc", .description = "Enable SRAMECC", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sramecc_support)] = .{ + result[@backingInt(Feature.sramecc_support)] = .{ .llvm_name = "sramecc-support", .description = "Hardware supports SRAMECC", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tanh_insts)] = .{ + result[@backingInt(Feature.tanh_insts)] = .{ .llvm_name = "tanh-insts", .description = "Has v_tanh_f32/f16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tensor_cvt_lut_insts)] = .{ + result[@backingInt(Feature.tensor_cvt_lut_insts)] = .{ .llvm_name = "tensor-cvt-lut-insts", .description = "Has v_perm_pk16* instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tgsplit)] = .{ + result[@backingInt(Feature.tgsplit)] = .{ .llvm_name = "tgsplit", .description = "Enable threadgroup split execution", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.transpose_load_f4f6_insts)] = .{ + result[@backingInt(Feature.transpose_load_f4f6_insts)] = .{ .llvm_name = "transpose-load-f4f6-insts", .description = "Has ds_load_tr4/tr6 and global_load_tr4/tr6 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.trap_handler)] = .{ + result[@backingInt(Feature.trap_handler)] = .{ .llvm_name = "trap-handler", .description = "Trap handler support", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.trig_reduced_range)] = .{ + result[@backingInt(Feature.trig_reduced_range)] = .{ .llvm_name = "trig-reduced-range", .description = "Requires use of fract on arguments to trig instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.true16)] = .{ + result[@backingInt(Feature.true16)] = .{ .llvm_name = "true16", .description = "True 16-bit operand instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unaligned_access_mode)] = .{ + result[@backingInt(Feature.unaligned_access_mode)] = .{ .llvm_name = "unaligned-access-mode", .description = "Enable unaligned global, local and region loads and stores if the hardware supports it", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unaligned_buffer_access)] = .{ + result[@backingInt(Feature.unaligned_buffer_access)] = .{ .llvm_name = "unaligned-buffer-access", .description = "Hardware supports unaligned global loads and stores", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unaligned_ds_access)] = .{ + result[@backingInt(Feature.unaligned_ds_access)] = .{ .llvm_name = "unaligned-ds-access", .description = "Hardware supports unaligned local and region loads and stores", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unaligned_scratch_access)] = .{ + result[@backingInt(Feature.unaligned_scratch_access)] = .{ .llvm_name = "unaligned-scratch-access", .description = "Support unaligned scratch loads and stores", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unpacked_d16_vmem)] = .{ + result[@backingInt(Feature.unpacked_d16_vmem)] = .{ .llvm_name = "unpacked-d16-vmem", .description = "Has unpacked d16 vmem instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unsafe_ds_offset_folding)] = .{ + result[@backingInt(Feature.unsafe_ds_offset_folding)] = .{ .llvm_name = "unsafe-ds-offset-folding", .description = "Force using DS instruction immediate offsets on SI", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.user_sgpr_init16_bug)] = .{ + result[@backingInt(Feature.user_sgpr_init16_bug)] = .{ .llvm_name = "user-sgpr-init16-bug", .description = "Bug requiring at least 16 user+system SGPRs to be enabled", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.valu_trans_use_hazard)] = .{ + result[@backingInt(Feature.valu_trans_use_hazard)] = .{ .llvm_name = "valu-trans-use-hazard", .description = "Hazard when TRANS instructions are closely followed by a use of the result", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vcmpx_exec_war_hazard)] = .{ + result[@backingInt(Feature.vcmpx_exec_war_hazard)] = .{ .llvm_name = "vcmpx-exec-war-hazard", .description = "V_CMPX WAR hazard on EXEC (V_CMPX issue ONLY)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vcmpx_permlane_hazard)] = .{ + result[@backingInt(Feature.vcmpx_permlane_hazard)] = .{ .llvm_name = "vcmpx-permlane-hazard", .description = "TODO: describe me", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vgpr_align2)] = .{ + result[@backingInt(Feature.vgpr_align2)] = .{ .llvm_name = "vgpr-align2", .description = "VGPR and AGPR tuple operands require even alignment", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vgpr_index_mode)] = .{ + result[@backingInt(Feature.vgpr_index_mode)] = .{ .llvm_name = "vgpr-index-mode", .description = "Has VGPR mode register indexing", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vmem_pref_insts)] = .{ + result[@backingInt(Feature.vmem_pref_insts)] = .{ .llvm_name = "vmem-pref-insts", .description = "Has flat_prefect_b8 and global_prefetch_b8 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vmem_to_lds_load_insts)] = .{ + result[@backingInt(Feature.vmem_to_lds_load_insts)] = .{ .llvm_name = "vmem-to-lds-load-insts", .description = "The platform has memory to lds instructions (global_load w/lds bit set, buffer_load w/lds bit set or global_load_lds. This does not include scratch_load_lds.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vmem_to_scalar_write_hazard)] = .{ + result[@backingInt(Feature.vmem_to_scalar_write_hazard)] = .{ .llvm_name = "vmem-to-scalar-write-hazard", .description = "VMEM instruction followed by scalar writing to EXEC mask, M0 or SGPR leads to incorrect execution.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vmem_write_vgpr_in_order)] = .{ + result[@backingInt(Feature.vmem_write_vgpr_in_order)] = .{ .llvm_name = "vmem-write-vgpr-in-order", .description = "VMEM instructions of the same type write VGPR results in order", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.volcanic_islands)] = .{ + result[@backingInt(Feature.volcanic_islands)] = .{ .llvm_name = "volcanic-islands", .description = "VOLCANIC_ISLANDS GPU generation", .dependencies = featureSet(&[_]Feature{ @@ -1814,62 +1814,62 @@ pub const all_features = blk: { .wavefrontsize64, }), }; - result[@intFromEnum(Feature.vop3_literal)] = .{ + result[@backingInt(Feature.vop3_literal)] = .{ .llvm_name = "vop3-literal", .description = "Can use one literal in VOP3", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vop3p)] = .{ + result[@backingInt(Feature.vop3p)] = .{ .llvm_name = "vop3p", .description = "Has VOP3P packed instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vopd)] = .{ + result[@backingInt(Feature.vopd)] = .{ .llvm_name = "vopd", .description = "Has VOPD dual issue wave32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vscnt)] = .{ + result[@backingInt(Feature.vscnt)] = .{ .llvm_name = "vscnt", .description = "Has separate store vscnt counter", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wait_xcnt)] = .{ + result[@backingInt(Feature.wait_xcnt)] = .{ .llvm_name = "wait-xcnt", .description = "Has s_wait_xcnt instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.waits_before_system_scope_stores)] = .{ + result[@backingInt(Feature.waits_before_system_scope_stores)] = .{ .llvm_name = "waits-before-system-scope-stores", .description = "Target requires waits for loads and atomics before system scope stores", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wavefrontsize16)] = .{ + result[@backingInt(Feature.wavefrontsize16)] = .{ .llvm_name = "wavefrontsize16", .description = "The number of threads per wavefront", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wavefrontsize32)] = .{ + result[@backingInt(Feature.wavefrontsize32)] = .{ .llvm_name = "wavefrontsize32", .description = "The number of threads per wavefront", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wavefrontsize64)] = .{ + result[@backingInt(Feature.wavefrontsize64)] = .{ .llvm_name = "wavefrontsize64", .description = "The number of threads per wavefront", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xf32_insts)] = .{ + result[@backingInt(Feature.xf32_insts)] = .{ .llvm_name = "xf32-insts", .description = "Has instructions that support xf32 format, such as v_mfma_f32_16x16x8_xf32 and v_mfma_f32_32x32x4_xf32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xnack)] = .{ + result[@backingInt(Feature.xnack)] = .{ .llvm_name = "xnack", .description = "Enable XNACK support", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xnack_support)] = .{ + result[@backingInt(Feature.xnack_support)] = .{ .llvm_name = "xnack-support", .description = "Hardware supports XNACK", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/arc.zig b/lib/std/Target/arc.zig index 40e85774733d746ad03fcf84043bc83d34b317b7..ac48a10ffe4b30100cdfcbeef6ef53191a1cd69e 100644 --- a/lib/std/Target/arc.zig +++ b/lib/std/Target/arc.zig @@ -17,7 +17,7 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.norm)] = .{ + result[@backingInt(Feature.norm)] = .{ .llvm_name = "norm", .description = "Enable support for norm instruction.", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/arm.zig b/lib/std/Target/arm.zig index 39a9fbbbf766ba408801e9ee00d1f5786e9b205c..bcad2d76384d46138448d6e2616cc2d331a3d965 100644 --- a/lib/std/Target/arm.zig +++ b/lib/std/Target/arm.zig @@ -218,159 +218,159 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"32bit")] = .{ + result[@backingInt(Feature.@"32bit")] = .{ .llvm_name = "32bit", .description = "Prefer 32-bit Thumb instrs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"8msecext")] = .{ + result[@backingInt(Feature.@"8msecext")] = .{ .llvm_name = "8msecext", .description = "Enable support for ARMv8-M Security Extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.aapcs_frame_chain)] = .{ + result[@backingInt(Feature.aapcs_frame_chain)] = .{ .llvm_name = "aapcs-frame-chain", .description = "Create an AAPCS compliant frame chain", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.aclass)] = .{ + result[@backingInt(Feature.aclass)] = .{ .llvm_name = "aclass", .description = "Is application profile ('A' series)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.acquire_release)] = .{ + result[@backingInt(Feature.acquire_release)] = .{ .llvm_name = "acquire-release", .description = "Has v8 acquire/release (lda/ldaex etc) instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.aes)] = .{ + result[@backingInt(Feature.aes)] = .{ .llvm_name = "aes", .description = "Enable AES support", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.atomics_32)] = .{ + result[@backingInt(Feature.atomics_32)] = .{ .llvm_name = "atomics-32", .description = "Assume that lock-free 32-bit atomics are available", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.avoid_movs_shop)] = .{ + result[@backingInt(Feature.avoid_movs_shop)] = .{ .llvm_name = "avoid-movs-shop", .description = "Avoid movs instructions with shifter operand", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.avoid_muls)] = .{ + result[@backingInt(Feature.avoid_muls)] = .{ .llvm_name = "avoid-muls", .description = "Avoid MULS instructions for M class cores", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.avoid_partial_cpsr)] = .{ + result[@backingInt(Feature.avoid_partial_cpsr)] = .{ .llvm_name = "avoid-partial-cpsr", .description = "Avoid CPSR partial update for OOO execution", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bf16)] = .{ + result[@backingInt(Feature.bf16)] = .{ .llvm_name = "bf16", .description = "Enable support for BFloat16 instructions", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.big_endian_instructions)] = .{ + result[@backingInt(Feature.big_endian_instructions)] = .{ .llvm_name = "big-endian-instructions", .description = "Expect instructions to be stored big-endian.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.branch_align_64)] = .{ + result[@backingInt(Feature.branch_align_64)] = .{ .llvm_name = "branch-align-64", .description = "Prefer 64-bit alignment for branch targets", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cde)] = .{ + result[@backingInt(Feature.cde)] = .{ .llvm_name = "cde", .description = "Support CDE instructions", .dependencies = featureSet(&[_]Feature{ .has_v8m_main, }), }; - result[@intFromEnum(Feature.cdecp0)] = .{ + result[@backingInt(Feature.cdecp0)] = .{ .llvm_name = "cdecp0", .description = "Coprocessor 0 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cdecp1)] = .{ + result[@backingInt(Feature.cdecp1)] = .{ .llvm_name = "cdecp1", .description = "Coprocessor 1 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cdecp2)] = .{ + result[@backingInt(Feature.cdecp2)] = .{ .llvm_name = "cdecp2", .description = "Coprocessor 2 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cdecp3)] = .{ + result[@backingInt(Feature.cdecp3)] = .{ .llvm_name = "cdecp3", .description = "Coprocessor 3 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cdecp4)] = .{ + result[@backingInt(Feature.cdecp4)] = .{ .llvm_name = "cdecp4", .description = "Coprocessor 4 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cdecp5)] = .{ + result[@backingInt(Feature.cdecp5)] = .{ .llvm_name = "cdecp5", .description = "Coprocessor 5 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cdecp6)] = .{ + result[@backingInt(Feature.cdecp6)] = .{ .llvm_name = "cdecp6", .description = "Coprocessor 6 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cdecp7)] = .{ + result[@backingInt(Feature.cdecp7)] = .{ .llvm_name = "cdecp7", .description = "Coprocessor 7 ISA is CDEv1", .dependencies = featureSet(&[_]Feature{ .cde, }), }; - result[@intFromEnum(Feature.cheap_predicable_cpsr)] = .{ + result[@backingInt(Feature.cheap_predicable_cpsr)] = .{ .llvm_name = "cheap-predicable-cpsr", .description = "Disable +1 predication cost for instructions updating CPSR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.clrbhb)] = .{ + result[@backingInt(Feature.clrbhb)] = .{ .llvm_name = "clrbhb", .description = "Enable Clear BHB instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cortex_a510)] = .{ + result[@backingInt(Feature.cortex_a510)] = .{ .llvm_name = "cortex-a510", .description = "Cortex-A510 ARM processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.crc)] = .{ + result[@backingInt(Feature.crc)] = .{ .llvm_name = "crc", .description = "Enable support for CRC instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.crypto)] = .{ + result[@backingInt(Feature.crypto)] = .{ .llvm_name = "crypto", .description = "Enable support for Cryptography extensions", .dependencies = featureSet(&[_]Feature{ @@ -378,83 +378,83 @@ pub const all_features = blk: { .sha2, }), }; - result[@intFromEnum(Feature.d32)] = .{ + result[@backingInt(Feature.d32)] = .{ .llvm_name = "d32", .description = "Extend FP to 32 double registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.db)] = .{ + result[@backingInt(Feature.db)] = .{ .llvm_name = "db", .description = "Has data barrier (dmb/dsb) instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dfb)] = .{ + result[@backingInt(Feature.dfb)] = .{ .llvm_name = "dfb", .description = "Has full data barrier (dfb) instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_postra_scheduler)] = .{ + result[@backingInt(Feature.disable_postra_scheduler)] = .{ .llvm_name = "disable-postra-scheduler", .description = "Don't schedule again after register allocation", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dont_widen_vmovs)] = .{ + result[@backingInt(Feature.dont_widen_vmovs)] = .{ .llvm_name = "dont-widen-vmovs", .description = "Don't widen VMOVS to VMOVD", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dotprod)] = .{ + result[@backingInt(Feature.dotprod)] = .{ .llvm_name = "dotprod", .description = "Enable support for dot product instructions", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.dsp)] = .{ + result[@backingInt(Feature.dsp)] = .{ .llvm_name = "dsp", .description = "Supports DSP instructions in ARM and/or Thumb2", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.execute_only)] = .{ + result[@backingInt(Feature.execute_only)] = .{ .llvm_name = "execute-only", .description = "Enable the generation of execute only code.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.expand_fp_mlx)] = .{ + result[@backingInt(Feature.expand_fp_mlx)] = .{ .llvm_name = "expand-fp-mlx", .description = "Expand VFP/NEON MLA/MLS instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_cmse_cve_2021_35465)] = .{ + result[@backingInt(Feature.fix_cmse_cve_2021_35465)] = .{ .llvm_name = "fix-cmse-cve-2021-35465", .description = "Mitigate against the cve-2021-35465 security vulnurability", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_cortex_a57_aes_1742098)] = .{ + result[@backingInt(Feature.fix_cortex_a57_aes_1742098)] = .{ .llvm_name = "fix-cortex-a57-aes-1742098", .description = "Work around Cortex-A57 Erratum 1742098 / Cortex-A72 Erratum 1655431 (AES)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp16)] = .{ + result[@backingInt(Feature.fp16)] = .{ .llvm_name = "fp16", .description = "Enable half-precision floating point", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp16fml)] = .{ + result[@backingInt(Feature.fp16fml)] = .{ .llvm_name = "fp16fml", .description = "Enable full half-precision floating point fml instructions", .dependencies = featureSet(&[_]Feature{ .fullfp16, }), }; - result[@intFromEnum(Feature.fp64)] = .{ + result[@backingInt(Feature.fp64)] = .{ .llvm_name = "fp64", .description = "Floating point unit supports double precision", .dependencies = featureSet(&[_]Feature{ .fpregs64, }), }; - result[@intFromEnum(Feature.fp_armv8)] = .{ + result[@backingInt(Feature.fp_armv8)] = .{ .llvm_name = "fp-armv8", .description = "Enable ARMv8 FP", .dependencies = featureSet(&[_]Feature{ @@ -463,7 +463,7 @@ pub const all_features = blk: { .vfp4, }), }; - result[@intFromEnum(Feature.fp_armv8d16)] = .{ + result[@backingInt(Feature.fp_armv8d16)] = .{ .llvm_name = "fp-armv8d16", .description = "Enable ARMv8 FP with only 16 d-registers", .dependencies = featureSet(&[_]Feature{ @@ -471,14 +471,14 @@ pub const all_features = blk: { .vfp4d16, }), }; - result[@intFromEnum(Feature.fp_armv8d16sp)] = .{ + result[@backingInt(Feature.fp_armv8d16sp)] = .{ .llvm_name = "fp-armv8d16sp", .description = "Enable ARMv8 FP with only 16 d-registers and no double precision", .dependencies = featureSet(&[_]Feature{ .vfp4d16sp, }), }; - result[@intFromEnum(Feature.fp_armv8sp)] = .{ + result[@backingInt(Feature.fp_armv8sp)] = .{ .llvm_name = "fp-armv8sp", .description = "Enable ARMv8 FP with no double precision", .dependencies = featureSet(&[_]Feature{ @@ -486,31 +486,31 @@ pub const all_features = blk: { .vfp4sp, }), }; - result[@intFromEnum(Feature.fpao)] = .{ + result[@backingInt(Feature.fpao)] = .{ .llvm_name = "fpao", .description = "Enable fast computation of positive address offsets", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpregs)] = .{ + result[@backingInt(Feature.fpregs)] = .{ .llvm_name = "fpregs", .description = "Enable FP registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpregs16)] = .{ + result[@backingInt(Feature.fpregs16)] = .{ .llvm_name = "fpregs16", .description = "Enable 16-bit FP registers", .dependencies = featureSet(&[_]Feature{ .fpregs, }), }; - result[@intFromEnum(Feature.fpregs64)] = .{ + result[@backingInt(Feature.fpregs64)] = .{ .llvm_name = "fpregs64", .description = "Enable 64-bit FP registers", .dependencies = featureSet(&[_]Feature{ .fpregs, }), }; - result[@intFromEnum(Feature.fullfp16)] = .{ + result[@backingInt(Feature.fullfp16)] = .{ .llvm_name = "fullfp16", .description = "Enable full half-precision floating point", .dependencies = featureSet(&[_]Feature{ @@ -518,72 +518,72 @@ pub const all_features = blk: { .fpregs16, }), }; - result[@intFromEnum(Feature.fuse_aes)] = .{ + result[@backingInt(Feature.fuse_aes)] = .{ .llvm_name = "fuse-aes", .description = "CPU fuses AES crypto operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fuse_literals)] = .{ + result[@backingInt(Feature.fuse_literals)] = .{ .llvm_name = "fuse-literals", .description = "CPU fuses literal generation operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.harden_sls_blr)] = .{ + result[@backingInt(Feature.harden_sls_blr)] = .{ .llvm_name = "harden-sls-blr", .description = "Harden against straight line speculation across indirect calls", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.harden_sls_nocomdat)] = .{ + result[@backingInt(Feature.harden_sls_nocomdat)] = .{ .llvm_name = "harden-sls-nocomdat", .description = "Generate thunk code for SLS mitigation in the normal text section", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.harden_sls_retbr)] = .{ + result[@backingInt(Feature.harden_sls_retbr)] = .{ .llvm_name = "harden-sls-retbr", .description = "Harden against straight line speculation across RETurn and BranchRegister instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.has_v4t)] = .{ + result[@backingInt(Feature.has_v4t)] = .{ .llvm_name = "v4t", .description = "Support ARM v4T instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.has_v5t)] = .{ + result[@backingInt(Feature.has_v5t)] = .{ .llvm_name = "v5t", .description = "Support ARM v5T instructions", .dependencies = featureSet(&[_]Feature{ .has_v4t, }), }; - result[@intFromEnum(Feature.has_v5te)] = .{ + result[@backingInt(Feature.has_v5te)] = .{ .llvm_name = "v5te", .description = "Support ARM v5TE, v5TEj, and v5TExp instructions", .dependencies = featureSet(&[_]Feature{ .has_v5t, }), }; - result[@intFromEnum(Feature.has_v6)] = .{ + result[@backingInt(Feature.has_v6)] = .{ .llvm_name = "v6", .description = "Support ARM v6 instructions", .dependencies = featureSet(&[_]Feature{ .has_v5te, }), }; - result[@intFromEnum(Feature.has_v6k)] = .{ + result[@backingInt(Feature.has_v6k)] = .{ .llvm_name = "v6k", .description = "Support ARM v6k instructions", .dependencies = featureSet(&[_]Feature{ .has_v6, }), }; - result[@intFromEnum(Feature.has_v6m)] = .{ + result[@backingInt(Feature.has_v6m)] = .{ .llvm_name = "v6m", .description = "Support ARM v6M instructions", .dependencies = featureSet(&[_]Feature{ .has_v6, }), }; - result[@intFromEnum(Feature.has_v6t2)] = .{ + result[@backingInt(Feature.has_v6t2)] = .{ .llvm_name = "v6t2", .description = "Support ARM v6t2 instructions", .dependencies = featureSet(&[_]Feature{ @@ -592,7 +592,7 @@ pub const all_features = blk: { .thumb2, }), }; - result[@intFromEnum(Feature.has_v7)] = .{ + result[@backingInt(Feature.has_v7)] = .{ .llvm_name = "v7", .description = "Support ARM v7 instructions", .dependencies = featureSet(&[_]Feature{ @@ -600,12 +600,12 @@ pub const all_features = blk: { .has_v7clrex, }), }; - result[@intFromEnum(Feature.has_v7clrex)] = .{ + result[@backingInt(Feature.has_v7clrex)] = .{ .llvm_name = "v7clrex", .description = "Has v7 clrex instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.has_v8)] = .{ + result[@backingInt(Feature.has_v8)] = .{ .llvm_name = "v8", .description = "Support ARM v8 instructions", .dependencies = featureSet(&[_]Feature{ @@ -614,35 +614,35 @@ pub const all_features = blk: { .perfmon, }), }; - result[@intFromEnum(Feature.has_v8_1a)] = .{ + result[@backingInt(Feature.has_v8_1a)] = .{ .llvm_name = "v8.1a", .description = "Support ARM v8.1a instructions", .dependencies = featureSet(&[_]Feature{ .has_v8, }), }; - result[@intFromEnum(Feature.has_v8_1m_main)] = .{ + result[@backingInt(Feature.has_v8_1m_main)] = .{ .llvm_name = "v8.1m.main", .description = "Support ARM v8-1M Mainline instructions", .dependencies = featureSet(&[_]Feature{ .has_v8m_main, }), }; - result[@intFromEnum(Feature.has_v8_2a)] = .{ + result[@backingInt(Feature.has_v8_2a)] = .{ .llvm_name = "v8.2a", .description = "Support ARM v8.2a instructions", .dependencies = featureSet(&[_]Feature{ .has_v8_1a, }), }; - result[@intFromEnum(Feature.has_v8_3a)] = .{ + result[@backingInt(Feature.has_v8_3a)] = .{ .llvm_name = "v8.3a", .description = "Support ARM v8.3a instructions", .dependencies = featureSet(&[_]Feature{ .has_v8_2a, }), }; - result[@intFromEnum(Feature.has_v8_4a)] = .{ + result[@backingInt(Feature.has_v8_4a)] = .{ .llvm_name = "v8.4a", .description = "Support ARM v8.4a instructions", .dependencies = featureSet(&[_]Feature{ @@ -650,7 +650,7 @@ pub const all_features = blk: { .has_v8_3a, }), }; - result[@intFromEnum(Feature.has_v8_5a)] = .{ + result[@backingInt(Feature.has_v8_5a)] = .{ .llvm_name = "v8.5a", .description = "Support ARM v8.5a instructions", .dependencies = featureSet(&[_]Feature{ @@ -658,7 +658,7 @@ pub const all_features = blk: { .sb, }), }; - result[@intFromEnum(Feature.has_v8_6a)] = .{ + result[@backingInt(Feature.has_v8_6a)] = .{ .llvm_name = "v8.6a", .description = "Support ARM v8.6a instructions", .dependencies = featureSet(&[_]Feature{ @@ -667,21 +667,21 @@ pub const all_features = blk: { .i8mm, }), }; - result[@intFromEnum(Feature.has_v8_7a)] = .{ + result[@backingInt(Feature.has_v8_7a)] = .{ .llvm_name = "v8.7a", .description = "Support ARM v8.7a instructions", .dependencies = featureSet(&[_]Feature{ .has_v8_6a, }), }; - result[@intFromEnum(Feature.has_v8_8a)] = .{ + result[@backingInt(Feature.has_v8_8a)] = .{ .llvm_name = "v8.8a", .description = "Support ARM v8.8a instructions", .dependencies = featureSet(&[_]Feature{ .has_v8_7a, }), }; - result[@intFromEnum(Feature.has_v8_9a)] = .{ + result[@backingInt(Feature.has_v8_9a)] = .{ .llvm_name = "v8.9a", .description = "Support ARM v8.9a instructions", .dependencies = featureSet(&[_]Feature{ @@ -689,21 +689,21 @@ pub const all_features = blk: { .has_v8_8a, }), }; - result[@intFromEnum(Feature.has_v8m)] = .{ + result[@backingInt(Feature.has_v8m)] = .{ .llvm_name = "v8m", .description = "Support ARM v8M Baseline instructions", .dependencies = featureSet(&[_]Feature{ .has_v6m, }), }; - result[@intFromEnum(Feature.has_v8m_main)] = .{ + result[@backingInt(Feature.has_v8m_main)] = .{ .llvm_name = "v8m.main", .description = "Support ARM v8M Mainline instructions", .dependencies = featureSet(&[_]Feature{ .has_v7, }), }; - result[@intFromEnum(Feature.has_v9_1a)] = .{ + result[@backingInt(Feature.has_v9_1a)] = .{ .llvm_name = "v9.1a", .description = "Support ARM v9.1a instructions", .dependencies = featureSet(&[_]Feature{ @@ -711,7 +711,7 @@ pub const all_features = blk: { .has_v9a, }), }; - result[@intFromEnum(Feature.has_v9_2a)] = .{ + result[@backingInt(Feature.has_v9_2a)] = .{ .llvm_name = "v9.2a", .description = "Support ARM v9.2a instructions", .dependencies = featureSet(&[_]Feature{ @@ -719,7 +719,7 @@ pub const all_features = blk: { .has_v9_1a, }), }; - result[@intFromEnum(Feature.has_v9_3a)] = .{ + result[@backingInt(Feature.has_v9_3a)] = .{ .llvm_name = "v9.3a", .description = "Support ARM v9.3a instructions", .dependencies = featureSet(&[_]Feature{ @@ -727,7 +727,7 @@ pub const all_features = blk: { .has_v9_2a, }), }; - result[@intFromEnum(Feature.has_v9_4a)] = .{ + result[@backingInt(Feature.has_v9_4a)] = .{ .llvm_name = "v9.4a", .description = "Support ARM v9.4a instructions", .dependencies = featureSet(&[_]Feature{ @@ -735,106 +735,106 @@ pub const all_features = blk: { .has_v9_3a, }), }; - result[@intFromEnum(Feature.has_v9_5a)] = .{ + result[@backingInt(Feature.has_v9_5a)] = .{ .llvm_name = "v9.5a", .description = "Support ARM v9.5a instructions", .dependencies = featureSet(&[_]Feature{ .has_v9_4a, }), }; - result[@intFromEnum(Feature.has_v9_6a)] = .{ + result[@backingInt(Feature.has_v9_6a)] = .{ .llvm_name = "v9.6a", .description = "Support ARM v9.6a instructions", .dependencies = featureSet(&[_]Feature{ .has_v9_5a, }), }; - result[@intFromEnum(Feature.has_v9_7a)] = .{ + result[@backingInt(Feature.has_v9_7a)] = .{ .llvm_name = "v9.7a", .description = "Support ARM v9.7a instructions", .dependencies = featureSet(&[_]Feature{ .has_v9_6a, }), }; - result[@intFromEnum(Feature.has_v9a)] = .{ + result[@backingInt(Feature.has_v9a)] = .{ .llvm_name = "v9a", .description = "Support ARM v9a instructions", .dependencies = featureSet(&[_]Feature{ .has_v8_5a, }), }; - result[@intFromEnum(Feature.hwdiv)] = .{ + result[@backingInt(Feature.hwdiv)] = .{ .llvm_name = "hwdiv", .description = "Enable divide instructions in Thumb", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hwdiv_arm)] = .{ + result[@backingInt(Feature.hwdiv_arm)] = .{ .llvm_name = "hwdiv-arm", .description = "Enable divide instructions in ARM mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.i8mm)] = .{ + result[@backingInt(Feature.i8mm)] = .{ .llvm_name = "i8mm", .description = "Enable Matrix Multiply Int8 Extension", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.iwmmxt)] = .{ + result[@backingInt(Feature.iwmmxt)] = .{ .llvm_name = "iwmmxt", .description = "ARMv5te architecture", .dependencies = featureSet(&[_]Feature{ .v5te, }), }; - result[@intFromEnum(Feature.iwmmxt2)] = .{ + result[@backingInt(Feature.iwmmxt2)] = .{ .llvm_name = "iwmmxt2", .description = "ARMv5te architecture", .dependencies = featureSet(&[_]Feature{ .v5te, }), }; - result[@intFromEnum(Feature.lob)] = .{ + result[@backingInt(Feature.lob)] = .{ .llvm_name = "lob", .description = "Enable Low Overhead Branch extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.long_calls)] = .{ + result[@backingInt(Feature.long_calls)] = .{ .llvm_name = "long-calls", .description = "Generate calls via indirect call instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.loop_align)] = .{ + result[@backingInt(Feature.loop_align)] = .{ .llvm_name = "loop-align", .description = "Prefer 32-bit alignment for branch targets", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.m55)] = .{ + result[@backingInt(Feature.m55)] = .{ .llvm_name = "m55", .description = "Cortex-M55 ARM processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.m85)] = .{ + result[@backingInt(Feature.m85)] = .{ .llvm_name = "m85", .description = "Cortex-M85 ARM processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mclass)] = .{ + result[@backingInt(Feature.mclass)] = .{ .llvm_name = "mclass", .description = "Is microcontroller profile ('M' series)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mp)] = .{ + result[@backingInt(Feature.mp)] = .{ .llvm_name = "mp", .description = "Supports Multiprocessing extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.muxed_units)] = .{ + result[@backingInt(Feature.muxed_units)] = .{ .llvm_name = "muxed-units", .description = "Has muxed AGU and NEON/FPU", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mve)] = .{ + result[@backingInt(Feature.mve)] = .{ .llvm_name = "mve", .description = "Support M-Class Vector Extension with integer ops", .dependencies = featureSet(&[_]Feature{ @@ -844,22 +844,22 @@ pub const all_features = blk: { .has_v8_1m_main, }), }; - result[@intFromEnum(Feature.mve1beat)] = .{ + result[@backingInt(Feature.mve1beat)] = .{ .llvm_name = "mve1beat", .description = "Model MVE instructions as a 1 beat per tick architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mve2beat)] = .{ + result[@backingInt(Feature.mve2beat)] = .{ .llvm_name = "mve2beat", .description = "Model MVE instructions as a 2 beats per tick architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mve4beat)] = .{ + result[@backingInt(Feature.mve4beat)] = .{ .llvm_name = "mve4beat", .description = "Model MVE instructions as a 4 beats per tick architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mve_fp)] = .{ + result[@backingInt(Feature.mve_fp)] = .{ .llvm_name = "mve.fp", .description = "Support M-Class Vector Extension with integer and floating ops", .dependencies = featureSet(&[_]Feature{ @@ -867,238 +867,238 @@ pub const all_features = blk: { .mve, }), }; - result[@intFromEnum(Feature.neon)] = .{ + result[@backingInt(Feature.neon)] = .{ .llvm_name = "neon", .description = "Enable NEON instructions", .dependencies = featureSet(&[_]Feature{ .vfp3, }), }; - result[@intFromEnum(Feature.neon_fpmovs)] = .{ + result[@backingInt(Feature.neon_fpmovs)] = .{ .llvm_name = "neon-fpmovs", .description = "Convert VMOVSR, VMOVRS, VMOVS to NEON", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.neonfp)] = .{ + result[@backingInt(Feature.neonfp)] = .{ .llvm_name = "neonfp", .description = "Use NEON for single precision FP", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_branch_predictor)] = .{ + result[@backingInt(Feature.no_branch_predictor)] = .{ .llvm_name = "no-branch-predictor", .description = "Has no branch predictor", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_bti_at_return_twice)] = .{ + result[@backingInt(Feature.no_bti_at_return_twice)] = .{ .llvm_name = "no-bti-at-return-twice", .description = "Don't place a BTI instruction after a return-twice", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_movt)] = .{ + result[@backingInt(Feature.no_movt)] = .{ .llvm_name = "no-movt", .description = "Don't use movt/movw pairs for 32-bit imms", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_neg_immediates)] = .{ + result[@backingInt(Feature.no_neg_immediates)] = .{ .llvm_name = "no-neg-immediates", .description = "Convert immediates and instructions to their negated or complemented equivalent when the immediate does not fit in the encoding.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.noarm)] = .{ + result[@backingInt(Feature.noarm)] = .{ .llvm_name = "noarm", .description = "Does not support ARM mode execution", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nonpipelined_vfp)] = .{ + result[@backingInt(Feature.nonpipelined_vfp)] = .{ .llvm_name = "nonpipelined-vfp", .description = "VFP instructions are not pipelined", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pacbti)] = .{ + result[@backingInt(Feature.pacbti)] = .{ .llvm_name = "pacbti", .description = "Enable Pointer Authentication and Branch Target Identification", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.perfmon)] = .{ + result[@backingInt(Feature.perfmon)] = .{ .llvm_name = "perfmon", .description = "Enable support for Performance Monitor extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_ishst)] = .{ + result[@backingInt(Feature.prefer_ishst)] = .{ .llvm_name = "prefer-ishst", .description = "Prefer ISHST barriers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_vmovsr)] = .{ + result[@backingInt(Feature.prefer_vmovsr)] = .{ .llvm_name = "prefer-vmovsr", .description = "Prefer VMOVSR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prof_unpr)] = .{ + result[@backingInt(Feature.prof_unpr)] = .{ .llvm_name = "prof-unpr", .description = "Is profitable to unpredicate", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ras)] = .{ + result[@backingInt(Feature.ras)] = .{ .llvm_name = "ras", .description = "Enable Reliability, Availability and Serviceability extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rclass)] = .{ + result[@backingInt(Feature.rclass)] = .{ .llvm_name = "rclass", .description = "Is realtime profile ('R' series)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.read_tp_tpidrprw)] = .{ + result[@backingInt(Feature.read_tp_tpidrprw)] = .{ .llvm_name = "read-tp-tpidrprw", .description = "Reading thread pointer from TPIDRPRW register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.read_tp_tpidruro)] = .{ + result[@backingInt(Feature.read_tp_tpidruro)] = .{ .llvm_name = "read-tp-tpidruro", .description = "Reading thread pointer from TPIDRURO register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.read_tp_tpidrurw)] = .{ + result[@backingInt(Feature.read_tp_tpidrurw)] = .{ .llvm_name = "read-tp-tpidrurw", .description = "Reading thread pointer from TPIDRURW register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_r9)] = .{ + result[@backingInt(Feature.reserve_r9)] = .{ .llvm_name = "reserve-r9", .description = "Reserve R9, making it unavailable as GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ret_addr_stack)] = .{ + result[@backingInt(Feature.ret_addr_stack)] = .{ .llvm_name = "ret-addr-stack", .description = "Has return address stack", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sb)] = .{ + result[@backingInt(Feature.sb)] = .{ .llvm_name = "sb", .description = "Enable v8.5a Speculation Barrier", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sha2)] = .{ + result[@backingInt(Feature.sha2)] = .{ .llvm_name = "sha2", .description = "Enable SHA1 and SHA256 support", .dependencies = featureSet(&[_]Feature{ .neon, }), }; - result[@intFromEnum(Feature.slow_fp_brcc)] = .{ + result[@backingInt(Feature.slow_fp_brcc)] = .{ .llvm_name = "slow-fp-brcc", .description = "FP compare + branch is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_load_D_subreg)] = .{ + result[@backingInt(Feature.slow_load_D_subreg)] = .{ .llvm_name = "slow-load-D-subreg", .description = "Loading into D subregs is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_odd_reg)] = .{ + result[@backingInt(Feature.slow_odd_reg)] = .{ .llvm_name = "slow-odd-reg", .description = "VLDM/VSTM starting with an odd register is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_vdup32)] = .{ + result[@backingInt(Feature.slow_vdup32)] = .{ .llvm_name = "slow-vdup32", .description = "Has slow VDUP32 - prefer VMOV", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_vgetlni32)] = .{ + result[@backingInt(Feature.slow_vgetlni32)] = .{ .llvm_name = "slow-vgetlni32", .description = "Has slow VGETLNi32 - prefer VMOV", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slowfpvfmx)] = .{ + result[@backingInt(Feature.slowfpvfmx)] = .{ .llvm_name = "slowfpvfmx", .description = "Disable VFP / NEON FMA instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slowfpvmlx)] = .{ + result[@backingInt(Feature.slowfpvmlx)] = .{ .llvm_name = "slowfpvmlx", .description = "Disable VFP / NEON MAC instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.soft_float)] = .{ + result[@backingInt(Feature.soft_float)] = .{ .llvm_name = "soft-float", .description = "Use software floating point features.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.splat_vfp_neon)] = .{ + result[@backingInt(Feature.splat_vfp_neon)] = .{ .llvm_name = "splat-vfp-neon", .description = "Splat register from VFP to NEON", .dependencies = featureSet(&[_]Feature{ .dont_widen_vmovs, }), }; - result[@intFromEnum(Feature.strict_align)] = .{ + result[@backingInt(Feature.strict_align)] = .{ .llvm_name = "strict-align", .description = "Disallow all unaligned memory access", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.thumb2)] = .{ + result[@backingInt(Feature.thumb2)] = .{ .llvm_name = "thumb2", .description = "Enable Thumb2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.thumb_mode)] = .{ + result[@backingInt(Feature.thumb_mode)] = .{ .llvm_name = "thumb-mode", .description = "Thumb mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.trustzone)] = .{ + result[@backingInt(Feature.trustzone)] = .{ .llvm_name = "trustzone", .description = "Enable support for TrustZone security extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_mipipeliner)] = .{ + result[@backingInt(Feature.use_mipipeliner)] = .{ .llvm_name = "use-mipipeliner", .description = "Use the MachinePipeliner", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_misched)] = .{ + result[@backingInt(Feature.use_misched)] = .{ .llvm_name = "use-misched", .description = "Use the MachineScheduler", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v2)] = .{ + result[@backingInt(Feature.v2)] = .{ .llvm_name = null, .description = "ARMv2 architecture", .dependencies = featureSet(&[_]Feature{ .strict_align, }), }; - result[@intFromEnum(Feature.v2a)] = .{ + result[@backingInt(Feature.v2a)] = .{ .llvm_name = null, .description = "ARMv2a architecture", .dependencies = featureSet(&[_]Feature{ .strict_align, }), }; - result[@intFromEnum(Feature.v3)] = .{ + result[@backingInt(Feature.v3)] = .{ .llvm_name = null, .description = "ARMv3 architecture", .dependencies = featureSet(&[_]Feature{ .strict_align, }), }; - result[@intFromEnum(Feature.v3m)] = .{ + result[@backingInt(Feature.v3m)] = .{ .llvm_name = null, .description = "ARMv3m architecture", .dependencies = featureSet(&[_]Feature{ .strict_align, }), }; - result[@intFromEnum(Feature.v4)] = .{ + result[@backingInt(Feature.v4)] = .{ .llvm_name = "armv4", .description = "ARMv4 architecture", .dependencies = featureSet(&[_]Feature{ .strict_align, }), }; - result[@intFromEnum(Feature.v4t)] = .{ + result[@backingInt(Feature.v4t)] = .{ .llvm_name = "armv4t", .description = "ARMv4t architecture", .dependencies = featureSet(&[_]Feature{ @@ -1106,7 +1106,7 @@ pub const all_features = blk: { .strict_align, }), }; - result[@intFromEnum(Feature.v5t)] = .{ + result[@backingInt(Feature.v5t)] = .{ .llvm_name = "armv5t", .description = "ARMv5t architecture", .dependencies = featureSet(&[_]Feature{ @@ -1114,7 +1114,7 @@ pub const all_features = blk: { .strict_align, }), }; - result[@intFromEnum(Feature.v5te)] = .{ + result[@backingInt(Feature.v5te)] = .{ .llvm_name = "armv5te", .description = "ARMv5te architecture", .dependencies = featureSet(&[_]Feature{ @@ -1122,7 +1122,7 @@ pub const all_features = blk: { .strict_align, }), }; - result[@intFromEnum(Feature.v5tej)] = .{ + result[@backingInt(Feature.v5tej)] = .{ .llvm_name = "armv5tej", .description = "ARMv5tej architecture", .dependencies = featureSet(&[_]Feature{ @@ -1130,7 +1130,7 @@ pub const all_features = blk: { .strict_align, }), }; - result[@intFromEnum(Feature.v6)] = .{ + result[@backingInt(Feature.v6)] = .{ .llvm_name = "armv6", .description = "ARMv6 architecture", .dependencies = featureSet(&[_]Feature{ @@ -1138,21 +1138,21 @@ pub const all_features = blk: { .has_v6, }), }; - result[@intFromEnum(Feature.v6j)] = .{ + result[@backingInt(Feature.v6j)] = .{ .llvm_name = "armv6j", .description = "ARMv7a architecture", .dependencies = featureSet(&[_]Feature{ .v6, }), }; - result[@intFromEnum(Feature.v6k)] = .{ + result[@backingInt(Feature.v6k)] = .{ .llvm_name = "armv6k", .description = "ARMv6k architecture", .dependencies = featureSet(&[_]Feature{ .has_v6k, }), }; - result[@intFromEnum(Feature.v6kz)] = .{ + result[@backingInt(Feature.v6kz)] = .{ .llvm_name = "armv6kz", .description = "ARMv6kz architecture", .dependencies = featureSet(&[_]Feature{ @@ -1160,7 +1160,7 @@ pub const all_features = blk: { .trustzone, }), }; - result[@intFromEnum(Feature.v6m)] = .{ + result[@backingInt(Feature.v6m)] = .{ .llvm_name = "armv6-m", .description = "ARMv6m architecture", .dependencies = featureSet(&[_]Feature{ @@ -1172,7 +1172,7 @@ pub const all_features = blk: { .thumb_mode, }), }; - result[@intFromEnum(Feature.v6sm)] = .{ + result[@backingInt(Feature.v6sm)] = .{ .llvm_name = "armv6s-m", .description = "ARMv6sm architecture", .dependencies = featureSet(&[_]Feature{ @@ -1184,7 +1184,7 @@ pub const all_features = blk: { .thumb_mode, }), }; - result[@intFromEnum(Feature.v6t2)] = .{ + result[@backingInt(Feature.v6t2)] = .{ .llvm_name = "armv6t2", .description = "ARMv6t2 architecture", .dependencies = featureSet(&[_]Feature{ @@ -1192,7 +1192,7 @@ pub const all_features = blk: { .has_v6t2, }), }; - result[@intFromEnum(Feature.v7a)] = .{ + result[@backingInt(Feature.v7a)] = .{ .llvm_name = "armv7-a", .description = "ARMv7a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1204,7 +1204,7 @@ pub const all_features = blk: { .perfmon, }), }; - result[@intFromEnum(Feature.v7em)] = .{ + result[@backingInt(Feature.v7em)] = .{ .llvm_name = "armv7e-m", .description = "ARMv7em architecture", .dependencies = featureSet(&[_]Feature{ @@ -1217,7 +1217,7 @@ pub const all_features = blk: { .thumb_mode, }), }; - result[@intFromEnum(Feature.v7m)] = .{ + result[@backingInt(Feature.v7m)] = .{ .llvm_name = "armv7-m", .description = "ARMv7m architecture", .dependencies = featureSet(&[_]Feature{ @@ -1229,7 +1229,7 @@ pub const all_features = blk: { .thumb_mode, }), }; - result[@intFromEnum(Feature.v7r)] = .{ + result[@backingInt(Feature.v7r)] = .{ .llvm_name = "armv7-r", .description = "ARMv7r architecture", .dependencies = featureSet(&[_]Feature{ @@ -1241,7 +1241,7 @@ pub const all_features = blk: { .rclass, }), }; - result[@intFromEnum(Feature.v7ve)] = .{ + result[@backingInt(Feature.v7ve)] = .{ .llvm_name = "armv7ve", .description = "ARMv7ve architecture", .dependencies = featureSet(&[_]Feature{ @@ -1256,7 +1256,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_1a)] = .{ + result[@backingInt(Feature.v8_1a)] = .{ .llvm_name = "armv8.1-a", .description = "ARMv81a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1272,7 +1272,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_1m_main)] = .{ + result[@backingInt(Feature.v8_1m_main)] = .{ .llvm_name = "armv8.1-m.main", .description = "ARMv81mMainline architecture", .dependencies = featureSet(&[_]Feature{ @@ -1288,7 +1288,7 @@ pub const all_features = blk: { .thumb_mode, }), }; - result[@intFromEnum(Feature.v8_2a)] = .{ + result[@backingInt(Feature.v8_2a)] = .{ .llvm_name = "armv8.2-a", .description = "ARMv82a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1305,7 +1305,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_3a)] = .{ + result[@backingInt(Feature.v8_3a)] = .{ .llvm_name = "armv8.3-a", .description = "ARMv83a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1322,7 +1322,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_4a)] = .{ + result[@backingInt(Feature.v8_4a)] = .{ .llvm_name = "armv8.4-a", .description = "ARMv84a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1339,7 +1339,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_5a)] = .{ + result[@backingInt(Feature.v8_5a)] = .{ .llvm_name = "armv8.5-a", .description = "ARMv85a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1356,7 +1356,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_6a)] = .{ + result[@backingInt(Feature.v8_6a)] = .{ .llvm_name = "armv8.6-a", .description = "ARMv86a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1373,7 +1373,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_7a)] = .{ + result[@backingInt(Feature.v8_7a)] = .{ .llvm_name = "armv8.7-a", .description = "ARMv87a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1390,7 +1390,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_8a)] = .{ + result[@backingInt(Feature.v8_8a)] = .{ .llvm_name = "armv8.8-a", .description = "ARMv88a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1407,7 +1407,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8_9a)] = .{ + result[@backingInt(Feature.v8_9a)] = .{ .llvm_name = "armv8.9-a", .description = "ARMv89a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1424,7 +1424,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8a)] = .{ + result[@backingInt(Feature.v8a)] = .{ .llvm_name = "armv8-a", .description = "ARMv8a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1440,7 +1440,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v8m)] = .{ + result[@backingInt(Feature.v8m)] = .{ .llvm_name = "armv8-m.base", .description = "ARMv8mBaseline architecture", .dependencies = featureSet(&[_]Feature{ @@ -1456,7 +1456,7 @@ pub const all_features = blk: { .thumb_mode, }), }; - result[@intFromEnum(Feature.v8m_main)] = .{ + result[@backingInt(Feature.v8m_main)] = .{ .llvm_name = "armv8-m.main", .description = "ARMv8mMainline architecture", .dependencies = featureSet(&[_]Feature{ @@ -1470,7 +1470,7 @@ pub const all_features = blk: { .thumb_mode, }), }; - result[@intFromEnum(Feature.v8r)] = .{ + result[@backingInt(Feature.v8r)] = .{ .llvm_name = "armv8-r", .description = "ARMv8r architecture", .dependencies = featureSet(&[_]Feature{ @@ -1485,7 +1485,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9_1a)] = .{ + result[@backingInt(Feature.v9_1a)] = .{ .llvm_name = "armv9.1-a", .description = "ARMv91a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1501,7 +1501,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9_2a)] = .{ + result[@backingInt(Feature.v9_2a)] = .{ .llvm_name = "armv9.2-a", .description = "ARMv92a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1517,7 +1517,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9_3a)] = .{ + result[@backingInt(Feature.v9_3a)] = .{ .llvm_name = "armv9.3-a", .description = "ARMv93a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1534,7 +1534,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9_4a)] = .{ + result[@backingInt(Feature.v9_4a)] = .{ .llvm_name = "armv9.4-a", .description = "ARMv94a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1550,7 +1550,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9_5a)] = .{ + result[@backingInt(Feature.v9_5a)] = .{ .llvm_name = "armv9.5-a", .description = "ARMv95a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1566,7 +1566,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9_6a)] = .{ + result[@backingInt(Feature.v9_6a)] = .{ .llvm_name = "armv9.6-a", .description = "ARMv96a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1582,7 +1582,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9_7a)] = .{ + result[@backingInt(Feature.v9_7a)] = .{ .llvm_name = "armv9.7-a", .description = "ARMv97a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1598,7 +1598,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.v9a)] = .{ + result[@backingInt(Feature.v9a)] = .{ .llvm_name = "armv9-a", .description = "ARMv9a architecture", .dependencies = featureSet(&[_]Feature{ @@ -1614,7 +1614,7 @@ pub const all_features = blk: { .virtualization, }), }; - result[@intFromEnum(Feature.vfp2)] = .{ + result[@backingInt(Feature.vfp2)] = .{ .llvm_name = "vfp2", .description = "Enable VFP2 instructions", .dependencies = featureSet(&[_]Feature{ @@ -1622,14 +1622,14 @@ pub const all_features = blk: { .vfp2sp, }), }; - result[@intFromEnum(Feature.vfp2sp)] = .{ + result[@backingInt(Feature.vfp2sp)] = .{ .llvm_name = "vfp2sp", .description = "Enable VFP2 instructions with no double precision", .dependencies = featureSet(&[_]Feature{ .fpregs, }), }; - result[@intFromEnum(Feature.vfp3)] = .{ + result[@backingInt(Feature.vfp3)] = .{ .llvm_name = "vfp3", .description = "Enable VFP3 instructions", .dependencies = featureSet(&[_]Feature{ @@ -1637,7 +1637,7 @@ pub const all_features = blk: { .vfp3sp, }), }; - result[@intFromEnum(Feature.vfp3d16)] = .{ + result[@backingInt(Feature.vfp3d16)] = .{ .llvm_name = "vfp3d16", .description = "Enable VFP3 instructions with only 16 d-registers", .dependencies = featureSet(&[_]Feature{ @@ -1645,14 +1645,14 @@ pub const all_features = blk: { .vfp3d16sp, }), }; - result[@intFromEnum(Feature.vfp3d16sp)] = .{ + result[@backingInt(Feature.vfp3d16sp)] = .{ .llvm_name = "vfp3d16sp", .description = "Enable VFP3 instructions with only 16 d-registers and no double precision", .dependencies = featureSet(&[_]Feature{ .vfp2sp, }), }; - result[@intFromEnum(Feature.vfp3sp)] = .{ + result[@backingInt(Feature.vfp3sp)] = .{ .llvm_name = "vfp3sp", .description = "Enable VFP3 instructions with no double precision", .dependencies = featureSet(&[_]Feature{ @@ -1660,7 +1660,7 @@ pub const all_features = blk: { .vfp3d16sp, }), }; - result[@intFromEnum(Feature.vfp4)] = .{ + result[@backingInt(Feature.vfp4)] = .{ .llvm_name = "vfp4", .description = "Enable VFP4 instructions", .dependencies = featureSet(&[_]Feature{ @@ -1669,7 +1669,7 @@ pub const all_features = blk: { .vfp4sp, }), }; - result[@intFromEnum(Feature.vfp4d16)] = .{ + result[@backingInt(Feature.vfp4d16)] = .{ .llvm_name = "vfp4d16", .description = "Enable VFP4 instructions with only 16 d-registers", .dependencies = featureSet(&[_]Feature{ @@ -1677,7 +1677,7 @@ pub const all_features = blk: { .vfp4d16sp, }), }; - result[@intFromEnum(Feature.vfp4d16sp)] = .{ + result[@backingInt(Feature.vfp4d16sp)] = .{ .llvm_name = "vfp4d16sp", .description = "Enable VFP4 instructions with only 16 d-registers and no double precision", .dependencies = featureSet(&[_]Feature{ @@ -1685,7 +1685,7 @@ pub const all_features = blk: { .vfp3d16sp, }), }; - result[@intFromEnum(Feature.vfp4sp)] = .{ + result[@backingInt(Feature.vfp4sp)] = .{ .llvm_name = "vfp4sp", .description = "Enable VFP4 instructions with no double precision", .dependencies = featureSet(&[_]Feature{ @@ -1693,7 +1693,7 @@ pub const all_features = blk: { .vfp4d16sp, }), }; - result[@intFromEnum(Feature.virtualization)] = .{ + result[@backingInt(Feature.virtualization)] = .{ .llvm_name = "virtualization", .description = "Supports Virtualization extension", .dependencies = featureSet(&[_]Feature{ @@ -1701,34 +1701,34 @@ pub const all_features = blk: { .hwdiv_arm, }), }; - result[@intFromEnum(Feature.vldn_align)] = .{ + result[@backingInt(Feature.vldn_align)] = .{ .llvm_name = "vldn-align", .description = "Check for VLDn unaligned access", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vmlx_forwarding)] = .{ + result[@backingInt(Feature.vmlx_forwarding)] = .{ .llvm_name = "vmlx-forwarding", .description = "Has multiplier accumulator forwarding", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vmlx_hazards)] = .{ + result[@backingInt(Feature.vmlx_hazards)] = .{ .llvm_name = "vmlx-hazards", .description = "Has VMLx hazards", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wide_stride_vfp)] = .{ + result[@backingInt(Feature.wide_stride_vfp)] = .{ .llvm_name = "wide-stride-vfp", .description = "Use a wide stride when allocating VFP registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xscale)] = .{ + result[@backingInt(Feature.xscale)] = .{ .llvm_name = "xscale", .description = "ARMv5te architecture", .dependencies = featureSet(&[_]Feature{ .v5te, }), }; - result[@intFromEnum(Feature.zcz)] = .{ + result[@backingInt(Feature.zcz)] = .{ .llvm_name = "zcz", .description = "Has zero-cycle zeroing instructions", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/avr.zig b/lib/std/Target/avr.zig index 85b15bb636504555a9063cdd1ab9ec8e8f892420..0d0f1e910948ec5a714ef5746445d903a3bfcd92 100644 --- a/lib/std/Target/avr.zig +++ b/lib/std/Target/avr.zig @@ -55,17 +55,17 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.addsubiw)] = .{ + result[@backingInt(Feature.addsubiw)] = .{ .llvm_name = "addsubiw", .description = "Enable 16-bit register-immediate addition and subtraction instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.avr0)] = .{ + result[@backingInt(Feature.avr0)] = .{ .llvm_name = "avr0", .description = "The device is a part of the avr0 family", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.avr1)] = .{ + result[@backingInt(Feature.avr1)] = .{ .llvm_name = "avr1", .description = "The device is a part of the avr1 family", .dependencies = featureSet(&[_]Feature{ @@ -74,7 +74,7 @@ pub const all_features = blk: { .memmappedregs, }), }; - result[@intFromEnum(Feature.avr2)] = .{ + result[@backingInt(Feature.avr2)] = .{ .llvm_name = "avr2", .description = "The device is a part of the avr2 family", .dependencies = featureSet(&[_]Feature{ @@ -84,7 +84,7 @@ pub const all_features = blk: { .sram, }), }; - result[@intFromEnum(Feature.avr25)] = .{ + result[@backingInt(Feature.avr25)] = .{ .llvm_name = "avr25", .description = "The device is a part of the avr25 family", .dependencies = featureSet(&[_]Feature{ @@ -95,7 +95,7 @@ pub const all_features = blk: { .spm, }), }; - result[@intFromEnum(Feature.avr3)] = .{ + result[@backingInt(Feature.avr3)] = .{ .llvm_name = "avr3", .description = "The device is a part of the avr3 family", .dependencies = featureSet(&[_]Feature{ @@ -103,7 +103,7 @@ pub const all_features = blk: { .jmpcall, }), }; - result[@intFromEnum(Feature.avr31)] = .{ + result[@backingInt(Feature.avr31)] = .{ .llvm_name = "avr31", .description = "The device is a part of the avr31 family", .dependencies = featureSet(&[_]Feature{ @@ -111,7 +111,7 @@ pub const all_features = blk: { .elpm, }), }; - result[@intFromEnum(Feature.avr35)] = .{ + result[@backingInt(Feature.avr35)] = .{ .llvm_name = "avr35", .description = "The device is a part of the avr35 family", .dependencies = featureSet(&[_]Feature{ @@ -122,7 +122,7 @@ pub const all_features = blk: { .spm, }), }; - result[@intFromEnum(Feature.avr4)] = .{ + result[@backingInt(Feature.avr4)] = .{ .llvm_name = "avr4", .description = "The device is a part of the avr4 family", .dependencies = featureSet(&[_]Feature{ @@ -134,7 +134,7 @@ pub const all_features = blk: { .spm, }), }; - result[@intFromEnum(Feature.avr5)] = .{ + result[@backingInt(Feature.avr5)] = .{ .llvm_name = "avr5", .description = "The device is a part of the avr5 family", .dependencies = featureSet(&[_]Feature{ @@ -146,7 +146,7 @@ pub const all_features = blk: { .spm, }), }; - result[@intFromEnum(Feature.avr51)] = .{ + result[@backingInt(Feature.avr51)] = .{ .llvm_name = "avr51", .description = "The device is a part of the avr51 family", .dependencies = featureSet(&[_]Feature{ @@ -155,7 +155,7 @@ pub const all_features = blk: { .elpmx, }), }; - result[@intFromEnum(Feature.avr6)] = .{ + result[@backingInt(Feature.avr6)] = .{ .llvm_name = "avr6", .description = "The device is a part of the avr6 family", .dependencies = featureSet(&[_]Feature{ @@ -163,7 +163,7 @@ pub const all_features = blk: { .eijmpcall, }), }; - result[@intFromEnum(Feature.avrtiny)] = .{ + result[@backingInt(Feature.avrtiny)] = .{ .llvm_name = "avrtiny", .description = "The device is a part of the avrtiny family", .dependencies = featureSet(&[_]Feature{ @@ -174,82 +174,82 @@ pub const all_features = blk: { .tinyencoding, }), }; - result[@intFromEnum(Feature.@"break")] = .{ + result[@backingInt(Feature.@"break")] = .{ .llvm_name = "break", .description = "The device supports the `BREAK` debugging instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.des)] = .{ + result[@backingInt(Feature.des)] = .{ .llvm_name = "des", .description = "The device supports the `DES k` encryption instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.eijmpcall)] = .{ + result[@backingInt(Feature.eijmpcall)] = .{ .llvm_name = "eijmpcall", .description = "The device supports the `EIJMP`/`EICALL` instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.elpm)] = .{ + result[@backingInt(Feature.elpm)] = .{ .llvm_name = "elpm", .description = "The device supports the ELPM instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.elpmx)] = .{ + result[@backingInt(Feature.elpmx)] = .{ .llvm_name = "elpmx", .description = "The device supports the `ELPM Rd, Z[+]` instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ijmpcall)] = .{ + result[@backingInt(Feature.ijmpcall)] = .{ .llvm_name = "ijmpcall", .description = "The device supports `IJMP`/`ICALL`instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.jmpcall)] = .{ + result[@backingInt(Feature.jmpcall)] = .{ .llvm_name = "jmpcall", .description = "The device supports the `JMP` and `CALL` instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lowbytefirst)] = .{ + result[@backingInt(Feature.lowbytefirst)] = .{ .llvm_name = "lowbytefirst", .description = "Do the low byte first when writing a 16-bit port or storing a 16-bit word", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lpm)] = .{ + result[@backingInt(Feature.lpm)] = .{ .llvm_name = "lpm", .description = "The device supports the `LPM` instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lpmx)] = .{ + result[@backingInt(Feature.lpmx)] = .{ .llvm_name = "lpmx", .description = "The device supports the `LPM Rd, Z[+]` instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.memmappedregs)] = .{ + result[@backingInt(Feature.memmappedregs)] = .{ .llvm_name = "memmappedregs", .description = "The device has CPU registers mapped in data address space", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.movw)] = .{ + result[@backingInt(Feature.movw)] = .{ .llvm_name = "movw", .description = "The device supports the 16-bit MOVW instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mul)] = .{ + result[@backingInt(Feature.mul)] = .{ .llvm_name = "mul", .description = "The device supports the multiplication instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rmw)] = .{ + result[@backingInt(Feature.rmw)] = .{ .llvm_name = "rmw", .description = "The device supports the read-write-modify instructions: XCH, LAS, LAC, LAT", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smallstack)] = .{ + result[@backingInt(Feature.smallstack)] = .{ .llvm_name = "smallstack", .description = "The device has an 8-bit stack pointer", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.special)] = .{ + result[@backingInt(Feature.special)] = .{ .llvm_name = "special", .description = "Enable use of the entire instruction set - used for debugging", .dependencies = featureSet(&[_]Feature{ @@ -272,32 +272,32 @@ pub const all_features = blk: { .sram, }), }; - result[@intFromEnum(Feature.spm)] = .{ + result[@backingInt(Feature.spm)] = .{ .llvm_name = "spm", .description = "The device supports the `SPM` instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.spmx)] = .{ + result[@backingInt(Feature.spmx)] = .{ .llvm_name = "spmx", .description = "The device supports the `SPM Z+` instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sram)] = .{ + result[@backingInt(Feature.sram)] = .{ .llvm_name = "sram", .description = "The device has random access memory", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tinyencoding)] = .{ + result[@backingInt(Feature.tinyencoding)] = .{ .llvm_name = "tinyencoding", .description = "The device has Tiny core specific instruction encodings", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wrappingrjmp)] = .{ + result[@backingInt(Feature.wrappingrjmp)] = .{ .llvm_name = "wrappingrjmp", .description = "The device potentially requires emitting rjmp that wraps across the flash boundary", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xmega)] = .{ + result[@backingInt(Feature.xmega)] = .{ .llvm_name = "xmega", .description = "The device is a part of the xmega family", .dependencies = featureSet(&[_]Feature{ @@ -320,7 +320,7 @@ pub const all_features = blk: { .sram, }), }; - result[@intFromEnum(Feature.xmega2)] = .{ + result[@backingInt(Feature.xmega2)] = .{ .llvm_name = "xmega2", .description = "The device is a part of the xmega2 family", .dependencies = featureSet(&[_]Feature{ @@ -339,7 +339,7 @@ pub const all_features = blk: { .sram, }), }; - result[@intFromEnum(Feature.xmega3)] = .{ + result[@backingInt(Feature.xmega3)] = .{ .llvm_name = "xmega3", .description = "The device is a part of the xmega3 family", .dependencies = featureSet(&[_]Feature{ @@ -356,7 +356,7 @@ pub const all_features = blk: { .sram, }), }; - result[@intFromEnum(Feature.xmega4)] = .{ + result[@backingInt(Feature.xmega4)] = .{ .llvm_name = "xmega4", .description = "The device is a part of the xmega4 family", .dependencies = featureSet(&[_]Feature{ @@ -377,7 +377,7 @@ pub const all_features = blk: { .sram, }), }; - result[@intFromEnum(Feature.xmegau)] = .{ + result[@backingInt(Feature.xmegau)] = .{ .llvm_name = "xmegau", .description = "The device is a part of the xmegau family", .dependencies = featureSet(&[_]Feature{ diff --git a/lib/std/Target/bpf.zig b/lib/std/Target/bpf.zig index a5e34bb0d07cb47991ff176f940e7d11cda1546a..f55ebf8b01ef0ae8947914c8ee53c47847bcfd49 100644 --- a/lib/std/Target/bpf.zig +++ b/lib/std/Target/bpf.zig @@ -20,22 +20,22 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.allows_misaligned_mem_access)] = .{ + result[@backingInt(Feature.allows_misaligned_mem_access)] = .{ .llvm_name = "allows-misaligned-mem-access", .description = "Allows misaligned memory access", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.alu32)] = .{ + result[@backingInt(Feature.alu32)] = .{ .llvm_name = "alu32", .description = "Enable ALU32 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dummy)] = .{ + result[@backingInt(Feature.dummy)] = .{ .llvm_name = "dummy", .description = "unused feature", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dwarfris)] = .{ + result[@backingInt(Feature.dwarfris)] = .{ .llvm_name = "dwarfris", .description = "Disable MCAsmInfo DwarfUsesRelocationsAcrossSections", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/csky.zig b/lib/std/Target/csky.zig index 4b40098a9cbc328b2bc8cb186420dadde22a0581..913d22c06df9c93a755fd9d4ecf6984370933fbd 100644 --- a/lib/std/Target/csky.zig +++ b/lib/std/Target/csky.zig @@ -79,26 +79,26 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"10e60")] = .{ + result[@backingInt(Feature.@"10e60")] = .{ .llvm_name = "10e60", .description = "Support CSKY 10e60 instructions", .dependencies = featureSet(&[_]Feature{ .@"7e10", }), }; - result[@intFromEnum(Feature.@"2e3")] = .{ + result[@backingInt(Feature.@"2e3")] = .{ .llvm_name = "2e3", .description = "Support CSKY 2e3 instructions", .dependencies = featureSet(&[_]Feature{ .e2, }), }; - result[@intFromEnum(Feature.@"3e3r1")] = .{ + result[@backingInt(Feature.@"3e3r1")] = .{ .llvm_name = "3e3r1", .description = "Support CSKY 3e3r1 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"3e3r2")] = .{ + result[@backingInt(Feature.@"3e3r2")] = .{ .llvm_name = "3e3r2", .description = "Support CSKY 3e3r2 instructions", .dependencies = featureSet(&[_]Feature{ @@ -106,311 +106,311 @@ pub const all_features = blk: { .doloop, }), }; - result[@intFromEnum(Feature.@"3e3r3")] = .{ + result[@backingInt(Feature.@"3e3r3")] = .{ .llvm_name = "3e3r3", .description = "Support CSKY 3e3r3 instructions", .dependencies = featureSet(&[_]Feature{ .doloop, }), }; - result[@intFromEnum(Feature.@"3e7")] = .{ + result[@backingInt(Feature.@"3e7")] = .{ .llvm_name = "3e7", .description = "Support CSKY 3e7 instructions", .dependencies = featureSet(&[_]Feature{ .@"2e3", }), }; - result[@intFromEnum(Feature.@"7e10")] = .{ + result[@backingInt(Feature.@"7e10")] = .{ .llvm_name = "7e10", .description = "Support CSKY 7e10 instructions", .dependencies = featureSet(&[_]Feature{ .@"3e7", }), }; - result[@intFromEnum(Feature.btst16)] = .{ + result[@backingInt(Feature.btst16)] = .{ .llvm_name = "btst16", .description = "Use the 16-bit btsti instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cache)] = .{ + result[@backingInt(Feature.cache)] = .{ .llvm_name = "cache", .description = "Enable cache", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ccrt)] = .{ + result[@backingInt(Feature.ccrt)] = .{ .llvm_name = "ccrt", .description = "Use CSKY compiler runtime", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck801)] = .{ + result[@backingInt(Feature.ck801)] = .{ .llvm_name = "ck801", .description = "CSKY ck801 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck802)] = .{ + result[@backingInt(Feature.ck802)] = .{ .llvm_name = "ck802", .description = "CSKY ck802 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck803)] = .{ + result[@backingInt(Feature.ck803)] = .{ .llvm_name = "ck803", .description = "CSKY ck803 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck803s)] = .{ + result[@backingInt(Feature.ck803s)] = .{ .llvm_name = "ck803s", .description = "CSKY ck803s processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck804)] = .{ + result[@backingInt(Feature.ck804)] = .{ .llvm_name = "ck804", .description = "CSKY ck804 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck805)] = .{ + result[@backingInt(Feature.ck805)] = .{ .llvm_name = "ck805", .description = "CSKY ck805 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck807)] = .{ + result[@backingInt(Feature.ck807)] = .{ .llvm_name = "ck807", .description = "CSKY ck807 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck810)] = .{ + result[@backingInt(Feature.ck810)] = .{ .llvm_name = "ck810", .description = "CSKY ck810 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck810v)] = .{ + result[@backingInt(Feature.ck810v)] = .{ .llvm_name = "ck810v", .description = "CSKY ck810v processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck860)] = .{ + result[@backingInt(Feature.ck860)] = .{ .llvm_name = "ck860", .description = "CSKY ck860 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ck860v)] = .{ + result[@backingInt(Feature.ck860v)] = .{ .llvm_name = "ck860v", .description = "CSKY ck860v processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.constpool)] = .{ + result[@backingInt(Feature.constpool)] = .{ .llvm_name = "constpool", .description = "Dump the constant pool by compiler", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.doloop)] = .{ + result[@backingInt(Feature.doloop)] = .{ .llvm_name = "doloop", .description = "Enable doloop instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dsp1e2)] = .{ + result[@backingInt(Feature.dsp1e2)] = .{ .llvm_name = "dsp1e2", .description = "Support CSKY dsp1e2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dsp_silan)] = .{ + result[@backingInt(Feature.dsp_silan)] = .{ .llvm_name = "dsp_silan", .description = "Enable DSP Silan instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dspe60)] = .{ + result[@backingInt(Feature.dspe60)] = .{ .llvm_name = "dspe60", .description = "Support CSKY dspe60 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dspv2)] = .{ + result[@backingInt(Feature.dspv2)] = .{ .llvm_name = "dspv2", .description = "Enable DSP V2.0 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.e1)] = .{ + result[@backingInt(Feature.e1)] = .{ .llvm_name = "e1", .description = "Support CSKY e1 instructions", .dependencies = featureSet(&[_]Feature{ .elrw, }), }; - result[@intFromEnum(Feature.e2)] = .{ + result[@backingInt(Feature.e2)] = .{ .llvm_name = "e2", .description = "Support CSKY e2 instructions", .dependencies = featureSet(&[_]Feature{ .e1, }), }; - result[@intFromEnum(Feature.edsp)] = .{ + result[@backingInt(Feature.edsp)] = .{ .llvm_name = "edsp", .description = "Enable DSP instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.elrw)] = .{ + result[@backingInt(Feature.elrw)] = .{ .llvm_name = "elrw", .description = "Use the extend LRW instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fdivdu)] = .{ + result[@backingInt(Feature.fdivdu)] = .{ .llvm_name = "fdivdu", .description = "Enable float divide instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.float1e2)] = .{ + result[@backingInt(Feature.float1e2)] = .{ .llvm_name = "float1e2", .description = "Support CSKY float1e2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.float1e3)] = .{ + result[@backingInt(Feature.float1e3)] = .{ .llvm_name = "float1e3", .description = "Support CSKY float1e3 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.float3e4)] = .{ + result[@backingInt(Feature.float3e4)] = .{ .llvm_name = "float3e4", .description = "Support CSKY float3e4 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.float7e60)] = .{ + result[@backingInt(Feature.float7e60)] = .{ .llvm_name = "float7e60", .description = "Support CSKY float7e60 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.floate1)] = .{ + result[@backingInt(Feature.floate1)] = .{ .llvm_name = "floate1", .description = "Support CSKY floate1 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpuv2_df)] = .{ + result[@backingInt(Feature.fpuv2_df)] = .{ .llvm_name = "fpuv2_df", .description = "Enable FPUv2 double float instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpuv2_sf)] = .{ + result[@backingInt(Feature.fpuv2_sf)] = .{ .llvm_name = "fpuv2_sf", .description = "Enable FPUv2 single float instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpuv3_df)] = .{ + result[@backingInt(Feature.fpuv3_df)] = .{ .llvm_name = "fpuv3_df", .description = "Enable FPUv3 double float instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpuv3_hf)] = .{ + result[@backingInt(Feature.fpuv3_hf)] = .{ .llvm_name = "fpuv3_hf", .description = "Enable FPUv3 half precision operate instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpuv3_hi)] = .{ + result[@backingInt(Feature.fpuv3_hi)] = .{ .llvm_name = "fpuv3_hi", .description = "Enable FPUv3 half word converting instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpuv3_sf)] = .{ + result[@backingInt(Feature.fpuv3_sf)] = .{ .llvm_name = "fpuv3_sf", .description = "Enable FPUv3 single float instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hard_float)] = .{ + result[@backingInt(Feature.hard_float)] = .{ .llvm_name = "hard-float", .description = "Use hard floating point features", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hard_float_abi)] = .{ + result[@backingInt(Feature.hard_float_abi)] = .{ .llvm_name = "hard-float-abi", .description = "Use hard floating point ABI to pass args", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hard_tp)] = .{ + result[@backingInt(Feature.hard_tp)] = .{ .llvm_name = "hard-tp", .description = "Enable TLS Pointer register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.high_registers)] = .{ + result[@backingInt(Feature.high_registers)] = .{ .llvm_name = "high-registers", .description = "Enable r16-r31 registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hwdiv)] = .{ + result[@backingInt(Feature.hwdiv)] = .{ .llvm_name = "hwdiv", .description = "Enable divide instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.istack)] = .{ + result[@backingInt(Feature.istack)] = .{ .llvm_name = "istack", .description = "Enable interrupt attribute", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.java)] = .{ + result[@backingInt(Feature.java)] = .{ .llvm_name = "java", .description = "Enable java instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mp)] = .{ + result[@backingInt(Feature.mp)] = .{ .llvm_name = "mp", .description = "Support CSKY mp instructions", .dependencies = featureSet(&[_]Feature{ .@"2e3", }), }; - result[@intFromEnum(Feature.mp1e2)] = .{ + result[@backingInt(Feature.mp1e2)] = .{ .llvm_name = "mp1e2", .description = "Support CSKY mp1e2 instructions", .dependencies = featureSet(&[_]Feature{ .@"3e7", }), }; - result[@intFromEnum(Feature.multiple_stld)] = .{ + result[@backingInt(Feature.multiple_stld)] = .{ .llvm_name = "multiple_stld", .description = "Enable multiple load/store instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nvic)] = .{ + result[@backingInt(Feature.nvic)] = .{ .llvm_name = "nvic", .description = "Enable NVIC", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pushpop)] = .{ + result[@backingInt(Feature.pushpop)] = .{ .llvm_name = "pushpop", .description = "Enable push/pop instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smart)] = .{ + result[@backingInt(Feature.smart)] = .{ .llvm_name = "smart", .description = "Let CPU work in Smart Mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.soft_tp)] = .{ + result[@backingInt(Feature.soft_tp)] = .{ .llvm_name = "soft-tp", .description = "Disable TLS Pointer register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.stack_size)] = .{ + result[@backingInt(Feature.stack_size)] = .{ .llvm_name = "stack-size", .description = "Output stack size information", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.trust)] = .{ + result[@backingInt(Feature.trust)] = .{ .llvm_name = "trust", .description = "Enable trust instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vdsp2e3)] = .{ + result[@backingInt(Feature.vdsp2e3)] = .{ .llvm_name = "vdsp2e3", .description = "Support CSKY vdsp2e3 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vdsp2e60f)] = .{ + result[@backingInt(Feature.vdsp2e60f)] = .{ .llvm_name = "vdsp2e60f", .description = "Support CSKY vdsp2e60f instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vdspv1)] = .{ + result[@backingInt(Feature.vdspv1)] = .{ .llvm_name = "vdspv1", .description = "Enable 128bit vdsp-v1 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vdspv2)] = .{ + result[@backingInt(Feature.vdspv2)] = .{ .llvm_name = "vdspv2", .description = "Enable vdsp-v2 instructions", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/hexagon.zig b/lib/std/Target/hexagon.zig index 9de1e04b5d5acd3207dc81db008f241a858a654b..2342edacb1bdb089971030a5dc891e1b08bd4ab3 100644 --- a/lib/std/Target/hexagon.zig +++ b/lib/std/Target/hexagon.zig @@ -63,77 +63,77 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.audio)] = .{ + result[@backingInt(Feature.audio)] = .{ .llvm_name = "audio", .description = "Hexagon Audio extension instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cabac)] = .{ + result[@backingInt(Feature.cabac)] = .{ .llvm_name = "cabac", .description = "Emit the CABAC instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.compound)] = .{ + result[@backingInt(Feature.compound)] = .{ .llvm_name = "compound", .description = "Use compound instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.duplex)] = .{ + result[@backingInt(Feature.duplex)] = .{ .llvm_name = "duplex", .description = "Enable generation of duplex instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hvx)] = .{ + result[@backingInt(Feature.hvx)] = .{ .llvm_name = "hvx", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hvx_ieee_fp)] = .{ + result[@backingInt(Feature.hvx_ieee_fp)] = .{ .llvm_name = "hvx-ieee-fp", .description = "Hexagon HVX IEEE floating point instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hvx_length128b)] = .{ + result[@backingInt(Feature.hvx_length128b)] = .{ .llvm_name = "hvx-length128b", .description = "Hexagon HVX 128B instructions", .dependencies = featureSet(&[_]Feature{ .hvx, }), }; - result[@intFromEnum(Feature.hvx_length64b)] = .{ + result[@backingInt(Feature.hvx_length64b)] = .{ .llvm_name = "hvx-length64b", .description = "Hexagon HVX 64B instructions", .dependencies = featureSet(&[_]Feature{ .hvx, }), }; - result[@intFromEnum(Feature.hvx_qfloat)] = .{ + result[@backingInt(Feature.hvx_qfloat)] = .{ .llvm_name = "hvx-qfloat", .description = "Hexagon HVX QFloating point instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hvxv60)] = .{ + result[@backingInt(Feature.hvxv60)] = .{ .llvm_name = "hvxv60", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvx, }), }; - result[@intFromEnum(Feature.hvxv62)] = .{ + result[@backingInt(Feature.hvxv62)] = .{ .llvm_name = "hvxv62", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv60, }), }; - result[@intFromEnum(Feature.hvxv65)] = .{ + result[@backingInt(Feature.hvxv65)] = .{ .llvm_name = "hvxv65", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv62, }), }; - result[@intFromEnum(Feature.hvxv66)] = .{ + result[@backingInt(Feature.hvxv66)] = .{ .llvm_name = "hvxv66", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ @@ -141,192 +141,192 @@ pub const all_features = blk: { .zreg, }), }; - result[@intFromEnum(Feature.hvxv67)] = .{ + result[@backingInt(Feature.hvxv67)] = .{ .llvm_name = "hvxv67", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv66, }), }; - result[@intFromEnum(Feature.hvxv68)] = .{ + result[@backingInt(Feature.hvxv68)] = .{ .llvm_name = "hvxv68", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv67, }), }; - result[@intFromEnum(Feature.hvxv69)] = .{ + result[@backingInt(Feature.hvxv69)] = .{ .llvm_name = "hvxv69", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv68, }), }; - result[@intFromEnum(Feature.hvxv71)] = .{ + result[@backingInt(Feature.hvxv71)] = .{ .llvm_name = "hvxv71", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv69, }), }; - result[@intFromEnum(Feature.hvxv73)] = .{ + result[@backingInt(Feature.hvxv73)] = .{ .llvm_name = "hvxv73", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv71, }), }; - result[@intFromEnum(Feature.hvxv75)] = .{ + result[@backingInt(Feature.hvxv75)] = .{ .llvm_name = "hvxv75", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv73, }), }; - result[@intFromEnum(Feature.hvxv79)] = .{ + result[@backingInt(Feature.hvxv79)] = .{ .llvm_name = "hvxv79", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv75, }), }; - result[@intFromEnum(Feature.hvxv81)] = .{ + result[@backingInt(Feature.hvxv81)] = .{ .llvm_name = "hvxv81", .description = "Hexagon HVX instructions", .dependencies = featureSet(&[_]Feature{ .hvxv79, }), }; - result[@intFromEnum(Feature.long_calls)] = .{ + result[@backingInt(Feature.long_calls)] = .{ .llvm_name = "long-calls", .description = "Use constant-extended calls", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mem_noshuf)] = .{ + result[@backingInt(Feature.mem_noshuf)] = .{ .llvm_name = "mem_noshuf", .description = "Supports mem_noshuf feature", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.memops)] = .{ + result[@backingInt(Feature.memops)] = .{ .llvm_name = "memops", .description = "Use memop instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.noreturn_stack_elim)] = .{ + result[@backingInt(Feature.noreturn_stack_elim)] = .{ .llvm_name = "noreturn-stack-elim", .description = "Eliminate stack allocation in a noreturn function when possible", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nvj)] = .{ + result[@backingInt(Feature.nvj)] = .{ .llvm_name = "nvj", .description = "Support for new-value jumps", .dependencies = featureSet(&[_]Feature{ .packets, }), }; - result[@intFromEnum(Feature.nvs)] = .{ + result[@backingInt(Feature.nvs)] = .{ .llvm_name = "nvs", .description = "Support for new-value stores", .dependencies = featureSet(&[_]Feature{ .packets, }), }; - result[@intFromEnum(Feature.packets)] = .{ + result[@backingInt(Feature.packets)] = .{ .llvm_name = "packets", .description = "Support for instruction packets", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prev65)] = .{ + result[@backingInt(Feature.prev65)] = .{ .llvm_name = "prev65", .description = "Support features deprecated in v65", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserved_r19)] = .{ + result[@backingInt(Feature.reserved_r19)] = .{ .llvm_name = "reserved-r19", .description = "Reserve register R19", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.small_data)] = .{ + result[@backingInt(Feature.small_data)] = .{ .llvm_name = "small-data", .description = "Allow GP-relative addressing of global variables", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tinycore)] = .{ + result[@backingInt(Feature.tinycore)] = .{ .llvm_name = "tinycore", .description = "Hexagon Tiny Core", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v5)] = .{ + result[@backingInt(Feature.v5)] = .{ .llvm_name = "v5", .description = "Enable Hexagon V5 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v55)] = .{ + result[@backingInt(Feature.v55)] = .{ .llvm_name = "v55", .description = "Enable Hexagon V55 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v60)] = .{ + result[@backingInt(Feature.v60)] = .{ .llvm_name = "v60", .description = "Enable Hexagon V60 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v62)] = .{ + result[@backingInt(Feature.v62)] = .{ .llvm_name = "v62", .description = "Enable Hexagon V62 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v65)] = .{ + result[@backingInt(Feature.v65)] = .{ .llvm_name = "v65", .description = "Enable Hexagon V65 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v66)] = .{ + result[@backingInt(Feature.v66)] = .{ .llvm_name = "v66", .description = "Enable Hexagon V66 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v67)] = .{ + result[@backingInt(Feature.v67)] = .{ .llvm_name = "v67", .description = "Enable Hexagon V67 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v68)] = .{ + result[@backingInt(Feature.v68)] = .{ .llvm_name = "v68", .description = "Enable Hexagon V68 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v69)] = .{ + result[@backingInt(Feature.v69)] = .{ .llvm_name = "v69", .description = "Enable Hexagon V69 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v71)] = .{ + result[@backingInt(Feature.v71)] = .{ .llvm_name = "v71", .description = "Enable Hexagon V71 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v73)] = .{ + result[@backingInt(Feature.v73)] = .{ .llvm_name = "v73", .description = "Enable Hexagon V73 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v75)] = .{ + result[@backingInt(Feature.v75)] = .{ .llvm_name = "v75", .description = "Enable Hexagon V75 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v79)] = .{ + result[@backingInt(Feature.v79)] = .{ .llvm_name = "v79", .description = "Enable Hexagon V79 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v81)] = .{ + result[@backingInt(Feature.v81)] = .{ .llvm_name = "v81", .description = "Enable Hexagon V81 architecture", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zreg)] = .{ + result[@backingInt(Feature.zreg)] = .{ .llvm_name = "zreg", .description = "Hexagon ZReg extension instructions", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/hppa.zig b/lib/std/Target/hppa.zig index 881b17db06903379b8cb00e64fd7ed1bf4c75603..306ceb5c9a4ea2a7474221482b906fcf40114826 100644 --- a/lib/std/Target/hppa.zig +++ b/lib/std/Target/hppa.zig @@ -21,31 +21,31 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"64bit")] = .{ + result[@backingInt(Feature.@"64bit")] = .{ .llvm_name = null, .description = "Enable 64-bit PA-RISC 2.0", .dependencies = featureSet(&[_]Feature{ .v2_0, }), }; - result[@intFromEnum(Feature.max_1)] = .{ + result[@backingInt(Feature.max_1)] = .{ .llvm_name = null, .description = "Enable MAX-1 multimedia acceleration extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.max_2)] = .{ + result[@backingInt(Feature.max_2)] = .{ .llvm_name = null, .description = "Enable MAX-2 multimedia acceleration extensions", .dependencies = featureSet(&[_]Feature{ .max_1, }), }; - result[@intFromEnum(Feature.v1_1)] = .{ + result[@backingInt(Feature.v1_1)] = .{ .llvm_name = null, .description = "Enable ISA v1.1", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v2_0)] = .{ + result[@backingInt(Feature.v2_0)] = .{ .llvm_name = null, .description = "Enable ISA v2.0", .dependencies = featureSet(&[_]Feature{ diff --git a/lib/std/Target/kvx.zig b/lib/std/Target/kvx.zig index 121ec5799d174f873233bbbb9d729110a224329c..e0cff92996388458b82f572f8905836eda039d6c 100644 --- a/lib/std/Target/kvx.zig +++ b/lib/std/Target/kvx.zig @@ -19,19 +19,19 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.v3_1)] = .{ + result[@backingInt(Feature.v3_1)] = .{ .llvm_name = null, .description = "Enable ISA v3.1", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v3_2)] = .{ + result[@backingInt(Feature.v3_2)] = .{ .llvm_name = null, .description = "Enable ISA v3.2", .dependencies = featureSet(&[_]Feature{ .v3_1, }), }; - result[@intFromEnum(Feature.v4_1)] = .{ + result[@backingInt(Feature.v4_1)] = .{ .llvm_name = null, .description = "Enable ISA v4.1", .dependencies = featureSet(&[_]Feature{ diff --git a/lib/std/Target/loongarch.zig b/lib/std/Target/loongarch.zig index 7158074464942873b3b7e9eb2ecde999bb4c204f..ca86eda817230c373f1913f3938765e1849f8594 100644 --- a/lib/std/Target/loongarch.zig +++ b/lib/std/Target/loongarch.zig @@ -37,115 +37,115 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"32bit")] = .{ + result[@backingInt(Feature.@"32bit")] = .{ .llvm_name = "32bit", .description = "LA32 Basic Integer and Privilege Instruction Set", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"32s")] = .{ + result[@backingInt(Feature.@"32s")] = .{ .llvm_name = "32s", .description = "LA32 Standard Basic Instruction Extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"64bit")] = .{ + result[@backingInt(Feature.@"64bit")] = .{ .llvm_name = "64bit", .description = "LA64 Basic Integer and Privilege Instruction Set", .dependencies = featureSet(&[_]Feature{ .@"32s", }), }; - result[@intFromEnum(Feature.d)] = .{ + result[@backingInt(Feature.d)] = .{ .llvm_name = "d", .description = "'D' (Double-Precision Floating-Point)", .dependencies = featureSet(&[_]Feature{ .f, }), }; - result[@intFromEnum(Feature.div32)] = .{ + result[@backingInt(Feature.div32)] = .{ .llvm_name = "div32", .description = "Assume div.w[u] and mod.w[u] can handle inputs that are not sign-extended", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.f)] = .{ + result[@backingInt(Feature.f)] = .{ .llvm_name = "f", .description = "'F' (Single-Precision Floating-Point)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.frecipe)] = .{ + result[@backingInt(Feature.frecipe)] = .{ .llvm_name = "frecipe", .description = "Support frecipe.{s/d} and frsqrte.{s/d} instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.la_global_with_abs)] = .{ + result[@backingInt(Feature.la_global_with_abs)] = .{ .llvm_name = "la-global-with-abs", .description = "Expand la.global as la.abs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.la_global_with_pcrel)] = .{ + result[@backingInt(Feature.la_global_with_pcrel)] = .{ .llvm_name = "la-global-with-pcrel", .description = "Expand la.global as la.pcrel", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.la_local_with_abs)] = .{ + result[@backingInt(Feature.la_local_with_abs)] = .{ .llvm_name = "la-local-with-abs", .description = "Expand la.local as la.abs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lam_bh)] = .{ + result[@backingInt(Feature.lam_bh)] = .{ .llvm_name = "lam-bh", .description = "Support amswap[_db].{b/h} and amadd[_db].{b/h} instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lamcas)] = .{ + result[@backingInt(Feature.lamcas)] = .{ .llvm_name = "lamcas", .description = "Support amcas[_db].{b/h/w/d}", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lasx)] = .{ + result[@backingInt(Feature.lasx)] = .{ .llvm_name = "lasx", .description = "'LASX' (Loongson Advanced SIMD Extension)", .dependencies = featureSet(&[_]Feature{ .lsx, }), }; - result[@intFromEnum(Feature.lbt)] = .{ + result[@backingInt(Feature.lbt)] = .{ .llvm_name = "lbt", .description = "'LBT' (Loongson Binary Translation Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ld_seq_sa)] = .{ + result[@backingInt(Feature.ld_seq_sa)] = .{ .llvm_name = "ld-seq-sa", .description = "Don't use a same-address load-load barrier (dbar 0x700)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lsx)] = .{ + result[@backingInt(Feature.lsx)] = .{ .llvm_name = "lsx", .description = "'LSX' (Loongson SIMD Extension)", .dependencies = featureSet(&[_]Feature{ .d, }), }; - result[@intFromEnum(Feature.lvz)] = .{ + result[@backingInt(Feature.lvz)] = .{ .llvm_name = "lvz", .description = "'LVZ' (Loongson Virtualization Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_w_inst)] = .{ + result[@backingInt(Feature.prefer_w_inst)] = .{ .llvm_name = "prefer-w-inst", .description = "Prefer instructions with W suffix", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.relax)] = .{ + result[@backingInt(Feature.relax)] = .{ .llvm_name = "relax", .description = "Enable Linker relaxation", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.scq)] = .{ + result[@backingInt(Feature.scq)] = .{ .llvm_name = "scq", .description = "Support sc.q instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ual)] = .{ + result[@backingInt(Feature.ual)] = .{ .llvm_name = "ual", .description = "Allow memory accesses to be unaligned", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/m68k.zig b/lib/std/Target/m68k.zig index 0a65c1a2da6b5e27697d33e072ff485cb9977a39..759f966b51b0acd3936e7848f19ad0a63712e46d 100644 --- a/lib/std/Target/m68k.zig +++ b/lib/std/Target/m68k.zig @@ -39,33 +39,33 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.isa_68000)] = .{ + result[@backingInt(Feature.isa_68000)] = .{ .llvm_name = "isa-68000", .description = "Is M68000 ISA supported", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.isa_68010)] = .{ + result[@backingInt(Feature.isa_68010)] = .{ .llvm_name = "isa-68010", .description = "Is M68010 ISA supported", .dependencies = featureSet(&[_]Feature{ .isa_68000, }), }; - result[@intFromEnum(Feature.isa_68020)] = .{ + result[@backingInt(Feature.isa_68020)] = .{ .llvm_name = "isa-68020", .description = "Is M68020 ISA supported", .dependencies = featureSet(&[_]Feature{ .isa_68010, }), }; - result[@intFromEnum(Feature.isa_68030)] = .{ + result[@backingInt(Feature.isa_68030)] = .{ .llvm_name = "isa-68030", .description = "Is M68030 ISA supported", .dependencies = featureSet(&[_]Feature{ .isa_68020, }), }; - result[@intFromEnum(Feature.isa_68040)] = .{ + result[@backingInt(Feature.isa_68040)] = .{ .llvm_name = "isa-68040", .description = "Is M68040 ISA supported", .dependencies = featureSet(&[_]Feature{ @@ -73,96 +73,96 @@ pub const all_features = blk: { .isa_68882, }), }; - result[@intFromEnum(Feature.isa_68060)] = .{ + result[@backingInt(Feature.isa_68060)] = .{ .llvm_name = "isa-68060", .description = "Is M68060 ISA supported", .dependencies = featureSet(&[_]Feature{ .isa_68040, }), }; - result[@intFromEnum(Feature.isa_68881)] = .{ + result[@backingInt(Feature.isa_68881)] = .{ .llvm_name = "isa-68881", .description = "Is M68881 (FPU) ISA supported", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.isa_68882)] = .{ + result[@backingInt(Feature.isa_68882)] = .{ .llvm_name = "isa-68882", .description = "Is M68882 (FPU) ISA supported", .dependencies = featureSet(&[_]Feature{ .isa_68881, }), }; - result[@intFromEnum(Feature.reserve_a0)] = .{ + result[@backingInt(Feature.reserve_a0)] = .{ .llvm_name = "reserve-a0", .description = "Reserve A0 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_a1)] = .{ + result[@backingInt(Feature.reserve_a1)] = .{ .llvm_name = "reserve-a1", .description = "Reserve A1 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_a2)] = .{ + result[@backingInt(Feature.reserve_a2)] = .{ .llvm_name = "reserve-a2", .description = "Reserve A2 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_a3)] = .{ + result[@backingInt(Feature.reserve_a3)] = .{ .llvm_name = "reserve-a3", .description = "Reserve A3 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_a4)] = .{ + result[@backingInt(Feature.reserve_a4)] = .{ .llvm_name = "reserve-a4", .description = "Reserve A4 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_a5)] = .{ + result[@backingInt(Feature.reserve_a5)] = .{ .llvm_name = "reserve-a5", .description = "Reserve A5 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_a6)] = .{ + result[@backingInt(Feature.reserve_a6)] = .{ .llvm_name = "reserve-a6", .description = "Reserve A6 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d0)] = .{ + result[@backingInt(Feature.reserve_d0)] = .{ .llvm_name = "reserve-d0", .description = "Reserve D0 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d1)] = .{ + result[@backingInt(Feature.reserve_d1)] = .{ .llvm_name = "reserve-d1", .description = "Reserve D1 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d2)] = .{ + result[@backingInt(Feature.reserve_d2)] = .{ .llvm_name = "reserve-d2", .description = "Reserve D2 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d3)] = .{ + result[@backingInt(Feature.reserve_d3)] = .{ .llvm_name = "reserve-d3", .description = "Reserve D3 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d4)] = .{ + result[@backingInt(Feature.reserve_d4)] = .{ .llvm_name = "reserve-d4", .description = "Reserve D4 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d5)] = .{ + result[@backingInt(Feature.reserve_d5)] = .{ .llvm_name = "reserve-d5", .description = "Reserve D5 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d6)] = .{ + result[@backingInt(Feature.reserve_d6)] = .{ .llvm_name = "reserve-d6", .description = "Reserve D6 register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_d7)] = .{ + result[@backingInt(Feature.reserve_d7)] = .{ .llvm_name = "reserve-d7", .description = "Reserve D7 register", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/mips.zig b/lib/std/Target/mips.zig index dad3a54940b45a9e9f2a7f45f8fb52cf34545f63..532fb7871cfb697c3c707b58d1c4ad0bc81e7fc9 100644 --- a/lib/std/Target/mips.zig +++ b/lib/std/Target/mips.zig @@ -73,75 +73,75 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.abs2008)] = .{ + result[@backingInt(Feature.abs2008)] = .{ .llvm_name = "abs2008", .description = "Disable IEEE 754-2008 abs.fmt mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cnmips)] = .{ + result[@backingInt(Feature.cnmips)] = .{ .llvm_name = "cnmips", .description = "Octeon cnMIPS Support", .dependencies = featureSet(&[_]Feature{ .mips64r2, }), }; - result[@intFromEnum(Feature.cnmipsp)] = .{ + result[@backingInt(Feature.cnmipsp)] = .{ .llvm_name = "cnmipsp", .description = "Octeon+ cnMIPS Support", .dependencies = featureSet(&[_]Feature{ .cnmips, }), }; - result[@intFromEnum(Feature.crc)] = .{ + result[@backingInt(Feature.crc)] = .{ .llvm_name = "crc", .description = "Mips R6 CRC ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dsp)] = .{ + result[@backingInt(Feature.dsp)] = .{ .llvm_name = "dsp", .description = "Mips DSP ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dspr2)] = .{ + result[@backingInt(Feature.dspr2)] = .{ .llvm_name = "dspr2", .description = "Mips DSP-R2 ASE", .dependencies = featureSet(&[_]Feature{ .dsp, }), }; - result[@intFromEnum(Feature.dspr3)] = .{ + result[@backingInt(Feature.dspr3)] = .{ .llvm_name = "dspr3", .description = "Mips DSP-R3 ASE", .dependencies = featureSet(&[_]Feature{ .dspr2, }), }; - result[@intFromEnum(Feature.eva)] = .{ + result[@backingInt(Feature.eva)] = .{ .llvm_name = "eva", .description = "Mips EVA ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp64)] = .{ + result[@backingInt(Feature.fp64)] = .{ .llvm_name = "fp64", .description = "Support 64-bit FP registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fpxx)] = .{ + result[@backingInt(Feature.fpxx)] = .{ .llvm_name = "fpxx", .description = "Support for FPXX", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ginv)] = .{ + result[@backingInt(Feature.ginv)] = .{ .llvm_name = "ginv", .description = "Mips Global Invalidate ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gp64)] = .{ + result[@backingInt(Feature.gp64)] = .{ .llvm_name = "gp64", .description = "General Purpose Registers are 64-bit wide", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.i6400)] = .{ + result[@backingInt(Feature.i6400)] = .{ .llvm_name = "i6400", .description = "MIPS I6400 Processor", .dependencies = featureSet(&[_]Feature{ @@ -149,7 +149,7 @@ pub const all_features = blk: { .msa, }), }; - result[@intFromEnum(Feature.i6500)] = .{ + result[@backingInt(Feature.i6500)] = .{ .llvm_name = "i6500", .description = "MIPS I6500 Processor", .dependencies = featureSet(&[_]Feature{ @@ -157,34 +157,34 @@ pub const all_features = blk: { .msa, }), }; - result[@intFromEnum(Feature.long_calls)] = .{ + result[@backingInt(Feature.long_calls)] = .{ .llvm_name = "long-calls", .description = "Disable use of the jal instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.micromips)] = .{ + result[@backingInt(Feature.micromips)] = .{ .llvm_name = "micromips", .description = "microMips mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips1)] = .{ + result[@backingInt(Feature.mips1)] = .{ .llvm_name = "mips1", .description = "Mips I ISA Support [highly experimental]", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips16)] = .{ + result[@backingInt(Feature.mips16)] = .{ .llvm_name = "mips16", .description = "Mips16 mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips2)] = .{ + result[@backingInt(Feature.mips2)] = .{ .llvm_name = "mips2", .description = "Mips II ISA Support [highly experimental]", .dependencies = featureSet(&[_]Feature{ .mips1, }), }; - result[@intFromEnum(Feature.mips3)] = .{ + result[@backingInt(Feature.mips3)] = .{ .llvm_name = "mips3", .description = "MIPS III ISA Support [highly experimental]", .dependencies = featureSet(&[_]Feature{ @@ -195,7 +195,7 @@ pub const all_features = blk: { .mips3_32r2, }), }; - result[@intFromEnum(Feature.mips32)] = .{ + result[@backingInt(Feature.mips32)] = .{ .llvm_name = "mips32", .description = "Mips32 ISA Support", .dependencies = featureSet(&[_]Feature{ @@ -204,7 +204,7 @@ pub const all_features = blk: { .mips4_32, }), }; - result[@intFromEnum(Feature.mips32r2)] = .{ + result[@backingInt(Feature.mips32r2)] = .{ .llvm_name = "mips32r2", .description = "Mips32r2 ISA Support", .dependencies = featureSet(&[_]Feature{ @@ -214,21 +214,21 @@ pub const all_features = blk: { .mips5_32r2, }), }; - result[@intFromEnum(Feature.mips32r3)] = .{ + result[@backingInt(Feature.mips32r3)] = .{ .llvm_name = "mips32r3", .description = "Mips32r3 ISA Support", .dependencies = featureSet(&[_]Feature{ .mips32r2, }), }; - result[@intFromEnum(Feature.mips32r5)] = .{ + result[@backingInt(Feature.mips32r5)] = .{ .llvm_name = "mips32r5", .description = "Mips32r5 ISA Support", .dependencies = featureSet(&[_]Feature{ .mips32r3, }), }; - result[@intFromEnum(Feature.mips32r6)] = .{ + result[@backingInt(Feature.mips32r6)] = .{ .llvm_name = "mips32r6", .description = "Mips32r6 ISA Support [experimental]", .dependencies = featureSet(&[_]Feature{ @@ -238,22 +238,22 @@ pub const all_features = blk: { .nan2008, }), }; - result[@intFromEnum(Feature.mips3_32)] = .{ + result[@backingInt(Feature.mips3_32)] = .{ .llvm_name = "mips3_32", .description = "Subset of MIPS-III that is also in MIPS32 [highly experimental]", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips3_32r2)] = .{ + result[@backingInt(Feature.mips3_32r2)] = .{ .llvm_name = "mips3_32r2", .description = "Subset of MIPS-III that is also in MIPS32r2 [highly experimental]", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips3d)] = .{ + result[@backingInt(Feature.mips3d)] = .{ .llvm_name = "mips3d", .description = "Mips 3D ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips4)] = .{ + result[@backingInt(Feature.mips4)] = .{ .llvm_name = "mips4", .description = "MIPS IV ISA Support", .dependencies = featureSet(&[_]Feature{ @@ -262,17 +262,17 @@ pub const all_features = blk: { .mips4_32r2, }), }; - result[@intFromEnum(Feature.mips4_32)] = .{ + result[@backingInt(Feature.mips4_32)] = .{ .llvm_name = "mips4_32", .description = "Subset of MIPS-IV that is also in MIPS32 [highly experimental]", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips4_32r2)] = .{ + result[@backingInt(Feature.mips4_32r2)] = .{ .llvm_name = "mips4_32r2", .description = "Subset of MIPS-IV that is also in MIPS32r2 [highly experimental]", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips5)] = .{ + result[@backingInt(Feature.mips5)] = .{ .llvm_name = "mips5", .description = "MIPS V ISA Support [highly experimental]", .dependencies = featureSet(&[_]Feature{ @@ -280,12 +280,12 @@ pub const all_features = blk: { .mips5_32r2, }), }; - result[@intFromEnum(Feature.mips5_32r2)] = .{ + result[@backingInt(Feature.mips5_32r2)] = .{ .llvm_name = "mips5_32r2", .description = "Subset of MIPS-V that is also in MIPS32r2 [highly experimental]", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mips64)] = .{ + result[@backingInt(Feature.mips64)] = .{ .llvm_name = "mips64", .description = "Mips64 ISA Support", .dependencies = featureSet(&[_]Feature{ @@ -293,7 +293,7 @@ pub const all_features = blk: { .mips5, }), }; - result[@intFromEnum(Feature.mips64r2)] = .{ + result[@backingInt(Feature.mips64r2)] = .{ .llvm_name = "mips64r2", .description = "Mips64r2 ISA Support", .dependencies = featureSet(&[_]Feature{ @@ -301,7 +301,7 @@ pub const all_features = blk: { .mips64, }), }; - result[@intFromEnum(Feature.mips64r3)] = .{ + result[@backingInt(Feature.mips64r3)] = .{ .llvm_name = "mips64r3", .description = "Mips64r3 ISA Support", .dependencies = featureSet(&[_]Feature{ @@ -309,7 +309,7 @@ pub const all_features = blk: { .mips64r2, }), }; - result[@intFromEnum(Feature.mips64r5)] = .{ + result[@backingInt(Feature.mips64r5)] = .{ .llvm_name = "mips64r5", .description = "Mips64r5 ISA Support", .dependencies = featureSet(&[_]Feature{ @@ -317,7 +317,7 @@ pub const all_features = blk: { .mips64r3, }), }; - result[@intFromEnum(Feature.mips64r6)] = .{ + result[@backingInt(Feature.mips64r6)] = .{ .llvm_name = "mips64r6", .description = "Mips64r6 ISA Support [experimental]", .dependencies = featureSet(&[_]Feature{ @@ -325,99 +325,99 @@ pub const all_features = blk: { .mips64r5, }), }; - result[@intFromEnum(Feature.msa)] = .{ + result[@backingInt(Feature.msa)] = .{ .llvm_name = "msa", .description = "Mips MSA ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mt)] = .{ + result[@backingInt(Feature.mt)] = .{ .llvm_name = "mt", .description = "Mips MT ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nan2008)] = .{ + result[@backingInt(Feature.nan2008)] = .{ .llvm_name = "nan2008", .description = "IEEE 754-2008 NaN encoding", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.noabicalls)] = .{ + result[@backingInt(Feature.noabicalls)] = .{ .llvm_name = "noabicalls", .description = "Disable SVR4-style position-independent code", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nomadd4)] = .{ + result[@backingInt(Feature.nomadd4)] = .{ .llvm_name = "nomadd4", .description = "Disable 4-operand madd.fmt and related instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nooddspreg)] = .{ + result[@backingInt(Feature.nooddspreg)] = .{ .llvm_name = "nooddspreg", .description = "Disable odd numbered single-precision registers", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.notraps)] = .{ + result[@backingInt(Feature.notraps)] = .{ .llvm_name = null, .description = "Disable trap instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.p5600)] = .{ + result[@backingInt(Feature.p5600)] = .{ .llvm_name = "p5600", .description = "The P5600 Processor", .dependencies = featureSet(&[_]Feature{ .mips32r5, }), }; - result[@intFromEnum(Feature.ptr64)] = .{ + result[@backingInt(Feature.ptr64)] = .{ .llvm_name = "ptr64", .description = "Pointers are 64-bit wide", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.single_float)] = .{ + result[@backingInt(Feature.single_float)] = .{ .llvm_name = "single-float", .description = "Only supports single precision float", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.soft_float)] = .{ + result[@backingInt(Feature.soft_float)] = .{ .llvm_name = "soft-float", .description = "Does not support floating point instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.strict_align)] = .{ + result[@backingInt(Feature.strict_align)] = .{ .llvm_name = "strict-align", .description = "Disable unaligned load store for r6", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sym32)] = .{ + result[@backingInt(Feature.sym32)] = .{ .llvm_name = "sym32", .description = "Symbols are 32 bit on Mips64", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_compact_branches)] = .{ + result[@backingInt(Feature.use_compact_branches)] = .{ .llvm_name = "use-compact-branches", .description = "Use compact branch instructions for MIPS32R6/MIPS64R6", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_indirect_jump_hazard)] = .{ + result[@backingInt(Feature.use_indirect_jump_hazard)] = .{ .llvm_name = "use-indirect-jump-hazard", .description = "Use indirect jump guards to prevent certain speculation based attacks", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_tcc_in_div)] = .{ + result[@backingInt(Feature.use_tcc_in_div)] = .{ .llvm_name = "use-tcc-in-div", .description = "Force the assembler to use trapping", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vfpu)] = .{ + result[@backingInt(Feature.vfpu)] = .{ .llvm_name = "vfpu", .description = "Enable vector FPU instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.virt)] = .{ + result[@backingInt(Feature.virt)] = .{ .llvm_name = "virt", .description = "Mips Virtualization ASE", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xgot)] = .{ + result[@backingInt(Feature.xgot)] = .{ .llvm_name = "xgot", .description = "Assume 32-bit GOT", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/msp430.zig b/lib/std/Target/msp430.zig index 4e4bc288c8cde280a0407f887f576b975fb428c0..d2999c13c87ee02befe26587d86c2297800c6209 100644 --- a/lib/std/Target/msp430.zig +++ b/lib/std/Target/msp430.zig @@ -20,22 +20,22 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.ext)] = .{ + result[@backingInt(Feature.ext)] = .{ .llvm_name = "ext", .description = "Enable MSP430-X extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hwmult16)] = .{ + result[@backingInt(Feature.hwmult16)] = .{ .llvm_name = "hwmult16", .description = "Enable 16-bit hardware multiplier", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hwmult32)] = .{ + result[@backingInt(Feature.hwmult32)] = .{ .llvm_name = "hwmult32", .description = "Enable 32-bit hardware multiplier", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hwmultf5)] = .{ + result[@backingInt(Feature.hwmultf5)] = .{ .llvm_name = "hwmultf5", .description = "Enable F5 series hardware multiplier", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/nvptx.zig b/lib/std/Target/nvptx.zig index 8ba60697e377101c60b3299cfd6f12d106f02bb6..2bd9cda037c90aeb3542d92c1883fba5da333337 100644 --- a/lib/std/Target/nvptx.zig +++ b/lib/std/Target/nvptx.zig @@ -87,357 +87,357 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.ptx32)] = .{ + result[@backingInt(Feature.ptx32)] = .{ .llvm_name = "ptx32", .description = "Use PTX version 32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx40)] = .{ + result[@backingInt(Feature.ptx40)] = .{ .llvm_name = "ptx40", .description = "Use PTX version 40", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx41)] = .{ + result[@backingInt(Feature.ptx41)] = .{ .llvm_name = "ptx41", .description = "Use PTX version 41", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx42)] = .{ + result[@backingInt(Feature.ptx42)] = .{ .llvm_name = "ptx42", .description = "Use PTX version 42", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx43)] = .{ + result[@backingInt(Feature.ptx43)] = .{ .llvm_name = "ptx43", .description = "Use PTX version 43", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx50)] = .{ + result[@backingInt(Feature.ptx50)] = .{ .llvm_name = "ptx50", .description = "Use PTX version 50", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx60)] = .{ + result[@backingInt(Feature.ptx60)] = .{ .llvm_name = "ptx60", .description = "Use PTX version 60", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx61)] = .{ + result[@backingInt(Feature.ptx61)] = .{ .llvm_name = "ptx61", .description = "Use PTX version 61", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx62)] = .{ + result[@backingInt(Feature.ptx62)] = .{ .llvm_name = "ptx62", .description = "Use PTX version 62", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx63)] = .{ + result[@backingInt(Feature.ptx63)] = .{ .llvm_name = "ptx63", .description = "Use PTX version 63", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx64)] = .{ + result[@backingInt(Feature.ptx64)] = .{ .llvm_name = "ptx64", .description = "Use PTX version 64", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx65)] = .{ + result[@backingInt(Feature.ptx65)] = .{ .llvm_name = "ptx65", .description = "Use PTX version 65", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx70)] = .{ + result[@backingInt(Feature.ptx70)] = .{ .llvm_name = "ptx70", .description = "Use PTX version 70", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx71)] = .{ + result[@backingInt(Feature.ptx71)] = .{ .llvm_name = "ptx71", .description = "Use PTX version 71", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx72)] = .{ + result[@backingInt(Feature.ptx72)] = .{ .llvm_name = "ptx72", .description = "Use PTX version 72", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx73)] = .{ + result[@backingInt(Feature.ptx73)] = .{ .llvm_name = "ptx73", .description = "Use PTX version 73", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx74)] = .{ + result[@backingInt(Feature.ptx74)] = .{ .llvm_name = "ptx74", .description = "Use PTX version 74", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx75)] = .{ + result[@backingInt(Feature.ptx75)] = .{ .llvm_name = "ptx75", .description = "Use PTX version 75", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx76)] = .{ + result[@backingInt(Feature.ptx76)] = .{ .llvm_name = "ptx76", .description = "Use PTX version 76", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx77)] = .{ + result[@backingInt(Feature.ptx77)] = .{ .llvm_name = "ptx77", .description = "Use PTX version 77", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx78)] = .{ + result[@backingInt(Feature.ptx78)] = .{ .llvm_name = "ptx78", .description = "Use PTX version 78", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx80)] = .{ + result[@backingInt(Feature.ptx80)] = .{ .llvm_name = "ptx80", .description = "Use PTX version 80", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx81)] = .{ + result[@backingInt(Feature.ptx81)] = .{ .llvm_name = "ptx81", .description = "Use PTX version 81", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx82)] = .{ + result[@backingInt(Feature.ptx82)] = .{ .llvm_name = "ptx82", .description = "Use PTX version 82", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx83)] = .{ + result[@backingInt(Feature.ptx83)] = .{ .llvm_name = "ptx83", .description = "Use PTX version 83", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx84)] = .{ + result[@backingInt(Feature.ptx84)] = .{ .llvm_name = "ptx84", .description = "Use PTX version 84", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx85)] = .{ + result[@backingInt(Feature.ptx85)] = .{ .llvm_name = "ptx85", .description = "Use PTX version 85", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx86)] = .{ + result[@backingInt(Feature.ptx86)] = .{ .llvm_name = "ptx86", .description = "Use PTX version 86", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx87)] = .{ + result[@backingInt(Feature.ptx87)] = .{ .llvm_name = "ptx87", .description = "Use PTX version 87", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx88)] = .{ + result[@backingInt(Feature.ptx88)] = .{ .llvm_name = "ptx88", .description = "Use PTX version 88", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptx90)] = .{ + result[@backingInt(Feature.ptx90)] = .{ .llvm_name = "ptx90", .description = "Use PTX version 90", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_100)] = .{ + result[@backingInt(Feature.sm_100)] = .{ .llvm_name = "sm_100", .description = "Target SM 100", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_100a)] = .{ + result[@backingInt(Feature.sm_100a)] = .{ .llvm_name = "sm_100a", .description = "Target SM 100a", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_100f)] = .{ + result[@backingInt(Feature.sm_100f)] = .{ .llvm_name = "sm_100f", .description = "Target SM 100f", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_101)] = .{ + result[@backingInt(Feature.sm_101)] = .{ .llvm_name = "sm_101", .description = "Target SM 101", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_101a)] = .{ + result[@backingInt(Feature.sm_101a)] = .{ .llvm_name = "sm_101a", .description = "Target SM 101a", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_101f)] = .{ + result[@backingInt(Feature.sm_101f)] = .{ .llvm_name = "sm_101f", .description = "Target SM 101f", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_103)] = .{ + result[@backingInt(Feature.sm_103)] = .{ .llvm_name = "sm_103", .description = "Target SM 103", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_103a)] = .{ + result[@backingInt(Feature.sm_103a)] = .{ .llvm_name = "sm_103a", .description = "Target SM 103a", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_103f)] = .{ + result[@backingInt(Feature.sm_103f)] = .{ .llvm_name = "sm_103f", .description = "Target SM 103f", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_110)] = .{ + result[@backingInt(Feature.sm_110)] = .{ .llvm_name = "sm_110", .description = "Target SM 110", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_110a)] = .{ + result[@backingInt(Feature.sm_110a)] = .{ .llvm_name = "sm_110a", .description = "Target SM 110a", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_110f)] = .{ + result[@backingInt(Feature.sm_110f)] = .{ .llvm_name = "sm_110f", .description = "Target SM 110f", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_120)] = .{ + result[@backingInt(Feature.sm_120)] = .{ .llvm_name = "sm_120", .description = "Target SM 120", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_120a)] = .{ + result[@backingInt(Feature.sm_120a)] = .{ .llvm_name = "sm_120a", .description = "Target SM 120a", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_120f)] = .{ + result[@backingInt(Feature.sm_120f)] = .{ .llvm_name = "sm_120f", .description = "Target SM 120f", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_121)] = .{ + result[@backingInt(Feature.sm_121)] = .{ .llvm_name = "sm_121", .description = "Target SM 121", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_121a)] = .{ + result[@backingInt(Feature.sm_121a)] = .{ .llvm_name = "sm_121a", .description = "Target SM 121a", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_121f)] = .{ + result[@backingInt(Feature.sm_121f)] = .{ .llvm_name = "sm_121f", .description = "Target SM 121f", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_20)] = .{ + result[@backingInt(Feature.sm_20)] = .{ .llvm_name = "sm_20", .description = "Target SM 20", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_21)] = .{ + result[@backingInt(Feature.sm_21)] = .{ .llvm_name = "sm_21", .description = "Target SM 21", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_30)] = .{ + result[@backingInt(Feature.sm_30)] = .{ .llvm_name = "sm_30", .description = "Target SM 30", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_32)] = .{ + result[@backingInt(Feature.sm_32)] = .{ .llvm_name = "sm_32", .description = "Target SM 32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_35)] = .{ + result[@backingInt(Feature.sm_35)] = .{ .llvm_name = "sm_35", .description = "Target SM 35", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_37)] = .{ + result[@backingInt(Feature.sm_37)] = .{ .llvm_name = "sm_37", .description = "Target SM 37", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_50)] = .{ + result[@backingInt(Feature.sm_50)] = .{ .llvm_name = "sm_50", .description = "Target SM 50", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_52)] = .{ + result[@backingInt(Feature.sm_52)] = .{ .llvm_name = "sm_52", .description = "Target SM 52", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_53)] = .{ + result[@backingInt(Feature.sm_53)] = .{ .llvm_name = "sm_53", .description = "Target SM 53", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_60)] = .{ + result[@backingInt(Feature.sm_60)] = .{ .llvm_name = "sm_60", .description = "Target SM 60", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_61)] = .{ + result[@backingInt(Feature.sm_61)] = .{ .llvm_name = "sm_61", .description = "Target SM 61", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_62)] = .{ + result[@backingInt(Feature.sm_62)] = .{ .llvm_name = "sm_62", .description = "Target SM 62", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_70)] = .{ + result[@backingInt(Feature.sm_70)] = .{ .llvm_name = "sm_70", .description = "Target SM 70", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_72)] = .{ + result[@backingInt(Feature.sm_72)] = .{ .llvm_name = "sm_72", .description = "Target SM 72", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_75)] = .{ + result[@backingInt(Feature.sm_75)] = .{ .llvm_name = "sm_75", .description = "Target SM 75", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_80)] = .{ + result[@backingInt(Feature.sm_80)] = .{ .llvm_name = "sm_80", .description = "Target SM 80", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_86)] = .{ + result[@backingInt(Feature.sm_86)] = .{ .llvm_name = "sm_86", .description = "Target SM 86", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_87)] = .{ + result[@backingInt(Feature.sm_87)] = .{ .llvm_name = "sm_87", .description = "Target SM 87", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_88)] = .{ + result[@backingInt(Feature.sm_88)] = .{ .llvm_name = "sm_88", .description = "Target SM 88", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_89)] = .{ + result[@backingInt(Feature.sm_89)] = .{ .llvm_name = "sm_89", .description = "Target SM 89", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_90)] = .{ + result[@backingInt(Feature.sm_90)] = .{ .llvm_name = "sm_90", .description = "Target SM 90", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm_90a)] = .{ + result[@backingInt(Feature.sm_90a)] = .{ .llvm_name = "sm_90a", .description = "Target SM 90a", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/powerpc.zig b/lib/std/Target/powerpc.zig index 897eb69a94fd2a3d040c568f5362521c758bdd83..14c18791ffd52f94f3c768db72ebf4de13644263 100644 --- a/lib/std/Target/powerpc.zig +++ b/lib/std/Target/powerpc.zig @@ -96,331 +96,331 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"64bit")] = .{ + result[@backingInt(Feature.@"64bit")] = .{ .llvm_name = "64bit", .description = "Enable 64-bit mode", .dependencies = featureSet(&[_]Feature{ .@"64bit_support", }), }; - result[@intFromEnum(Feature.@"64bit_support")] = .{ + result[@backingInt(Feature.@"64bit_support")] = .{ .llvm_name = "64bit-support", .description = "Supports 64-bit instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"64bitregs")] = .{ + result[@backingInt(Feature.@"64bitregs")] = .{ .llvm_name = "64bitregs", .description = "Enable 64-bit registers usage for ppc32 [beta]", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.allow_unaligned_fp_access)] = .{ + result[@backingInt(Feature.allow_unaligned_fp_access)] = .{ .llvm_name = "allow-unaligned-fp-access", .description = "CPU does not trap on unaligned FP access", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.altivec)] = .{ + result[@backingInt(Feature.altivec)] = .{ .llvm_name = "altivec", .description = "Enable Altivec instructions", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.booke)] = .{ + result[@backingInt(Feature.booke)] = .{ .llvm_name = "booke", .description = "Enable Book E instructions", .dependencies = featureSet(&[_]Feature{ .icbt, }), }; - result[@intFromEnum(Feature.bpermd)] = .{ + result[@backingInt(Feature.bpermd)] = .{ .llvm_name = "bpermd", .description = "Enable the bpermd instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cmpb)] = .{ + result[@backingInt(Feature.cmpb)] = .{ .llvm_name = "cmpb", .description = "Enable the cmpb instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.crbits)] = .{ + result[@backingInt(Feature.crbits)] = .{ .llvm_name = "crbits", .description = "Use condition-register bits individually", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.crypto)] = .{ + result[@backingInt(Feature.crypto)] = .{ .llvm_name = "crypto", .description = "Enable POWER8 Crypto instructions", .dependencies = featureSet(&[_]Feature{ .power8_altivec, }), }; - result[@intFromEnum(Feature.direct_move)] = .{ + result[@backingInt(Feature.direct_move)] = .{ .llvm_name = "direct-move", .description = "Enable Power8 direct move instructions", .dependencies = featureSet(&[_]Feature{ .vsx, }), }; - result[@intFromEnum(Feature.e500)] = .{ + result[@backingInt(Feature.e500)] = .{ .llvm_name = "e500", .description = "Enable E500/E500mc instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.efpu2)] = .{ + result[@backingInt(Feature.efpu2)] = .{ .llvm_name = "efpu2", .description = "Enable Embedded Floating-Point APU 2 instructions", .dependencies = featureSet(&[_]Feature{ .spe, }), }; - result[@intFromEnum(Feature.extdiv)] = .{ + result[@backingInt(Feature.extdiv)] = .{ .llvm_name = "extdiv", .description = "Enable extended divide instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_MFLR)] = .{ + result[@backingInt(Feature.fast_MFLR)] = .{ .llvm_name = "fast-MFLR", .description = "MFLR is a fast instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fcpsgn)] = .{ + result[@backingInt(Feature.fcpsgn)] = .{ .llvm_name = "fcpsgn", .description = "Enable the fcpsgn instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.float128)] = .{ + result[@backingInt(Feature.float128)] = .{ .llvm_name = "float128", .description = "Enable the __float128 data type for IEEE-754R Binary128.", .dependencies = featureSet(&[_]Feature{ .vsx, }), }; - result[@intFromEnum(Feature.fpcvt)] = .{ + result[@backingInt(Feature.fpcvt)] = .{ .llvm_name = "fpcvt", .description = "Enable fc[ft]* (unsigned and single-precision) and lfiwzx instructions", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.fprnd)] = .{ + result[@backingInt(Feature.fprnd)] = .{ .llvm_name = "fprnd", .description = "Enable the fri[mnpz] instructions", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.fpu)] = .{ + result[@backingInt(Feature.fpu)] = .{ .llvm_name = "fpu", .description = "Enable classic FPU instructions", .dependencies = featureSet(&[_]Feature{ .hard_float, }), }; - result[@intFromEnum(Feature.fre)] = .{ + result[@backingInt(Feature.fre)] = .{ .llvm_name = "fre", .description = "Enable the fre instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.fres)] = .{ + result[@backingInt(Feature.fres)] = .{ .llvm_name = "fres", .description = "Enable the fres instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.frsqrte)] = .{ + result[@backingInt(Feature.frsqrte)] = .{ .llvm_name = "frsqrte", .description = "Enable the frsqrte instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.frsqrtes)] = .{ + result[@backingInt(Feature.frsqrtes)] = .{ .llvm_name = "frsqrtes", .description = "Enable the frsqrtes instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.fsqrt)] = .{ + result[@backingInt(Feature.fsqrt)] = .{ .llvm_name = "fsqrt", .description = "Enable the fsqrt instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.fuse_add_logical)] = .{ + result[@backingInt(Feature.fuse_add_logical)] = .{ .llvm_name = "fuse-add-logical", .description = "Target supports Add with Logical Operations fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_addi_load)] = .{ + result[@backingInt(Feature.fuse_addi_load)] = .{ .llvm_name = "fuse-addi-load", .description = "Power8 Addi-Load fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_addis_load)] = .{ + result[@backingInt(Feature.fuse_addis_load)] = .{ .llvm_name = "fuse-addis-load", .description = "Power8 Addis-Load fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_arith_add)] = .{ + result[@backingInt(Feature.fuse_arith_add)] = .{ .llvm_name = "fuse-arith-add", .description = "Target supports Arithmetic Operations with Add fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_back2back)] = .{ + result[@backingInt(Feature.fuse_back2back)] = .{ .llvm_name = "fuse-back2back", .description = "Target supports general back to back fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_cmp)] = .{ + result[@backingInt(Feature.fuse_cmp)] = .{ .llvm_name = "fuse-cmp", .description = "Target supports Comparison Operations fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_logical)] = .{ + result[@backingInt(Feature.fuse_logical)] = .{ .llvm_name = "fuse-logical", .description = "Target supports Logical Operations fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_logical_add)] = .{ + result[@backingInt(Feature.fuse_logical_add)] = .{ .llvm_name = "fuse-logical-add", .description = "Target supports Logical with Add Operations fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_sha3)] = .{ + result[@backingInt(Feature.fuse_sha3)] = .{ .llvm_name = "fuse-sha3", .description = "Target supports SHA3 assist fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_store)] = .{ + result[@backingInt(Feature.fuse_store)] = .{ .llvm_name = "fuse-store", .description = "Target supports store clustering", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_wideimm)] = .{ + result[@backingInt(Feature.fuse_wideimm)] = .{ .llvm_name = "fuse-wideimm", .description = "Target supports Wide-Immediate fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fuse_zeromove)] = .{ + result[@backingInt(Feature.fuse_zeromove)] = .{ .llvm_name = "fuse-zeromove", .description = "Target supports move to SPR with branch fusion", .dependencies = featureSet(&[_]Feature{ .fusion, }), }; - result[@intFromEnum(Feature.fusion)] = .{ + result[@backingInt(Feature.fusion)] = .{ .llvm_name = "fusion", .description = "Target supports instruction fusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hard_float)] = .{ + result[@backingInt(Feature.hard_float)] = .{ .llvm_name = "hard-float", .description = "Enable floating-point instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.htm)] = .{ + result[@backingInt(Feature.htm)] = .{ .llvm_name = "htm", .description = "Enable Hardware Transactional Memory instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.icbt)] = .{ + result[@backingInt(Feature.icbt)] = .{ .llvm_name = "icbt", .description = "Enable icbt instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.invariant_function_descriptors)] = .{ + result[@backingInt(Feature.invariant_function_descriptors)] = .{ .llvm_name = "invariant-function-descriptors", .description = "Assume function descriptors are invariant", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.isa_future_instructions)] = .{ + result[@backingInt(Feature.isa_future_instructions)] = .{ .llvm_name = "isa-future-instructions", .description = "Enable instructions for Future ISA.", .dependencies = featureSet(&[_]Feature{ .isa_v31_instructions, }), }; - result[@intFromEnum(Feature.isa_v206_instructions)] = .{ + result[@backingInt(Feature.isa_v206_instructions)] = .{ .llvm_name = "isa-v206-instructions", .description = "Enable instructions in ISA 2.06.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.isa_v207_instructions)] = .{ + result[@backingInt(Feature.isa_v207_instructions)] = .{ .llvm_name = "isa-v207-instructions", .description = "Enable instructions in ISA 2.07.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.isa_v30_instructions)] = .{ + result[@backingInt(Feature.isa_v30_instructions)] = .{ .llvm_name = "isa-v30-instructions", .description = "Enable instructions in ISA 3.0.", .dependencies = featureSet(&[_]Feature{ .isa_v207_instructions, }), }; - result[@intFromEnum(Feature.isa_v31_instructions)] = .{ + result[@backingInt(Feature.isa_v31_instructions)] = .{ .llvm_name = "isa-v31-instructions", .description = "Enable instructions in ISA 3.1.", .dependencies = featureSet(&[_]Feature{ .isa_v30_instructions, }), }; - result[@intFromEnum(Feature.isel)] = .{ + result[@backingInt(Feature.isel)] = .{ .llvm_name = "isel", .description = "Enable the isel instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ldbrx)] = .{ + result[@backingInt(Feature.ldbrx)] = .{ .llvm_name = "ldbrx", .description = "Enable the ldbrx instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lfiwax)] = .{ + result[@backingInt(Feature.lfiwax)] = .{ .llvm_name = "lfiwax", .description = "Enable the lfiwax instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.longcall)] = .{ + result[@backingInt(Feature.longcall)] = .{ .llvm_name = "longcall", .description = "Always use indirect calls", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mfocrf)] = .{ + result[@backingInt(Feature.mfocrf)] = .{ .llvm_name = "mfocrf", .description = "Enable the MFOCRF instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mma)] = .{ + result[@backingInt(Feature.mma)] = .{ .llvm_name = "mma", .description = "Enable MMA instructions", .dependencies = featureSet(&[_]Feature{ @@ -429,38 +429,38 @@ pub const all_features = blk: { .power9_altivec, }), }; - result[@intFromEnum(Feature.msync)] = .{ + result[@backingInt(Feature.msync)] = .{ .llvm_name = "msync", .description = "Has only the msync instruction instead of sync", .dependencies = featureSet(&[_]Feature{ .booke, }), }; - result[@intFromEnum(Feature.paired_vector_memops)] = .{ + result[@backingInt(Feature.paired_vector_memops)] = .{ .llvm_name = "paired-vector-memops", .description = "32Byte load and store instructions", .dependencies = featureSet(&[_]Feature{ .isa_v30_instructions, }), }; - result[@intFromEnum(Feature.partword_atomics)] = .{ + result[@backingInt(Feature.partword_atomics)] = .{ .llvm_name = "partword-atomics", .description = "Enable l[bh]arx and st[bh]cx.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pcrelative_memops)] = .{ + result[@backingInt(Feature.pcrelative_memops)] = .{ .llvm_name = "pcrelative-memops", .description = "Enable PC relative Memory Ops", .dependencies = featureSet(&[_]Feature{ .prefix_instrs, }), }; - result[@intFromEnum(Feature.popcntd)] = .{ + result[@backingInt(Feature.popcntd)] = .{ .llvm_name = "popcntd", .description = "Enable the popcnt[dw] instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.power10_vector)] = .{ + result[@backingInt(Feature.power10_vector)] = .{ .llvm_name = "power10-vector", .description = "Enable POWER10 vector instructions", .dependencies = featureSet(&[_]Feature{ @@ -468,14 +468,14 @@ pub const all_features = blk: { .power9_vector, }), }; - result[@intFromEnum(Feature.power8_altivec)] = .{ + result[@backingInt(Feature.power8_altivec)] = .{ .llvm_name = "power8-altivec", .description = "Enable POWER8 Altivec instructions", .dependencies = featureSet(&[_]Feature{ .altivec, }), }; - result[@intFromEnum(Feature.power8_vector)] = .{ + result[@backingInt(Feature.power8_vector)] = .{ .llvm_name = "power8-vector", .description = "Enable POWER8 vector instructions", .dependencies = featureSet(&[_]Feature{ @@ -483,7 +483,7 @@ pub const all_features = blk: { .vsx, }), }; - result[@intFromEnum(Feature.power9_altivec)] = .{ + result[@backingInt(Feature.power9_altivec)] = .{ .llvm_name = "power9-altivec", .description = "Enable POWER9 Altivec instructions", .dependencies = featureSet(&[_]Feature{ @@ -491,7 +491,7 @@ pub const all_features = blk: { .power8_altivec, }), }; - result[@intFromEnum(Feature.power9_vector)] = .{ + result[@backingInt(Feature.power9_vector)] = .{ .llvm_name = "power9-vector", .description = "Enable POWER9 vector instructions", .dependencies = featureSet(&[_]Feature{ @@ -499,93 +499,93 @@ pub const all_features = blk: { .power9_altivec, }), }; - result[@intFromEnum(Feature.ppc4xx)] = .{ + result[@backingInt(Feature.ppc4xx)] = .{ .llvm_name = "ppc4xx", .description = "Enable PPC 4xx instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ppc6xx)] = .{ + result[@backingInt(Feature.ppc6xx)] = .{ .llvm_name = "ppc6xx", .description = "Enable PPC 6xx instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ppc_postra_sched)] = .{ + result[@backingInt(Feature.ppc_postra_sched)] = .{ .llvm_name = "ppc-postra-sched", .description = "Use PowerPC post-RA scheduling strategy", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ppc_prera_sched)] = .{ + result[@backingInt(Feature.ppc_prera_sched)] = .{ .llvm_name = "ppc-prera-sched", .description = "Use PowerPC pre-RA scheduling strategy", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.predictable_select_expensive)] = .{ + result[@backingInt(Feature.predictable_select_expensive)] = .{ .llvm_name = "predictable-select-expensive", .description = "Prefer likely predicted branches over selects", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefix_instrs)] = .{ + result[@backingInt(Feature.prefix_instrs)] = .{ .llvm_name = "prefix-instrs", .description = "Enable prefixed instructions", .dependencies = featureSet(&[_]Feature{ .isa_v31_instructions, }), }; - result[@intFromEnum(Feature.privileged)] = .{ + result[@backingInt(Feature.privileged)] = .{ .llvm_name = "privileged", .description = "Add privileged instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.quadword_atomics)] = .{ + result[@backingInt(Feature.quadword_atomics)] = .{ .llvm_name = "quadword-atomics", .description = "Enable lqarx and stqcx.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.recipprec)] = .{ + result[@backingInt(Feature.recipprec)] = .{ .llvm_name = "recipprec", .description = "Assume higher precision reciprocal estimates", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rop_protect)] = .{ + result[@backingInt(Feature.rop_protect)] = .{ .llvm_name = "rop-protect", .description = "Add ROP protect", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.secure_plt)] = .{ + result[@backingInt(Feature.secure_plt)] = .{ .llvm_name = "secure-plt", .description = "Enable secure plt mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_popcntd)] = .{ + result[@backingInt(Feature.slow_popcntd)] = .{ .llvm_name = "slow-popcntd", .description = "Has slow popcnt[dw] instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.spe)] = .{ + result[@backingInt(Feature.spe)] = .{ .llvm_name = "spe", .description = "Enable SPE instructions", .dependencies = featureSet(&[_]Feature{ .hard_float, }), }; - result[@intFromEnum(Feature.stfiwx)] = .{ + result[@backingInt(Feature.stfiwx)] = .{ .llvm_name = "stfiwx", .description = "Enable the stfiwx instruction", .dependencies = featureSet(&[_]Feature{ .fpu, }), }; - result[@intFromEnum(Feature.two_const_nr)] = .{ + result[@backingInt(Feature.two_const_nr)] = .{ .llvm_name = "two-const-nr", .description = "Requires two constant Newton-Raphson computation", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vectors_use_two_units)] = .{ + result[@backingInt(Feature.vectors_use_two_units)] = .{ .llvm_name = "vectors-use-two-units", .description = "Vectors use two units", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vsx)] = .{ + result[@backingInt(Feature.vsx)] = .{ .llvm_name = "vsx", .description = "Enable VSX instructions", .dependencies = featureSet(&[_]Feature{ diff --git a/lib/std/Target/propeller.zig b/lib/std/Target/propeller.zig index 8e0b6e8580ae72967a44f762c228006119074ef3..2d2d1cc161f412a1678f1b52d5d4dfd480a7fd9f 100644 --- a/lib/std/Target/propeller.zig +++ b/lib/std/Target/propeller.zig @@ -17,7 +17,7 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.p2)] = .{ + result[@backingInt(Feature.p2)] = .{ .llvm_name = null, .description = "Enable Propeller 2", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/riscv.zig b/lib/std/Target/riscv.zig index d7da10033c078950766b29705b191da392013b89..495e8629badfb24396e9981eaf2f9e42a3f56819 100644 --- a/lib/std/Target/riscv.zig +++ b/lib/std/Target/riscv.zig @@ -364,17 +364,17 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"32bit")] = .{ + result[@backingInt(Feature.@"32bit")] = .{ .llvm_name = "32bit", .description = "Implements RV32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"64bit")] = .{ + result[@backingInt(Feature.@"64bit")] = .{ .llvm_name = "64bit", .description = "Implements RV64", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.a)] = .{ + result[@backingInt(Feature.a)] = .{ .llvm_name = "a", .description = "'A' (Atomic Instructions)", .dependencies = featureSet(&[_]Feature{ @@ -382,32 +382,32 @@ pub const all_features = blk: { .zalrsc, }), }; - result[@intFromEnum(Feature.add_load_fusion)] = .{ + result[@backingInt(Feature.add_load_fusion)] = .{ .llvm_name = "add-load-fusion", .description = "Enable ADD(.UW) + load macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.addi_load_fusion)] = .{ + result[@backingInt(Feature.addi_load_fusion)] = .{ .llvm_name = "addi-load-fusion", .description = "Enable ADDI + load macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.andes45)] = .{ + result[@backingInt(Feature.andes45)] = .{ .llvm_name = "andes45", .description = "Andes 45-Series processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.auipc_addi_fusion)] = .{ + result[@backingInt(Feature.auipc_addi_fusion)] = .{ .llvm_name = "auipc-addi-fusion", .description = "Enable AUIPC+ADDI macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.auipc_load_fusion)] = .{ + result[@backingInt(Feature.auipc_load_fusion)] = .{ .llvm_name = "auipc-load-fusion", .description = "Enable AUIPC + load macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.b)] = .{ + result[@backingInt(Feature.b)] = .{ .llvm_name = "b", .description = "'B' (the collection of the Zba, Zbb, Zbs extensions)", .dependencies = featureSet(&[_]Feature{ @@ -416,86 +416,86 @@ pub const all_features = blk: { .zbs, }), }; - result[@intFromEnum(Feature.bfext_fusion)] = .{ + result[@backingInt(Feature.bfext_fusion)] = .{ .llvm_name = "bfext-fusion", .description = "Enable SLLI+SRLI (bitfield extract) macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.c)] = .{ + result[@backingInt(Feature.c)] = .{ .llvm_name = "c", .description = "'C' (Compressed Instructions)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.conditional_cmv_fusion)] = .{ + result[@backingInt(Feature.conditional_cmv_fusion)] = .{ .llvm_name = "conditional-cmv-fusion", .description = "Enable branch+c.mv fusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.d)] = .{ + result[@backingInt(Feature.d)] = .{ .llvm_name = "d", .description = "'D' (Double-Precision Floating-Point)", .dependencies = featureSet(&[_]Feature{ .f, }), }; - result[@intFromEnum(Feature.disable_latency_sched_heuristic)] = .{ + result[@backingInt(Feature.disable_latency_sched_heuristic)] = .{ .llvm_name = "disable-latency-sched-heuristic", .description = "Disable latency scheduling heuristic", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_misched_load_clustering)] = .{ + result[@backingInt(Feature.disable_misched_load_clustering)] = .{ .llvm_name = "disable-misched-load-clustering", .description = "Disable load clustering in the machine scheduler", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_misched_store_clustering)] = .{ + result[@backingInt(Feature.disable_misched_store_clustering)] = .{ .llvm_name = "disable-misched-store-clustering", .description = "Disable store clustering in the machine scheduler", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_postmisched_load_clustering)] = .{ + result[@backingInt(Feature.disable_postmisched_load_clustering)] = .{ .llvm_name = "disable-postmisched-load-clustering", .description = "Disable PostRA load clustering in the machine scheduler", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.disable_postmisched_store_clustering)] = .{ + result[@backingInt(Feature.disable_postmisched_store_clustering)] = .{ .llvm_name = "disable-postmisched-store-clustering", .description = "Disable PostRA store clustering in the machine scheduler", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dlen_factor_2)] = .{ + result[@backingInt(Feature.dlen_factor_2)] = .{ .llvm_name = "dlen-factor-2", .description = "Vector unit DLEN(data path width) is half of VLEN", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.e)] = .{ + result[@backingInt(Feature.e)] = .{ .llvm_name = "e", .description = "'E' (Embedded Instruction Set with 16 GPRs)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.enable_vsetvli_sched_heuristic)] = .{ + result[@backingInt(Feature.enable_vsetvli_sched_heuristic)] = .{ .llvm_name = "enable-vsetvli-sched-heuristic", .description = "Enable vsetvli-based scheduling heuristic", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.exact_asm)] = .{ + result[@backingInt(Feature.exact_asm)] = .{ .llvm_name = "exact-asm", .description = "Enable Exact Assembly (Disables Compression and Relaxation)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental)] = .{ + result[@backingInt(Feature.experimental)] = .{ .llvm_name = "experimental", .description = "Experimental intrinsics", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_p)] = .{ + result[@backingInt(Feature.experimental_p)] = .{ .llvm_name = "experimental-p", .description = "'P' ('Base P' (Packed SIMD))", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_rvm23u32)] = .{ + result[@backingInt(Feature.experimental_rvm23u32)] = .{ .llvm_name = "experimental-rvm23u32", .description = "RISC-V experimental-rvm23u32 profile", .dependencies = featureSet(&[_]Feature{ @@ -512,49 +512,49 @@ pub const all_features = blk: { .zimop, }), }; - result[@intFromEnum(Feature.experimental_smpmpmt)] = .{ + result[@backingInt(Feature.experimental_smpmpmt)] = .{ .llvm_name = "experimental-smpmpmt", .description = "'Smpmpmt' (PMP-based Memory Types Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_svukte)] = .{ + result[@backingInt(Feature.experimental_svukte)] = .{ .llvm_name = "experimental-svukte", .description = "'Svukte' (Address-Independent Latency of User-Mode Faults to Supervisor Addresses)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_xrivosvisni)] = .{ + result[@backingInt(Feature.experimental_xrivosvisni)] = .{ .llvm_name = "experimental-xrivosvisni", .description = "'XRivosVisni' (Rivos Vector Integer Small New)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_xrivosvizip)] = .{ + result[@backingInt(Feature.experimental_xrivosvizip)] = .{ .llvm_name = "experimental-xrivosvizip", .description = "'XRivosVizip' (Rivos Vector Register Zips)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_xsfmclic)] = .{ + result[@backingInt(Feature.experimental_xsfmclic)] = .{ .llvm_name = "experimental-xsfmclic", .description = "'XSfmclic' (SiFive CLIC Machine-mode CSRs)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_xsfsclic)] = .{ + result[@backingInt(Feature.experimental_xsfsclic)] = .{ .llvm_name = "experimental-xsfsclic", .description = "'XSfsclic' (SiFive CLIC Supervisor-mode CSRs)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_zibi)] = .{ + result[@backingInt(Feature.experimental_zibi)] = .{ .llvm_name = "experimental-zibi", .description = "'Zibi' (Branch with Immediate)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.experimental_zicfilp)] = .{ + result[@backingInt(Feature.experimental_zicfilp)] = .{ .llvm_name = "experimental-zicfilp", .description = "'Zicfilp' (Landing pad)", .dependencies = featureSet(&[_]Feature{ .zicsr, }), }; - result[@intFromEnum(Feature.experimental_zicfiss)] = .{ + result[@backingInt(Feature.experimental_zicfiss)] = .{ .llvm_name = "experimental-zicfiss", .description = "'Zicfiss' (Shadow stack)", .dependencies = featureSet(&[_]Feature{ @@ -562,14 +562,14 @@ pub const all_features = blk: { .zimop, }), }; - result[@intFromEnum(Feature.experimental_zvbc32e)] = .{ + result[@backingInt(Feature.experimental_zvbc32e)] = .{ .llvm_name = "experimental-zvbc32e", .description = "'Zvbc32e' (Vector Carryless Multiplication with 32-bits elements)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.experimental_zvfbfa)] = .{ + result[@backingInt(Feature.experimental_zvfbfa)] = .{ .llvm_name = "experimental-zvfbfa", .description = "'Zvfbfa' (Additional BF16 vector compute support)", .dependencies = featureSet(&[_]Feature{ @@ -577,324 +577,324 @@ pub const all_features = blk: { .zve32f, }), }; - result[@intFromEnum(Feature.experimental_zvfofp8min)] = .{ + result[@backingInt(Feature.experimental_zvfofp8min)] = .{ .llvm_name = "experimental-zvfofp8min", .description = "'Zvfofp8min' (Vector OFP8 Converts)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.experimental_zvkgs)] = .{ + result[@backingInt(Feature.experimental_zvkgs)] = .{ .llvm_name = "experimental-zvkgs", .description = "'Zvkgs' (Vector-Scalar GCM instructions for Cryptography)", .dependencies = featureSet(&[_]Feature{ .zvkg, }), }; - result[@intFromEnum(Feature.experimental_zvqdotq)] = .{ + result[@backingInt(Feature.experimental_zvqdotq)] = .{ .llvm_name = "experimental-zvqdotq", .description = "'Zvqdotq' (Vector quad widening 4D Dot Product)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.f)] = .{ + result[@backingInt(Feature.f)] = .{ .llvm_name = "f", .description = "'F' (Single-Precision Floating-Point)", .dependencies = featureSet(&[_]Feature{ .zicsr, }), }; - result[@intFromEnum(Feature.forced_atomics)] = .{ + result[@backingInt(Feature.forced_atomics)] = .{ .llvm_name = "forced-atomics", .description = "Assume that lock-free native-width atomics are available", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.h)] = .{ + result[@backingInt(Feature.h)] = .{ .llvm_name = "h", .description = "'H' (Hypervisor)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.i)] = .{ + result[@backingInt(Feature.i)] = .{ .llvm_name = "i", .description = "'I' (Base Integer Instruction Set)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ld_add_fusion)] = .{ + result[@backingInt(Feature.ld_add_fusion)] = .{ .llvm_name = "ld-add-fusion", .description = "Enable LD+ADD macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.log_vrgather)] = .{ + result[@backingInt(Feature.log_vrgather)] = .{ .llvm_name = "log-vrgather", .description = "Has vrgather.vv with LMUL*log2(LMUL) latency", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lui_addi_fusion)] = .{ + result[@backingInt(Feature.lui_addi_fusion)] = .{ .llvm_name = "lui-addi-fusion", .description = "Enable LUI+ADDI macro fusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lui_load_fusion)] = .{ + result[@backingInt(Feature.lui_load_fusion)] = .{ .llvm_name = "lui-load-fusion", .description = "Enable LUI + load macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.m)] = .{ + result[@backingInt(Feature.m)] = .{ .llvm_name = "m", .description = "'M' (Integer Multiplication and Division)", .dependencies = featureSet(&[_]Feature{ .zmmul, }), }; - result[@intFromEnum(Feature.mips_p8700)] = .{ + result[@backingInt(Feature.mips_p8700)] = .{ .llvm_name = "mips-p8700", .description = "MIPS p8700 processor", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_default_unroll)] = .{ + result[@backingInt(Feature.no_default_unroll)] = .{ .llvm_name = "no-default-unroll", .description = "Disable default unroll preference.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_sink_splat_operands)] = .{ + result[@backingInt(Feature.no_sink_splat_operands)] = .{ .llvm_name = "no-sink-splat-operands", .description = "Disable sink splat operands to enable .vx, .vf,.wx, and .wf instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_trailing_seq_cst_fence)] = .{ + result[@backingInt(Feature.no_trailing_seq_cst_fence)] = .{ .llvm_name = "no-trailing-seq-cst-fence", .description = "Disable trailing fence for seq-cst store.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_nf2_segment_load_store)] = .{ + result[@backingInt(Feature.optimized_nf2_segment_load_store)] = .{ .llvm_name = "optimized-nf2-segment-load-store", .description = "vlseg2eN.v and vsseg2eN.v are implemented as a wide memory op and shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_nf3_segment_load_store)] = .{ + result[@backingInt(Feature.optimized_nf3_segment_load_store)] = .{ .llvm_name = "optimized-nf3-segment-load-store", .description = "vlseg3eN.v and vsseg3eN.v are implemented as a wide memory op and shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_nf4_segment_load_store)] = .{ + result[@backingInt(Feature.optimized_nf4_segment_load_store)] = .{ .llvm_name = "optimized-nf4-segment-load-store", .description = "vlseg4eN.v and vsseg4eN.v are implemented as a wide memory op and shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_nf5_segment_load_store)] = .{ + result[@backingInt(Feature.optimized_nf5_segment_load_store)] = .{ .llvm_name = "optimized-nf5-segment-load-store", .description = "vlseg5eN.v and vsseg5eN.v are implemented as a wide memory op and shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_nf6_segment_load_store)] = .{ + result[@backingInt(Feature.optimized_nf6_segment_load_store)] = .{ .llvm_name = "optimized-nf6-segment-load-store", .description = "vlseg6eN.v and vsseg6eN.v are implemented as a wide memory op and shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_nf7_segment_load_store)] = .{ + result[@backingInt(Feature.optimized_nf7_segment_load_store)] = .{ .llvm_name = "optimized-nf7-segment-load-store", .description = "vlseg7eN.v and vsseg7eN.v are implemented as a wide memory op and shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_nf8_segment_load_store)] = .{ + result[@backingInt(Feature.optimized_nf8_segment_load_store)] = .{ .llvm_name = "optimized-nf8-segment-load-store", .description = "vlseg8eN.v and vsseg8eN.v are implemented as a wide memory op and shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.optimized_zero_stride_load)] = .{ + result[@backingInt(Feature.optimized_zero_stride_load)] = .{ .llvm_name = "optimized-zero-stride-load", .description = "Optimized (perform fewer memory operations)zero-stride vector load", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.permissive_zalrsc)] = .{ + result[@backingInt(Feature.permissive_zalrsc)] = .{ .llvm_name = "permissive-zalrsc", .description = "Implementation permits non-base instructions between LR/SC pairs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.predictable_select_expensive)] = .{ + result[@backingInt(Feature.predictable_select_expensive)] = .{ .llvm_name = "predictable-select-expensive", .description = "Prefer likely predicted branches over selects", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_vsetvli_over_read_vlenb)] = .{ + result[@backingInt(Feature.prefer_vsetvli_over_read_vlenb)] = .{ .llvm_name = "prefer-vsetvli-over-read-vlenb", .description = "Prefer vsetvli over read vlenb CSR to calculate VLEN", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_w_inst)] = .{ + result[@backingInt(Feature.prefer_w_inst)] = .{ .llvm_name = "prefer-w-inst", .description = "Prefer instructions with W suffix", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.q)] = .{ + result[@backingInt(Feature.q)] = .{ .llvm_name = "q", .description = "'Q' (Quad-Precision Floating-Point)", .dependencies = featureSet(&[_]Feature{ .d, }), }; - result[@intFromEnum(Feature.relax)] = .{ + result[@backingInt(Feature.relax)] = .{ .llvm_name = "relax", .description = "Enable Linker relaxation.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x1)] = .{ + result[@backingInt(Feature.reserve_x1)] = .{ .llvm_name = "reserve-x1", .description = "Reserve X1", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x10)] = .{ + result[@backingInt(Feature.reserve_x10)] = .{ .llvm_name = "reserve-x10", .description = "Reserve X10", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x11)] = .{ + result[@backingInt(Feature.reserve_x11)] = .{ .llvm_name = "reserve-x11", .description = "Reserve X11", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x12)] = .{ + result[@backingInt(Feature.reserve_x12)] = .{ .llvm_name = "reserve-x12", .description = "Reserve X12", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x13)] = .{ + result[@backingInt(Feature.reserve_x13)] = .{ .llvm_name = "reserve-x13", .description = "Reserve X13", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x14)] = .{ + result[@backingInt(Feature.reserve_x14)] = .{ .llvm_name = "reserve-x14", .description = "Reserve X14", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x15)] = .{ + result[@backingInt(Feature.reserve_x15)] = .{ .llvm_name = "reserve-x15", .description = "Reserve X15", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x16)] = .{ + result[@backingInt(Feature.reserve_x16)] = .{ .llvm_name = "reserve-x16", .description = "Reserve X16", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x17)] = .{ + result[@backingInt(Feature.reserve_x17)] = .{ .llvm_name = "reserve-x17", .description = "Reserve X17", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x18)] = .{ + result[@backingInt(Feature.reserve_x18)] = .{ .llvm_name = "reserve-x18", .description = "Reserve X18", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x19)] = .{ + result[@backingInt(Feature.reserve_x19)] = .{ .llvm_name = "reserve-x19", .description = "Reserve X19", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x2)] = .{ + result[@backingInt(Feature.reserve_x2)] = .{ .llvm_name = "reserve-x2", .description = "Reserve X2", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x20)] = .{ + result[@backingInt(Feature.reserve_x20)] = .{ .llvm_name = "reserve-x20", .description = "Reserve X20", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x21)] = .{ + result[@backingInt(Feature.reserve_x21)] = .{ .llvm_name = "reserve-x21", .description = "Reserve X21", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x22)] = .{ + result[@backingInt(Feature.reserve_x22)] = .{ .llvm_name = "reserve-x22", .description = "Reserve X22", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x23)] = .{ + result[@backingInt(Feature.reserve_x23)] = .{ .llvm_name = "reserve-x23", .description = "Reserve X23", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x24)] = .{ + result[@backingInt(Feature.reserve_x24)] = .{ .llvm_name = "reserve-x24", .description = "Reserve X24", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x25)] = .{ + result[@backingInt(Feature.reserve_x25)] = .{ .llvm_name = "reserve-x25", .description = "Reserve X25", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x26)] = .{ + result[@backingInt(Feature.reserve_x26)] = .{ .llvm_name = "reserve-x26", .description = "Reserve X26", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x27)] = .{ + result[@backingInt(Feature.reserve_x27)] = .{ .llvm_name = "reserve-x27", .description = "Reserve X27", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x28)] = .{ + result[@backingInt(Feature.reserve_x28)] = .{ .llvm_name = "reserve-x28", .description = "Reserve X28", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x29)] = .{ + result[@backingInt(Feature.reserve_x29)] = .{ .llvm_name = "reserve-x29", .description = "Reserve X29", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x3)] = .{ + result[@backingInt(Feature.reserve_x3)] = .{ .llvm_name = "reserve-x3", .description = "Reserve X3", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x30)] = .{ + result[@backingInt(Feature.reserve_x30)] = .{ .llvm_name = "reserve-x30", .description = "Reserve X30", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x31)] = .{ + result[@backingInt(Feature.reserve_x31)] = .{ .llvm_name = "reserve-x31", .description = "Reserve X31", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x4)] = .{ + result[@backingInt(Feature.reserve_x4)] = .{ .llvm_name = "reserve-x4", .description = "Reserve X4", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x5)] = .{ + result[@backingInt(Feature.reserve_x5)] = .{ .llvm_name = "reserve-x5", .description = "Reserve X5", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x6)] = .{ + result[@backingInt(Feature.reserve_x6)] = .{ .llvm_name = "reserve-x6", .description = "Reserve X6", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x7)] = .{ + result[@backingInt(Feature.reserve_x7)] = .{ .llvm_name = "reserve-x7", .description = "Reserve X7", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x8)] = .{ + result[@backingInt(Feature.reserve_x8)] = .{ .llvm_name = "reserve-x8", .description = "Reserve X8", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_x9)] = .{ + result[@backingInt(Feature.reserve_x9)] = .{ .llvm_name = "reserve-x9", .description = "Reserve X9", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rva20s64)] = .{ + result[@backingInt(Feature.rva20s64)] = .{ .llvm_name = "rva20s64", .description = "RISC-V rva20s64 profile", .dependencies = featureSet(&[_]Feature{ @@ -918,7 +918,7 @@ pub const all_features = blk: { .zifencei, }), }; - result[@intFromEnum(Feature.rva20u64)] = .{ + result[@backingInt(Feature.rva20u64)] = .{ .llvm_name = "rva20u64", .description = "RISC-V rva20u64 profile", .dependencies = featureSet(&[_]Feature{ @@ -936,7 +936,7 @@ pub const all_features = blk: { .zicntr, }), }; - result[@intFromEnum(Feature.rva22s64)] = .{ + result[@backingInt(Feature.rva22s64)] = .{ .llvm_name = "rva22s64", .description = "RISC-V rva22s64 profile", .dependencies = featureSet(&[_]Feature{ @@ -972,7 +972,7 @@ pub const all_features = blk: { .zkt, }), }; - result[@intFromEnum(Feature.rva22u64)] = .{ + result[@backingInt(Feature.rva22u64)] = .{ .llvm_name = "rva22u64", .description = "RISC-V rva22u64 profile", .dependencies = featureSet(&[_]Feature{ @@ -999,7 +999,7 @@ pub const all_features = blk: { .zkt, }), }; - result[@intFromEnum(Feature.rva23s64)] = .{ + result[@backingInt(Feature.rva23s64)] = .{ .llvm_name = "rva23s64", .description = "RISC-V rva23s64 profile", .dependencies = featureSet(&[_]Feature{ @@ -1052,7 +1052,7 @@ pub const all_features = blk: { .zvkt, }), }; - result[@intFromEnum(Feature.rva23u64)] = .{ + result[@backingInt(Feature.rva23u64)] = .{ .llvm_name = "rva23u64", .description = "RISC-V rva23u64 profile", .dependencies = featureSet(&[_]Feature{ @@ -1090,7 +1090,7 @@ pub const all_features = blk: { .zvkt, }), }; - result[@intFromEnum(Feature.rvb23s64)] = .{ + result[@backingInt(Feature.rvb23s64)] = .{ .llvm_name = "rvb23s64", .description = "RISC-V rvb23s64 profile", .dependencies = featureSet(&[_]Feature{ @@ -1136,7 +1136,7 @@ pub const all_features = blk: { .zkt, }), }; - result[@intFromEnum(Feature.rvb23u64)] = .{ + result[@backingInt(Feature.rvb23u64)] = .{ .llvm_name = "rvb23u64", .description = "RISC-V rvb23u64 profile", .dependencies = featureSet(&[_]Feature{ @@ -1169,7 +1169,7 @@ pub const all_features = blk: { .zkt, }), }; - result[@intFromEnum(Feature.rvi20u32)] = .{ + result[@backingInt(Feature.rvi20u32)] = .{ .llvm_name = "rvi20u32", .description = "RISC-V rvi20u32 profile", .dependencies = featureSet(&[_]Feature{ @@ -1177,7 +1177,7 @@ pub const all_features = blk: { .i, }), }; - result[@intFromEnum(Feature.rvi20u64)] = .{ + result[@backingInt(Feature.rvi20u64)] = .{ .llvm_name = "rvi20u64", .description = "RISC-V rvi20u64 profile", .dependencies = featureSet(&[_]Feature{ @@ -1185,22 +1185,22 @@ pub const all_features = blk: { .i, }), }; - result[@intFromEnum(Feature.save_restore)] = .{ + result[@backingInt(Feature.save_restore)] = .{ .llvm_name = "save-restore", .description = "Enable save/restore.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdext)] = .{ + result[@backingInt(Feature.sdext)] = .{ .llvm_name = "sdext", .description = "'Sdext' (External debugger)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sdtrig)] = .{ + result[@backingInt(Feature.sdtrig)] = .{ .llvm_name = "sdtrig", .description = "'Sdtrig' (Debugger triggers)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sha)] = .{ + result[@backingInt(Feature.sha)] = .{ .llvm_name = "sha", .description = "'Sha' (Augmented Hypervisor)", .dependencies = featureSet(&[_]Feature{ @@ -1214,291 +1214,291 @@ pub const all_features = blk: { .ssstateen, }), }; - result[@intFromEnum(Feature.shcounterenw)] = .{ + result[@backingInt(Feature.shcounterenw)] = .{ .llvm_name = "shcounterenw", .description = "'Shcounterenw' (Support writeable hcounteren enable bit for any hpmcounter that is not read-only zero)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shgatpa)] = .{ + result[@backingInt(Feature.shgatpa)] = .{ .llvm_name = "shgatpa", .description = "'Shgatpa' (SvNNx4 mode supported for all modes supported by satp, as well as Bare)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shifted_zextw_fusion)] = .{ + result[@backingInt(Feature.shifted_zextw_fusion)] = .{ .llvm_name = "shifted-zextw-fusion", .description = "Enable SLLI+SRLI to be fused when computing (shifted) word zero extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shlcofideleg)] = .{ + result[@backingInt(Feature.shlcofideleg)] = .{ .llvm_name = "shlcofideleg", .description = "'Shlcofideleg' (Delegating LCOFI Interrupts to VS-mode)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.short_forward_branch_ialu)] = .{ + result[@backingInt(Feature.short_forward_branch_ialu)] = .{ .llvm_name = "short-forward-branch-ialu", .description = "Enable short forward branch optimization for RVI base instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.short_forward_branch_iload)] = .{ + result[@backingInt(Feature.short_forward_branch_iload)] = .{ .llvm_name = "short-forward-branch-iload", .description = "Enable short forward branch optimization for load instructions", .dependencies = featureSet(&[_]Feature{ .short_forward_branch_ialu, }), }; - result[@intFromEnum(Feature.short_forward_branch_iminmax)] = .{ + result[@backingInt(Feature.short_forward_branch_iminmax)] = .{ .llvm_name = "short-forward-branch-iminmax", .description = "Enable short forward branch optimization for MIN,MAX instructions in Zbb", .dependencies = featureSet(&[_]Feature{ .short_forward_branch_ialu, }), }; - result[@intFromEnum(Feature.short_forward_branch_imul)] = .{ + result[@backingInt(Feature.short_forward_branch_imul)] = .{ .llvm_name = "short-forward-branch-imul", .description = "Enable short forward branch optimization for MUL instruction", .dependencies = featureSet(&[_]Feature{ .short_forward_branch_ialu, }), }; - result[@intFromEnum(Feature.shtvala)] = .{ + result[@backingInt(Feature.shtvala)] = .{ .llvm_name = "shtvala", .description = "'Shtvala' (htval provides all needed values)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shvsatpa)] = .{ + result[@backingInt(Feature.shvsatpa)] = .{ .llvm_name = "shvsatpa", .description = "'Shvsatpa' (vsatp supports all modes supported by satp)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shvstvala)] = .{ + result[@backingInt(Feature.shvstvala)] = .{ .llvm_name = "shvstvala", .description = "'Shvstvala' (vstval provides all needed values)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shvstvecd)] = .{ + result[@backingInt(Feature.shvstvecd)] = .{ .llvm_name = "shvstvecd", .description = "'Shvstvecd' (vstvec supports Direct mode)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.shxadd_load_fusion)] = .{ + result[@backingInt(Feature.shxadd_load_fusion)] = .{ .llvm_name = "shxadd-load-fusion", .description = "Enable SH(1|2|3)ADD(.UW) + load macrofusion", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.single_element_vec_fp64)] = .{ + result[@backingInt(Feature.single_element_vec_fp64)] = .{ .llvm_name = "single-element-vec-fp64", .description = "Certain vector FP64 operations produce a single result element per cycle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smaia)] = .{ + result[@backingInt(Feature.smaia)] = .{ .llvm_name = "smaia", .description = "'Smaia' (Advanced Interrupt Architecture Machine Level)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smcdeleg)] = .{ + result[@backingInt(Feature.smcdeleg)] = .{ .llvm_name = "smcdeleg", .description = "'Smcdeleg' (Counter Delegation Machine Level)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smcntrpmf)] = .{ + result[@backingInt(Feature.smcntrpmf)] = .{ .llvm_name = "smcntrpmf", .description = "'Smcntrpmf' (Cycle and Instret Privilege Mode Filtering)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smcsrind)] = .{ + result[@backingInt(Feature.smcsrind)] = .{ .llvm_name = "smcsrind", .description = "'Smcsrind' (Indirect CSR Access Machine Level)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smctr)] = .{ + result[@backingInt(Feature.smctr)] = .{ .llvm_name = "smctr", .description = "'Smctr' (Control Transfer Records Machine Level)", .dependencies = featureSet(&[_]Feature{ .sscsrind, }), }; - result[@intFromEnum(Feature.smdbltrp)] = .{ + result[@backingInt(Feature.smdbltrp)] = .{ .llvm_name = "smdbltrp", .description = "'Smdbltrp' (Double Trap Machine Level)", .dependencies = featureSet(&[_]Feature{ .zicsr, }), }; - result[@intFromEnum(Feature.smepmp)] = .{ + result[@backingInt(Feature.smepmp)] = .{ .llvm_name = "smepmp", .description = "'Smepmp' (Enhanced Physical Memory Protection)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smmpm)] = .{ + result[@backingInt(Feature.smmpm)] = .{ .llvm_name = "smmpm", .description = "'Smmpm' (Machine-level Pointer Masking for M-mode)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smnpm)] = .{ + result[@backingInt(Feature.smnpm)] = .{ .llvm_name = "smnpm", .description = "'Smnpm' (Machine-level Pointer Masking for next lower privilege mode)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smrnmi)] = .{ + result[@backingInt(Feature.smrnmi)] = .{ .llvm_name = "smrnmi", .description = "'Smrnmi' (Resumable Non-Maskable Interrupts)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smstateen)] = .{ + result[@backingInt(Feature.smstateen)] = .{ .llvm_name = "smstateen", .description = "'Smstateen' (Machine-mode view of the state-enable extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssaia)] = .{ + result[@backingInt(Feature.ssaia)] = .{ .llvm_name = "ssaia", .description = "'Ssaia' (Advanced Interrupt Architecture Supervisor Level)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssccfg)] = .{ + result[@backingInt(Feature.ssccfg)] = .{ .llvm_name = "ssccfg", .description = "'Ssccfg' (Counter Configuration Supervisor Level)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssccptr)] = .{ + result[@backingInt(Feature.ssccptr)] = .{ .llvm_name = "ssccptr", .description = "'Ssccptr' (Main memory supports page table reads)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sscofpmf)] = .{ + result[@backingInt(Feature.sscofpmf)] = .{ .llvm_name = "sscofpmf", .description = "'Sscofpmf' (Count Overflow and Mode-Based Filtering)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sscounterenw)] = .{ + result[@backingInt(Feature.sscounterenw)] = .{ .llvm_name = "sscounterenw", .description = "'Sscounterenw' (Support writeable scounteren enable bit for any hpmcounter that is not read-only zero)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sscsrind)] = .{ + result[@backingInt(Feature.sscsrind)] = .{ .llvm_name = "sscsrind", .description = "'Sscsrind' (Indirect CSR Access Supervisor Level)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssctr)] = .{ + result[@backingInt(Feature.ssctr)] = .{ .llvm_name = "ssctr", .description = "'Ssctr' (Control Transfer Records Supervisor Level)", .dependencies = featureSet(&[_]Feature{ .sscsrind, }), }; - result[@intFromEnum(Feature.ssdbltrp)] = .{ + result[@backingInt(Feature.ssdbltrp)] = .{ .llvm_name = "ssdbltrp", .description = "'Ssdbltrp' (Double Trap Supervisor Level)", .dependencies = featureSet(&[_]Feature{ .zicsr, }), }; - result[@intFromEnum(Feature.ssnpm)] = .{ + result[@backingInt(Feature.ssnpm)] = .{ .llvm_name = "ssnpm", .description = "'Ssnpm' (Supervisor-level Pointer Masking for next lower privilege mode)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sspm)] = .{ + result[@backingInt(Feature.sspm)] = .{ .llvm_name = "sspm", .description = "'Sspm' (Indicates Supervisor-mode Pointer Masking)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssqosid)] = .{ + result[@backingInt(Feature.ssqosid)] = .{ .llvm_name = "ssqosid", .description = "'Ssqosid' (Quality-of-Service (QoS) Identifiers)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssstateen)] = .{ + result[@backingInt(Feature.ssstateen)] = .{ .llvm_name = "ssstateen", .description = "'Ssstateen' (Supervisor-mode view of the state-enable extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssstrict)] = .{ + result[@backingInt(Feature.ssstrict)] = .{ .llvm_name = "ssstrict", .description = "'Ssstrict' (No non-conforming extensions are present)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sstc)] = .{ + result[@backingInt(Feature.sstc)] = .{ .llvm_name = "sstc", .description = "'Sstc' (Supervisor-mode timer interrupts)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sstvala)] = .{ + result[@backingInt(Feature.sstvala)] = .{ .llvm_name = "sstvala", .description = "'Sstvala' (stval provides all needed values)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sstvecd)] = .{ + result[@backingInt(Feature.sstvecd)] = .{ .llvm_name = "sstvecd", .description = "'Sstvecd' (stvec supports Direct mode)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssu64xl)] = .{ + result[@backingInt(Feature.ssu64xl)] = .{ .llvm_name = "ssu64xl", .description = "'Ssu64xl' (UXLEN=64 supported)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.supm)] = .{ + result[@backingInt(Feature.supm)] = .{ .llvm_name = "supm", .description = "'Supm' (Indicates User-mode Pointer Masking)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.svade)] = .{ + result[@backingInt(Feature.svade)] = .{ .llvm_name = "svade", .description = "'Svade' (Raise exceptions on improper A/D bits)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.svadu)] = .{ + result[@backingInt(Feature.svadu)] = .{ .llvm_name = "svadu", .description = "'Svadu' (Hardware A/D updates)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.svbare)] = .{ + result[@backingInt(Feature.svbare)] = .{ .llvm_name = "svbare", .description = "'Svbare' (satp mode Bare supported)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.svinval)] = .{ + result[@backingInt(Feature.svinval)] = .{ .llvm_name = "svinval", .description = "'Svinval' (Fine-Grained Address-Translation Cache Invalidation)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.svnapot)] = .{ + result[@backingInt(Feature.svnapot)] = .{ .llvm_name = "svnapot", .description = "'Svnapot' (NAPOT Translation Contiguity)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.svpbmt)] = .{ + result[@backingInt(Feature.svpbmt)] = .{ .llvm_name = "svpbmt", .description = "'Svpbmt' (Page-Based Memory Types)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.svvptc)] = .{ + result[@backingInt(Feature.svvptc)] = .{ .llvm_name = "svvptc", .description = "'Svvptc' (Obviating Memory-Management Instructions after Marking PTEs Valid)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tagged_globals)] = .{ + result[@backingInt(Feature.tagged_globals)] = .{ .llvm_name = "tagged-globals", .description = "Use an instruction sequence for taking the address of a global that allows a memory tag in the upper address bits", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unaligned_scalar_mem)] = .{ + result[@backingInt(Feature.unaligned_scalar_mem)] = .{ .llvm_name = "unaligned-scalar-mem", .description = "Has reasonably performant unaligned scalar loads and stores", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unaligned_vector_mem)] = .{ + result[@backingInt(Feature.unaligned_vector_mem)] = .{ .llvm_name = "unaligned-vector-mem", .description = "Has reasonably performant unaligned vector loads and stores", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_postra_scheduler)] = .{ + result[@backingInt(Feature.use_postra_scheduler)] = .{ .llvm_name = "use-postra-scheduler", .description = "Schedule again after register allocation", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v)] = .{ + result[@backingInt(Feature.v)] = .{ .llvm_name = "v", .description = "'V' (Vector Extension for Application Processors)", .dependencies = featureSet(&[_]Feature{ @@ -1506,131 +1506,131 @@ pub const all_features = blk: { .zvl128b, }), }; - result[@intFromEnum(Feature.ventana_veyron)] = .{ + result[@backingInt(Feature.ventana_veyron)] = .{ .llvm_name = "ventana-veyron", .description = "Ventana Veyron-Series processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vl_dependent_latency)] = .{ + result[@backingInt(Feature.vl_dependent_latency)] = .{ .llvm_name = "vl-dependent-latency", .description = "Latency of vector instructions is dependent on the dynamic value of vl", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vxrm_pipeline_flush)] = .{ + result[@backingInt(Feature.vxrm_pipeline_flush)] = .{ .llvm_name = "vxrm-pipeline-flush", .description = "VXRM writes causes pipeline flush", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xandesbfhcvt)] = .{ + result[@backingInt(Feature.xandesbfhcvt)] = .{ .llvm_name = "xandesbfhcvt", .description = "'XAndesBFHCvt' (Andes Scalar BFLOAT16 Conversion Extension)", .dependencies = featureSet(&[_]Feature{ .f, }), }; - result[@intFromEnum(Feature.xandesperf)] = .{ + result[@backingInt(Feature.xandesperf)] = .{ .llvm_name = "xandesperf", .description = "'XAndesPerf' (Andes Performance Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xandesvbfhcvt)] = .{ + result[@backingInt(Feature.xandesvbfhcvt)] = .{ .llvm_name = "xandesvbfhcvt", .description = "'XAndesVBFHCvt' (Andes Vector BFLOAT16 Conversion Extension)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.xandesvdot)] = .{ + result[@backingInt(Feature.xandesvdot)] = .{ .llvm_name = "xandesvdot", .description = "'XAndesVDot' (Andes Vector Dot Product Extension)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.xandesvpackfph)] = .{ + result[@backingInt(Feature.xandesvpackfph)] = .{ .llvm_name = "xandesvpackfph", .description = "'XAndesVPackFPH' (Andes Vector Packed FP16 Extension)", .dependencies = featureSet(&[_]Feature{ .f, }), }; - result[@intFromEnum(Feature.xandesvsinth)] = .{ + result[@backingInt(Feature.xandesvsinth)] = .{ .llvm_name = "xandesvsinth", .description = "'XAndesVSIntH' (Andes Vector Small INT Handling Extension)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.xandesvsintload)] = .{ + result[@backingInt(Feature.xandesvsintload)] = .{ .llvm_name = "xandesvsintload", .description = "'XAndesVSIntLoad' (Andes Vector INT4 Load Extension)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.xcvalu)] = .{ + result[@backingInt(Feature.xcvalu)] = .{ .llvm_name = "xcvalu", .description = "'XCValu' (CORE-V ALU Operations)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xcvbi)] = .{ + result[@backingInt(Feature.xcvbi)] = .{ .llvm_name = "xcvbi", .description = "'XCVbi' (CORE-V Immediate Branching)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xcvbitmanip)] = .{ + result[@backingInt(Feature.xcvbitmanip)] = .{ .llvm_name = "xcvbitmanip", .description = "'XCVbitmanip' (CORE-V Bit Manipulation)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xcvelw)] = .{ + result[@backingInt(Feature.xcvelw)] = .{ .llvm_name = "xcvelw", .description = "'XCVelw' (CORE-V Event Load Word)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xcvmac)] = .{ + result[@backingInt(Feature.xcvmac)] = .{ .llvm_name = "xcvmac", .description = "'XCVmac' (CORE-V Multiply-Accumulate)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xcvmem)] = .{ + result[@backingInt(Feature.xcvmem)] = .{ .llvm_name = "xcvmem", .description = "'XCVmem' (CORE-V Post-incrementing Load & Store)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xcvsimd)] = .{ + result[@backingInt(Feature.xcvsimd)] = .{ .llvm_name = "xcvsimd", .description = "'XCVsimd' (CORE-V SIMD ALU)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xmipscbop)] = .{ + result[@backingInt(Feature.xmipscbop)] = .{ .llvm_name = "xmipscbop", .description = "'XMIPSCBOP' (MIPS Software Prefetch)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xmipscmov)] = .{ + result[@backingInt(Feature.xmipscmov)] = .{ .llvm_name = "xmipscmov", .description = "'XMIPSCMov' (MIPS conditional move instruction (mips.ccmov))", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xmipsexectl)] = .{ + result[@backingInt(Feature.xmipsexectl)] = .{ .llvm_name = "xmipsexectl", .description = "'XMIPSEXECTL' (MIPS execution control)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xmipslsp)] = .{ + result[@backingInt(Feature.xmipslsp)] = .{ .llvm_name = "xmipslsp", .description = "'XMIPSLSP' (MIPS optimization for hardware load-store bonding)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqccmp)] = .{ + result[@backingInt(Feature.xqccmp)] = .{ .llvm_name = "xqccmp", .description = "'Xqccmp' (Qualcomm 16-bit Push/Pop and Double Moves)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqci)] = .{ + result[@backingInt(Feature.xqci)] = .{ .llvm_name = "xqci", .description = "'Xqci' (Qualcomm uC Extension)", .dependencies = featureSet(&[_]Feature{ @@ -1654,124 +1654,124 @@ pub const all_features = blk: { .xqcisync, }), }; - result[@intFromEnum(Feature.xqcia)] = .{ + result[@backingInt(Feature.xqcia)] = .{ .llvm_name = "xqcia", .description = "'Xqcia' (Qualcomm uC Arithmetic Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqciac)] = .{ + result[@backingInt(Feature.xqciac)] = .{ .llvm_name = "xqciac", .description = "'Xqciac' (Qualcomm uC Load-Store Address Calculation Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcibi)] = .{ + result[@backingInt(Feature.xqcibi)] = .{ .llvm_name = "xqcibi", .description = "'Xqcibi' (Qualcomm uC Branch Immediate Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcibm)] = .{ + result[@backingInt(Feature.xqcibm)] = .{ .llvm_name = "xqcibm", .description = "'Xqcibm' (Qualcomm uC Bit Manipulation Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcicli)] = .{ + result[@backingInt(Feature.xqcicli)] = .{ .llvm_name = "xqcicli", .description = "'Xqcicli' (Qualcomm uC Conditional Load Immediate Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqcicm)] = .{ + result[@backingInt(Feature.xqcicm)] = .{ .llvm_name = "xqcicm", .description = "'Xqcicm' (Qualcomm uC Conditional Move Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcics)] = .{ + result[@backingInt(Feature.xqcics)] = .{ .llvm_name = "xqcics", .description = "'Xqcics' (Qualcomm uC Conditional Select Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqcicsr)] = .{ + result[@backingInt(Feature.xqcicsr)] = .{ .llvm_name = "xqcicsr", .description = "'Xqcicsr' (Qualcomm uC CSR Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqciint)] = .{ + result[@backingInt(Feature.xqciint)] = .{ .llvm_name = "xqciint", .description = "'Xqciint' (Qualcomm uC Interrupts Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqciio)] = .{ + result[@backingInt(Feature.xqciio)] = .{ .llvm_name = "xqciio", .description = "'Xqciio' (Qualcomm uC External Input Output Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqcilb)] = .{ + result[@backingInt(Feature.xqcilb)] = .{ .llvm_name = "xqcilb", .description = "'Xqcilb' (Qualcomm uC Long Branch Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcili)] = .{ + result[@backingInt(Feature.xqcili)] = .{ .llvm_name = "xqcili", .description = "'Xqcili' (Qualcomm uC Load Large Immediate Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcilia)] = .{ + result[@backingInt(Feature.xqcilia)] = .{ .llvm_name = "xqcilia", .description = "'Xqcilia' (Qualcomm uC Large Immediate Arithmetic Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcilo)] = .{ + result[@backingInt(Feature.xqcilo)] = .{ .llvm_name = "xqcilo", .description = "'Xqcilo' (Qualcomm uC Large Offset Load Store Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcilsm)] = .{ + result[@backingInt(Feature.xqcilsm)] = .{ .llvm_name = "xqcilsm", .description = "'Xqcilsm' (Qualcomm uC Load Store Multiple Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqcisim)] = .{ + result[@backingInt(Feature.xqcisim)] = .{ .llvm_name = "xqcisim", .description = "'Xqcisim' (Qualcomm uC Simulation Hint Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xqcisls)] = .{ + result[@backingInt(Feature.xqcisls)] = .{ .llvm_name = "xqcisls", .description = "'Xqcisls' (Qualcomm uC Scaled Load Store Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xqcisync)] = .{ + result[@backingInt(Feature.xqcisync)] = .{ .llvm_name = "xqcisync", .description = "'Xqcisync' (Qualcomm uC Sync Delay Extension)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.xsfcease)] = .{ + result[@backingInt(Feature.xsfcease)] = .{ .llvm_name = "xsfcease", .description = "'XSfcease' (SiFive sf.cease Instruction)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xsfmm128t)] = .{ + result[@backingInt(Feature.xsfmm128t)] = .{ .llvm_name = "xsfmm128t", .description = "'XSfmm128t' (TE=128 configuration)", .dependencies = featureSet(&[_]Feature{ @@ -1779,7 +1779,7 @@ pub const all_features = blk: { .zvl512b, }), }; - result[@intFromEnum(Feature.xsfmm16t)] = .{ + result[@backingInt(Feature.xsfmm16t)] = .{ .llvm_name = "xsfmm16t", .description = "'XSfmm16t' (TE=16 configuration)", .dependencies = featureSet(&[_]Feature{ @@ -1787,7 +1787,7 @@ pub const all_features = blk: { .zvl64b, }), }; - result[@intFromEnum(Feature.xsfmm32a16f)] = .{ + result[@backingInt(Feature.xsfmm32a16f)] = .{ .llvm_name = "xsfmm32a16f", .description = "'XSfmm32a16f' (TEW=32-bit accumulation, operands - float: 16b, widen=2 (IEEE, BF))", .dependencies = featureSet(&[_]Feature{ @@ -1795,7 +1795,7 @@ pub const all_features = blk: { .zve32f, }), }; - result[@intFromEnum(Feature.xsfmm32a32f)] = .{ + result[@backingInt(Feature.xsfmm32a32f)] = .{ .llvm_name = "xsfmm32a32f", .description = "'XSfmm32a32f' (TEW=32-bit accumulation, operands - float: 32b)", .dependencies = featureSet(&[_]Feature{ @@ -1803,7 +1803,7 @@ pub const all_features = blk: { .zve32f, }), }; - result[@intFromEnum(Feature.xsfmm32a8f)] = .{ + result[@backingInt(Feature.xsfmm32a8f)] = .{ .llvm_name = "xsfmm32a8f", .description = "'XSfmm32a8f' (TEW=32-bit accumulation, operands - float: fp8)", .dependencies = featureSet(&[_]Feature{ @@ -1811,14 +1811,14 @@ pub const all_features = blk: { .zve32f, }), }; - result[@intFromEnum(Feature.xsfmm32a8i)] = .{ + result[@backingInt(Feature.xsfmm32a8i)] = .{ .llvm_name = "xsfmm32a8i", .description = "'XSfmm32a8i' (TEW=32-bit accumulation, operands - int: 8b)", .dependencies = featureSet(&[_]Feature{ .xsfmmbase, }), }; - result[@intFromEnum(Feature.xsfmm32t)] = .{ + result[@backingInt(Feature.xsfmm32t)] = .{ .llvm_name = "xsfmm32t", .description = "'XSfmm32t' (TE=32 configuration)", .dependencies = featureSet(&[_]Feature{ @@ -1826,7 +1826,7 @@ pub const all_features = blk: { .zvl128b, }), }; - result[@intFromEnum(Feature.xsfmm64a64f)] = .{ + result[@backingInt(Feature.xsfmm64a64f)] = .{ .llvm_name = "xsfmm64a64f", .description = "'XSfmm64a64f' (TEW=64-bit accumulation, operands - float: fp64)", .dependencies = featureSet(&[_]Feature{ @@ -1834,7 +1834,7 @@ pub const all_features = blk: { .zve64d, }), }; - result[@intFromEnum(Feature.xsfmm64t)] = .{ + result[@backingInt(Feature.xsfmm64t)] = .{ .llvm_name = "xsfmm64t", .description = "'XSfmm64t' (TE=64 configuration)", .dependencies = featureSet(&[_]Feature{ @@ -1842,47 +1842,47 @@ pub const all_features = blk: { .zvl256b, }), }; - result[@intFromEnum(Feature.xsfmmbase)] = .{ + result[@backingInt(Feature.xsfmmbase)] = .{ .llvm_name = "xsfmmbase", .description = "'XSfmmbase' (All non arithmetic instructions for all TEWs and sf.vtzero)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.xsfvcp)] = .{ + result[@backingInt(Feature.xsfvcp)] = .{ .llvm_name = "xsfvcp", .description = "'XSfvcp' (SiFive Custom Vector Coprocessor Interface Instructions)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.xsfvfbfexp16e)] = .{ + result[@backingInt(Feature.xsfvfbfexp16e)] = .{ .llvm_name = "xsfvfbfexp16e", .description = "'XSfvfbfexp16e' (SiFive Vector Floating-Point Exponential Function Instruction, BFloat16)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xsfvfexp16e)] = .{ + result[@backingInt(Feature.xsfvfexp16e)] = .{ .llvm_name = "xsfvfexp16e", .description = "'XSfvfexp16e' (SiFive Vector Floating-Point Exponential Function Instruction, Half Precision)", .dependencies = featureSet(&[_]Feature{ .zvfh, }), }; - result[@intFromEnum(Feature.xsfvfexp32e)] = .{ + result[@backingInt(Feature.xsfvfexp32e)] = .{ .llvm_name = "xsfvfexp32e", .description = "'XSfvfexp32e' (SiFive Vector Floating-Point Exponential Function Instruction, Single Precision)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.xsfvfexpa)] = .{ + result[@backingInt(Feature.xsfvfexpa)] = .{ .llvm_name = "xsfvfexpa", .description = "'XSfvfexpa' (SiFive Vector Floating-Point Exponential Approximation Instruction)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.xsfvfexpa64e)] = .{ + result[@backingInt(Feature.xsfvfexpa64e)] = .{ .llvm_name = "xsfvfexpa64e", .description = "'XSfvfexpa64e' (SiFive Vector Floating-Point Exponential Approximation Instruction with Double-Precision)", .dependencies = featureSet(&[_]Feature{ @@ -1890,14 +1890,14 @@ pub const all_features = blk: { .zve64d, }), }; - result[@intFromEnum(Feature.xsfvfnrclipxfqf)] = .{ + result[@backingInt(Feature.xsfvfnrclipxfqf)] = .{ .llvm_name = "xsfvfnrclipxfqf", .description = "'XSfvfnrclipxfqf' (SiFive FP32-to-int8 Ranged Clip Instructions)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.xsfvfwmaccqqq)] = .{ + result[@backingInt(Feature.xsfvfwmaccqqq)] = .{ .llvm_name = "xsfvfwmaccqqq", .description = "'XSfvfwmaccqqq' (SiFive Matrix Multiply Accumulate Instruction (4-by-4))", .dependencies = featureSet(&[_]Feature{ @@ -1905,7 +1905,7 @@ pub const all_features = blk: { .zvl128b, }), }; - result[@intFromEnum(Feature.xsfvqmaccdod)] = .{ + result[@backingInt(Feature.xsfvqmaccdod)] = .{ .llvm_name = "xsfvqmaccdod", .description = "'XSfvqmaccdod' (SiFive Int8 Matrix Multiplication Instructions (2-by-8 and 8-by-2))", .dependencies = featureSet(&[_]Feature{ @@ -1913,7 +1913,7 @@ pub const all_features = blk: { .zvl128b, }), }; - result[@intFromEnum(Feature.xsfvqmaccqoq)] = .{ + result[@backingInt(Feature.xsfvqmaccqoq)] = .{ .llvm_name = "xsfvqmaccqoq", .description = "'XSfvqmaccqoq' (SiFive Int8 Matrix Multiplication Instructions (4-by-8 and 8-by-4))", .dependencies = featureSet(&[_]Feature{ @@ -1921,189 +1921,189 @@ pub const all_features = blk: { .zvl256b, }), }; - result[@intFromEnum(Feature.xsifivecdiscarddlone)] = .{ + result[@backingInt(Feature.xsifivecdiscarddlone)] = .{ .llvm_name = "xsifivecdiscarddlone", .description = "'XSiFivecdiscarddlone' (SiFive sf.cdiscard.d.l1 Instruction)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xsifivecflushdlone)] = .{ + result[@backingInt(Feature.xsifivecflushdlone)] = .{ .llvm_name = "xsifivecflushdlone", .description = "'XSiFivecflushdlone' (SiFive sf.cflush.d.l1 Instruction)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xsmtvdot)] = .{ + result[@backingInt(Feature.xsmtvdot)] = .{ .llvm_name = "xsmtvdot", .description = "'XSMTVDot' (SpacemiT Vector Dot Product Extension)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.xtheadba)] = .{ + result[@backingInt(Feature.xtheadba)] = .{ .llvm_name = "xtheadba", .description = "'XTHeadBa' (T-Head address calculation instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadbb)] = .{ + result[@backingInt(Feature.xtheadbb)] = .{ .llvm_name = "xtheadbb", .description = "'XTHeadBb' (T-Head basic bit-manipulation instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadbs)] = .{ + result[@backingInt(Feature.xtheadbs)] = .{ .llvm_name = "xtheadbs", .description = "'XTHeadBs' (T-Head single-bit instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadcmo)] = .{ + result[@backingInt(Feature.xtheadcmo)] = .{ .llvm_name = "xtheadcmo", .description = "'XTHeadCmo' (T-Head cache management instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadcondmov)] = .{ + result[@backingInt(Feature.xtheadcondmov)] = .{ .llvm_name = "xtheadcondmov", .description = "'XTHeadCondMov' (T-Head conditional move instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadfmemidx)] = .{ + result[@backingInt(Feature.xtheadfmemidx)] = .{ .llvm_name = "xtheadfmemidx", .description = "'XTHeadFMemIdx' (T-Head FP Indexed Memory Operations)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadmac)] = .{ + result[@backingInt(Feature.xtheadmac)] = .{ .llvm_name = "xtheadmac", .description = "'XTHeadMac' (T-Head Multiply-Accumulate Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadmemidx)] = .{ + result[@backingInt(Feature.xtheadmemidx)] = .{ .llvm_name = "xtheadmemidx", .description = "'XTHeadMemIdx' (T-Head Indexed Memory Operations)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadmempair)] = .{ + result[@backingInt(Feature.xtheadmempair)] = .{ .llvm_name = "xtheadmempair", .description = "'XTHeadMemPair' (T-Head two-GPR Memory Operations)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadsync)] = .{ + result[@backingInt(Feature.xtheadsync)] = .{ .llvm_name = "xtheadsync", .description = "'XTHeadSync' (T-Head multicore synchronization instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xtheadvdot)] = .{ + result[@backingInt(Feature.xtheadvdot)] = .{ .llvm_name = "xtheadvdot", .description = "'XTHeadVdot' (T-Head Vector Extensions for Dot)", .dependencies = featureSet(&[_]Feature{ .v, }), }; - result[@intFromEnum(Feature.xventanacondops)] = .{ + result[@backingInt(Feature.xventanacondops)] = .{ .llvm_name = "xventanacondops", .description = "'XVentanaCondOps' (Ventana Conditional Ops)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xwchc)] = .{ + result[@backingInt(Feature.xwchc)] = .{ .llvm_name = "xwchc", .description = "'Xwchc' (WCH/QingKe additional compressed opcodes)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.za128rs)] = .{ + result[@backingInt(Feature.za128rs)] = .{ .llvm_name = "za128rs", .description = "'Za128rs' (Reservation Set Size of at Most 128 Bytes)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.za64rs)] = .{ + result[@backingInt(Feature.za64rs)] = .{ .llvm_name = "za64rs", .description = "'Za64rs' (Reservation Set Size of at Most 64 Bytes)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zaamo)] = .{ + result[@backingInt(Feature.zaamo)] = .{ .llvm_name = "zaamo", .description = "'Zaamo' (Atomic Memory Operations)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zabha)] = .{ + result[@backingInt(Feature.zabha)] = .{ .llvm_name = "zabha", .description = "'Zabha' (Byte and Halfword Atomic Memory Operations)", .dependencies = featureSet(&[_]Feature{ .zaamo, }), }; - result[@intFromEnum(Feature.zacas)] = .{ + result[@backingInt(Feature.zacas)] = .{ .llvm_name = "zacas", .description = "'Zacas' (Atomic Compare-And-Swap Instructions)", .dependencies = featureSet(&[_]Feature{ .zaamo, }), }; - result[@intFromEnum(Feature.zalasr)] = .{ + result[@backingInt(Feature.zalasr)] = .{ .llvm_name = "zalasr", .description = "'Zalasr' (Load-Acquire and Store-Release Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zalrsc)] = .{ + result[@backingInt(Feature.zalrsc)] = .{ .llvm_name = "zalrsc", .description = "'Zalrsc' (Load-Reserved/Store-Conditional)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zama16b)] = .{ + result[@backingInt(Feature.zama16b)] = .{ .llvm_name = "zama16b", .description = "'Zama16b' (Atomic 16-byte misaligned loads, stores and AMOs)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zawrs)] = .{ + result[@backingInt(Feature.zawrs)] = .{ .llvm_name = "zawrs", .description = "'Zawrs' (Wait on Reservation Set)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zba)] = .{ + result[@backingInt(Feature.zba)] = .{ .llvm_name = "zba", .description = "'Zba' (Address Generation Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zbb)] = .{ + result[@backingInt(Feature.zbb)] = .{ .llvm_name = "zbb", .description = "'Zbb' (Basic Bit-Manipulation)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zbc)] = .{ + result[@backingInt(Feature.zbc)] = .{ .llvm_name = "zbc", .description = "'Zbc' (Carry-Less Multiplication)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zbkb)] = .{ + result[@backingInt(Feature.zbkb)] = .{ .llvm_name = "zbkb", .description = "'Zbkb' (Bitmanip instructions for Cryptography)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zbkc)] = .{ + result[@backingInt(Feature.zbkc)] = .{ .llvm_name = "zbkc", .description = "'Zbkc' (Carry-less multiply instructions for Cryptography)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zbkx)] = .{ + result[@backingInt(Feature.zbkx)] = .{ .llvm_name = "zbkx", .description = "'Zbkx' (Crossbar permutation instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zbs)] = .{ + result[@backingInt(Feature.zbs)] = .{ .llvm_name = "zbs", .description = "'Zbs' (Single-Bit Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zca)] = .{ + result[@backingInt(Feature.zca)] = .{ .llvm_name = "zca", .description = "'Zca' (part of the C extension, excluding compressed floating point loads/stores)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zcb)] = .{ + result[@backingInt(Feature.zcb)] = .{ .llvm_name = "zcb", .description = "'Zcb' (Compressed basic bit manipulation instructions)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.zcd)] = .{ + result[@backingInt(Feature.zcd)] = .{ .llvm_name = "zcd", .description = "'Zcd' (Compressed Double-Precision Floating-Point Instructions)", .dependencies = featureSet(&[_]Feature{ @@ -2111,7 +2111,7 @@ pub const all_features = blk: { .zca, }), }; - result[@intFromEnum(Feature.zce)] = .{ + result[@backingInt(Feature.zce)] = .{ .llvm_name = "zce", .description = "'Zce' (Compressed extensions for microcontrollers)", .dependencies = featureSet(&[_]Feature{ @@ -2120,7 +2120,7 @@ pub const all_features = blk: { .zcmt, }), }; - result[@intFromEnum(Feature.zcf)] = .{ + result[@backingInt(Feature.zcf)] = .{ .llvm_name = "zcf", .description = "'Zcf' (Compressed Single-Precision Floating-Point Instructions)", .dependencies = featureSet(&[_]Feature{ @@ -2128,7 +2128,7 @@ pub const all_features = blk: { .zca, }), }; - result[@intFromEnum(Feature.zclsd)] = .{ + result[@backingInt(Feature.zclsd)] = .{ .llvm_name = "zclsd", .description = "'Zclsd' (Compressed Load/Store Pair Instructions)", .dependencies = featureSet(&[_]Feature{ @@ -2136,21 +2136,21 @@ pub const all_features = blk: { .zilsd, }), }; - result[@intFromEnum(Feature.zcmop)] = .{ + result[@backingInt(Feature.zcmop)] = .{ .llvm_name = "zcmop", .description = "'Zcmop' (Compressed May-Be-Operations)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.zcmp)] = .{ + result[@backingInt(Feature.zcmp)] = .{ .llvm_name = "zcmp", .description = "'Zcmp' (sequenced instructions for code-size reduction)", .dependencies = featureSet(&[_]Feature{ .zca, }), }; - result[@intFromEnum(Feature.zcmt)] = .{ + result[@backingInt(Feature.zcmt)] = .{ .llvm_name = "zcmt", .description = "'Zcmt' (table jump instructions for code-size reduction)", .dependencies = featureSet(&[_]Feature{ @@ -2158,172 +2158,172 @@ pub const all_features = blk: { .zicsr, }), }; - result[@intFromEnum(Feature.zdinx)] = .{ + result[@backingInt(Feature.zdinx)] = .{ .llvm_name = "zdinx", .description = "'Zdinx' (Double in Integer)", .dependencies = featureSet(&[_]Feature{ .zfinx, }), }; - result[@intFromEnum(Feature.zexth_fusion)] = .{ + result[@backingInt(Feature.zexth_fusion)] = .{ .llvm_name = "zexth-fusion", .description = "Enable SLLI+SRLI to be fused to zero extension of halfword", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zextw_fusion)] = .{ + result[@backingInt(Feature.zextw_fusion)] = .{ .llvm_name = "zextw-fusion", .description = "Enable SLLI+SRLI to be fused to zero extension of word", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zfa)] = .{ + result[@backingInt(Feature.zfa)] = .{ .llvm_name = "zfa", .description = "'Zfa' (Additional Floating-Point)", .dependencies = featureSet(&[_]Feature{ .f, }), }; - result[@intFromEnum(Feature.zfbfmin)] = .{ + result[@backingInt(Feature.zfbfmin)] = .{ .llvm_name = "zfbfmin", .description = "'Zfbfmin' (Scalar BF16 Converts)", .dependencies = featureSet(&[_]Feature{ .f, }), }; - result[@intFromEnum(Feature.zfh)] = .{ + result[@backingInt(Feature.zfh)] = .{ .llvm_name = "zfh", .description = "'Zfh' (Half-Precision Floating-Point)", .dependencies = featureSet(&[_]Feature{ .zfhmin, }), }; - result[@intFromEnum(Feature.zfhmin)] = .{ + result[@backingInt(Feature.zfhmin)] = .{ .llvm_name = "zfhmin", .description = "'Zfhmin' (Half-Precision Floating-Point Minimal)", .dependencies = featureSet(&[_]Feature{ .f, }), }; - result[@intFromEnum(Feature.zfinx)] = .{ + result[@backingInt(Feature.zfinx)] = .{ .llvm_name = "zfinx", .description = "'Zfinx' (Float in Integer)", .dependencies = featureSet(&[_]Feature{ .zicsr, }), }; - result[@intFromEnum(Feature.zhinx)] = .{ + result[@backingInt(Feature.zhinx)] = .{ .llvm_name = "zhinx", .description = "'Zhinx' (Half Float in Integer)", .dependencies = featureSet(&[_]Feature{ .zhinxmin, }), }; - result[@intFromEnum(Feature.zhinxmin)] = .{ + result[@backingInt(Feature.zhinxmin)] = .{ .llvm_name = "zhinxmin", .description = "'Zhinxmin' (Half Float in Integer Minimal)", .dependencies = featureSet(&[_]Feature{ .zfinx, }), }; - result[@intFromEnum(Feature.zic64b)] = .{ + result[@backingInt(Feature.zic64b)] = .{ .llvm_name = "zic64b", .description = "'Zic64b' (Cache Block Size Is 64 Bytes)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zicbom)] = .{ + result[@backingInt(Feature.zicbom)] = .{ .llvm_name = "zicbom", .description = "'Zicbom' (Cache-Block Management Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zicbop)] = .{ + result[@backingInt(Feature.zicbop)] = .{ .llvm_name = "zicbop", .description = "'Zicbop' (Cache-Block Prefetch Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zicboz)] = .{ + result[@backingInt(Feature.zicboz)] = .{ .llvm_name = "zicboz", .description = "'Zicboz' (Cache-Block Zero Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ziccamoa)] = .{ + result[@backingInt(Feature.ziccamoa)] = .{ .llvm_name = "ziccamoa", .description = "'Ziccamoa' (Main Memory Supports All Atomics in A)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ziccamoc)] = .{ + result[@backingInt(Feature.ziccamoc)] = .{ .llvm_name = "ziccamoc", .description = "'Ziccamoc' (Main Memory Supports Atomics in Zacas)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ziccif)] = .{ + result[@backingInt(Feature.ziccif)] = .{ .llvm_name = "ziccif", .description = "'Ziccif' (Main Memory Supports Instruction Fetch with Atomicity Requirement)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zicclsm)] = .{ + result[@backingInt(Feature.zicclsm)] = .{ .llvm_name = "zicclsm", .description = "'Zicclsm' (Main Memory Supports Misaligned Loads/Stores)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ziccrse)] = .{ + result[@backingInt(Feature.ziccrse)] = .{ .llvm_name = "ziccrse", .description = "'Ziccrse' (Main Memory Supports Forward Progress on LR/SC Sequences)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zicntr)] = .{ + result[@backingInt(Feature.zicntr)] = .{ .llvm_name = "zicntr", .description = "'Zicntr' (Base Counters and Timers)", .dependencies = featureSet(&[_]Feature{ .zicsr, }), }; - result[@intFromEnum(Feature.zicond)] = .{ + result[@backingInt(Feature.zicond)] = .{ .llvm_name = "zicond", .description = "'Zicond' (Integer Conditional Operations)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zicsr)] = .{ + result[@backingInt(Feature.zicsr)] = .{ .llvm_name = "zicsr", .description = "'Zicsr' (CSRs)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zifencei)] = .{ + result[@backingInt(Feature.zifencei)] = .{ .llvm_name = "zifencei", .description = "'Zifencei' (fence.i)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zihintntl)] = .{ + result[@backingInt(Feature.zihintntl)] = .{ .llvm_name = "zihintntl", .description = "'Zihintntl' (Non-Temporal Locality Hints)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zihintpause)] = .{ + result[@backingInt(Feature.zihintpause)] = .{ .llvm_name = "zihintpause", .description = "'Zihintpause' (Pause Hint)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zihpm)] = .{ + result[@backingInt(Feature.zihpm)] = .{ .llvm_name = "zihpm", .description = "'Zihpm' (Hardware Performance Counters)", .dependencies = featureSet(&[_]Feature{ .zicsr, }), }; - result[@intFromEnum(Feature.zilsd)] = .{ + result[@backingInt(Feature.zilsd)] = .{ .llvm_name = "zilsd", .description = "'Zilsd' (Load/Store Pair Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zilsd_4byte_align)] = .{ + result[@backingInt(Feature.zilsd_4byte_align)] = .{ .llvm_name = "zilsd-4byte-align", .description = "Allow 4-byte alignment for Zilsd LD/SD instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zimop)] = .{ + result[@backingInt(Feature.zimop)] = .{ .llvm_name = "zimop", .description = "'Zimop' (May-Be-Operations)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zk)] = .{ + result[@backingInt(Feature.zk)] = .{ .llvm_name = "zk", .description = "'Zk' (Standard scalar cryptography extension)", .dependencies = featureSet(&[_]Feature{ @@ -2332,7 +2332,7 @@ pub const all_features = blk: { .zkt, }), }; - result[@intFromEnum(Feature.zkn)] = .{ + result[@backingInt(Feature.zkn)] = .{ .llvm_name = "zkn", .description = "'Zkn' (NIST Algorithm Suite)", .dependencies = featureSet(&[_]Feature{ @@ -2344,27 +2344,27 @@ pub const all_features = blk: { .zknh, }), }; - result[@intFromEnum(Feature.zknd)] = .{ + result[@backingInt(Feature.zknd)] = .{ .llvm_name = "zknd", .description = "'Zknd' (NIST Suite: AES Decryption)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zkne)] = .{ + result[@backingInt(Feature.zkne)] = .{ .llvm_name = "zkne", .description = "'Zkne' (NIST Suite: AES Encryption)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zknh)] = .{ + result[@backingInt(Feature.zknh)] = .{ .llvm_name = "zknh", .description = "'Zknh' (NIST Suite: Hash Function Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zkr)] = .{ + result[@backingInt(Feature.zkr)] = .{ .llvm_name = "zkr", .description = "'Zkr' (Entropy Source Extension)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zks)] = .{ + result[@backingInt(Feature.zks)] = .{ .llvm_name = "zks", .description = "'Zks' (ShangMi Algorithm Suite)", .dependencies = featureSet(&[_]Feature{ @@ -2375,46 +2375,46 @@ pub const all_features = blk: { .zksh, }), }; - result[@intFromEnum(Feature.zksed)] = .{ + result[@backingInt(Feature.zksed)] = .{ .llvm_name = "zksed", .description = "'Zksed' (ShangMi Suite: SM4 Block Cipher Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zksh)] = .{ + result[@backingInt(Feature.zksh)] = .{ .llvm_name = "zksh", .description = "'Zksh' (ShangMi Suite: SM3 Hash Function Instructions)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zkt)] = .{ + result[@backingInt(Feature.zkt)] = .{ .llvm_name = "zkt", .description = "'Zkt' (Data Independent Execution Latency)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zmmul)] = .{ + result[@backingInt(Feature.zmmul)] = .{ .llvm_name = "zmmul", .description = "'Zmmul' (Integer Multiplication)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ztso)] = .{ + result[@backingInt(Feature.ztso)] = .{ .llvm_name = "ztso", .description = "'Ztso' (Memory Model - Total Store Order)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zvbb)] = .{ + result[@backingInt(Feature.zvbb)] = .{ .llvm_name = "zvbb", .description = "'Zvbb' (Vector basic bit-manipulation instructions)", .dependencies = featureSet(&[_]Feature{ .zvkb, }), }; - result[@intFromEnum(Feature.zvbc)] = .{ + result[@backingInt(Feature.zvbc)] = .{ .llvm_name = "zvbc", .description = "'Zvbc' (Vector Carryless Multiplication)", .dependencies = featureSet(&[_]Feature{ .zve64x, }), }; - result[@intFromEnum(Feature.zve32f)] = .{ + result[@backingInt(Feature.zve32f)] = .{ .llvm_name = "zve32f", .description = "'Zve32f' (Vector Extensions for Embedded Processors with maximal 32 EEW and F extension)", .dependencies = featureSet(&[_]Feature{ @@ -2422,7 +2422,7 @@ pub const all_features = blk: { .zve32x, }), }; - result[@intFromEnum(Feature.zve32x)] = .{ + result[@backingInt(Feature.zve32x)] = .{ .llvm_name = "zve32x", .description = "'Zve32x' (Vector Extensions for Embedded Processors with maximal 32 EEW)", .dependencies = featureSet(&[_]Feature{ @@ -2430,7 +2430,7 @@ pub const all_features = blk: { .zvl32b, }), }; - result[@intFromEnum(Feature.zve64d)] = .{ + result[@backingInt(Feature.zve64d)] = .{ .llvm_name = "zve64d", .description = "'Zve64d' (Vector Extensions for Embedded Processors with maximal 64 EEW, F and D extension)", .dependencies = featureSet(&[_]Feature{ @@ -2438,7 +2438,7 @@ pub const all_features = blk: { .zve64f, }), }; - result[@intFromEnum(Feature.zve64f)] = .{ + result[@backingInt(Feature.zve64f)] = .{ .llvm_name = "zve64f", .description = "'Zve64f' (Vector Extensions for Embedded Processors with maximal 64 EEW and F extension)", .dependencies = featureSet(&[_]Feature{ @@ -2446,7 +2446,7 @@ pub const all_features = blk: { .zve64x, }), }; - result[@intFromEnum(Feature.zve64x)] = .{ + result[@backingInt(Feature.zve64x)] = .{ .llvm_name = "zve64x", .description = "'Zve64x' (Vector Extensions for Embedded Processors with maximal 64 EEW)", .dependencies = featureSet(&[_]Feature{ @@ -2454,14 +2454,14 @@ pub const all_features = blk: { .zvl64b, }), }; - result[@intFromEnum(Feature.zvfbfmin)] = .{ + result[@backingInt(Feature.zvfbfmin)] = .{ .llvm_name = "zvfbfmin", .description = "'Zvfbfmin' (Vector BF16 Converts)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.zvfbfwma)] = .{ + result[@backingInt(Feature.zvfbfwma)] = .{ .llvm_name = "zvfbfwma", .description = "'Zvfbfwma' (Vector BF16 widening mul-add)", .dependencies = featureSet(&[_]Feature{ @@ -2469,7 +2469,7 @@ pub const all_features = blk: { .zvfbfmin, }), }; - result[@intFromEnum(Feature.zvfh)] = .{ + result[@backingInt(Feature.zvfh)] = .{ .llvm_name = "zvfh", .description = "'Zvfh' (Vector Half-Precision Floating-Point)", .dependencies = featureSet(&[_]Feature{ @@ -2477,28 +2477,28 @@ pub const all_features = blk: { .zvfhmin, }), }; - result[@intFromEnum(Feature.zvfhmin)] = .{ + result[@backingInt(Feature.zvfhmin)] = .{ .llvm_name = "zvfhmin", .description = "'Zvfhmin' (Vector Half-Precision Floating-Point Minimal)", .dependencies = featureSet(&[_]Feature{ .zve32f, }), }; - result[@intFromEnum(Feature.zvkb)] = .{ + result[@backingInt(Feature.zvkb)] = .{ .llvm_name = "zvkb", .description = "'Zvkb' (Vector Bit-manipulation used in Cryptography)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.zvkg)] = .{ + result[@backingInt(Feature.zvkg)] = .{ .llvm_name = "zvkg", .description = "'Zvkg' (Vector GCM instructions for Cryptography)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.zvkn)] = .{ + result[@backingInt(Feature.zvkn)] = .{ .llvm_name = "zvkn", .description = "'Zvkn' (shorthand for 'Zvkned', 'Zvknhb', 'Zvkb', and 'Zvkt')", .dependencies = featureSet(&[_]Feature{ @@ -2508,7 +2508,7 @@ pub const all_features = blk: { .zvkt, }), }; - result[@intFromEnum(Feature.zvknc)] = .{ + result[@backingInt(Feature.zvknc)] = .{ .llvm_name = "zvknc", .description = "'Zvknc' (shorthand for 'Zvknc' and 'Zvbc')", .dependencies = featureSet(&[_]Feature{ @@ -2516,14 +2516,14 @@ pub const all_features = blk: { .zvkn, }), }; - result[@intFromEnum(Feature.zvkned)] = .{ + result[@backingInt(Feature.zvkned)] = .{ .llvm_name = "zvkned", .description = "'Zvkned' (Vector AES Encryption & Decryption (Single Round))", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.zvkng)] = .{ + result[@backingInt(Feature.zvkng)] = .{ .llvm_name = "zvkng", .description = "'Zvkng' (shorthand for 'Zvkn' and 'Zvkg')", .dependencies = featureSet(&[_]Feature{ @@ -2531,21 +2531,21 @@ pub const all_features = blk: { .zvkn, }), }; - result[@intFromEnum(Feature.zvknha)] = .{ + result[@backingInt(Feature.zvknha)] = .{ .llvm_name = "zvknha", .description = "'Zvknha' (Vector SHA-2 (SHA-256 only))", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.zvknhb)] = .{ + result[@backingInt(Feature.zvknhb)] = .{ .llvm_name = "zvknhb", .description = "'Zvknhb' (Vector SHA-2 (SHA-256 and SHA-512))", .dependencies = featureSet(&[_]Feature{ .zve64x, }), }; - result[@intFromEnum(Feature.zvks)] = .{ + result[@backingInt(Feature.zvks)] = .{ .llvm_name = "zvks", .description = "'Zvks' (shorthand for 'Zvksed', 'Zvksh', 'Zvkb', and 'Zvkt')", .dependencies = featureSet(&[_]Feature{ @@ -2555,7 +2555,7 @@ pub const all_features = blk: { .zvkt, }), }; - result[@intFromEnum(Feature.zvksc)] = .{ + result[@backingInt(Feature.zvksc)] = .{ .llvm_name = "zvksc", .description = "'Zvksc' (shorthand for 'Zvks' and 'Zvbc')", .dependencies = featureSet(&[_]Feature{ @@ -2563,14 +2563,14 @@ pub const all_features = blk: { .zvks, }), }; - result[@intFromEnum(Feature.zvksed)] = .{ + result[@backingInt(Feature.zvksed)] = .{ .llvm_name = "zvksed", .description = "'Zvksed' (SM4 Block Cipher Instructions)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.zvksg)] = .{ + result[@backingInt(Feature.zvksg)] = .{ .llvm_name = "zvksg", .description = "'Zvksg' (shorthand for 'Zvks' and 'Zvkg')", .dependencies = featureSet(&[_]Feature{ @@ -2578,94 +2578,94 @@ pub const all_features = blk: { .zvks, }), }; - result[@intFromEnum(Feature.zvksh)] = .{ + result[@backingInt(Feature.zvksh)] = .{ .llvm_name = "zvksh", .description = "'Zvksh' (SM3 Hash Function Instructions)", .dependencies = featureSet(&[_]Feature{ .zve32x, }), }; - result[@intFromEnum(Feature.zvkt)] = .{ + result[@backingInt(Feature.zvkt)] = .{ .llvm_name = "zvkt", .description = "'Zvkt' (Vector Data-Independent Execution Latency)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zvl1024b)] = .{ + result[@backingInt(Feature.zvl1024b)] = .{ .llvm_name = "zvl1024b", .description = "'Zvl1024b' (Minimum Vector Length 1024)", .dependencies = featureSet(&[_]Feature{ .zvl512b, }), }; - result[@intFromEnum(Feature.zvl128b)] = .{ + result[@backingInt(Feature.zvl128b)] = .{ .llvm_name = "zvl128b", .description = "'Zvl128b' (Minimum Vector Length 128)", .dependencies = featureSet(&[_]Feature{ .zvl64b, }), }; - result[@intFromEnum(Feature.zvl16384b)] = .{ + result[@backingInt(Feature.zvl16384b)] = .{ .llvm_name = "zvl16384b", .description = "'Zvl16384b' (Minimum Vector Length 16384)", .dependencies = featureSet(&[_]Feature{ .zvl8192b, }), }; - result[@intFromEnum(Feature.zvl2048b)] = .{ + result[@backingInt(Feature.zvl2048b)] = .{ .llvm_name = "zvl2048b", .description = "'Zvl2048b' (Minimum Vector Length 2048)", .dependencies = featureSet(&[_]Feature{ .zvl1024b, }), }; - result[@intFromEnum(Feature.zvl256b)] = .{ + result[@backingInt(Feature.zvl256b)] = .{ .llvm_name = "zvl256b", .description = "'Zvl256b' (Minimum Vector Length 256)", .dependencies = featureSet(&[_]Feature{ .zvl128b, }), }; - result[@intFromEnum(Feature.zvl32768b)] = .{ + result[@backingInt(Feature.zvl32768b)] = .{ .llvm_name = "zvl32768b", .description = "'Zvl32768b' (Minimum Vector Length 32768)", .dependencies = featureSet(&[_]Feature{ .zvl16384b, }), }; - result[@intFromEnum(Feature.zvl32b)] = .{ + result[@backingInt(Feature.zvl32b)] = .{ .llvm_name = "zvl32b", .description = "'Zvl32b' (Minimum Vector Length 32)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.zvl4096b)] = .{ + result[@backingInt(Feature.zvl4096b)] = .{ .llvm_name = "zvl4096b", .description = "'Zvl4096b' (Minimum Vector Length 4096)", .dependencies = featureSet(&[_]Feature{ .zvl2048b, }), }; - result[@intFromEnum(Feature.zvl512b)] = .{ + result[@backingInt(Feature.zvl512b)] = .{ .llvm_name = "zvl512b", .description = "'Zvl512b' (Minimum Vector Length 512)", .dependencies = featureSet(&[_]Feature{ .zvl256b, }), }; - result[@intFromEnum(Feature.zvl64b)] = .{ + result[@backingInt(Feature.zvl64b)] = .{ .llvm_name = "zvl64b", .description = "'Zvl64b' (Minimum Vector Length 64)", .dependencies = featureSet(&[_]Feature{ .zvl32b, }), }; - result[@intFromEnum(Feature.zvl65536b)] = .{ + result[@backingInt(Feature.zvl65536b)] = .{ .llvm_name = "zvl65536b", .description = "'Zvl65536b' (Minimum Vector Length 65536)", .dependencies = featureSet(&[_]Feature{ .zvl32768b, }), }; - result[@intFromEnum(Feature.zvl8192b)] = .{ + result[@backingInt(Feature.zvl8192b)] = .{ .llvm_name = "zvl8192b", .description = "'Zvl8192b' (Minimum Vector Length 8192)", .dependencies = featureSet(&[_]Feature{ diff --git a/lib/std/Target/s390x.zig b/lib/std/Target/s390x.zig index 086e427075778200e25863dda162d4b4699714e0..5607f0362e0830bb5db5eb7c8d3237fe4728409b 100644 --- a/lib/std/Target/s390x.zig +++ b/lib/std/Target/s390x.zig @@ -65,247 +65,247 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.backchain)] = .{ + result[@backingInt(Feature.backchain)] = .{ .llvm_name = "backchain", .description = "Store the address of the caller's frame into the callee's stack frame", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bear_enhancement)] = .{ + result[@backingInt(Feature.bear_enhancement)] = .{ .llvm_name = "bear-enhancement", .description = "Assume that the BEAR-enhancement facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.concurrent_functions)] = .{ + result[@backingInt(Feature.concurrent_functions)] = .{ .llvm_name = "concurrent-functions", .description = "Assume that the concurrent-functions facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.deflate_conversion)] = .{ + result[@backingInt(Feature.deflate_conversion)] = .{ .llvm_name = "deflate-conversion", .description = "Assume that the deflate-conversion facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dfp_packed_conversion)] = .{ + result[@backingInt(Feature.dfp_packed_conversion)] = .{ .llvm_name = "dfp-packed-conversion", .description = "Assume that the DFP packed-conversion facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dfp_zoned_conversion)] = .{ + result[@backingInt(Feature.dfp_zoned_conversion)] = .{ .llvm_name = "dfp-zoned-conversion", .description = "Assume that the DFP zoned-conversion facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.distinct_ops)] = .{ + result[@backingInt(Feature.distinct_ops)] = .{ .llvm_name = "distinct-ops", .description = "Assume that the distinct-operands facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.enhanced_dat_2)] = .{ + result[@backingInt(Feature.enhanced_dat_2)] = .{ .llvm_name = "enhanced-dat-2", .description = "Assume that the enhanced-DAT facility 2 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.enhanced_sort)] = .{ + result[@backingInt(Feature.enhanced_sort)] = .{ .llvm_name = "enhanced-sort", .description = "Assume that the enhanced-sort facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.execution_hint)] = .{ + result[@backingInt(Feature.execution_hint)] = .{ .llvm_name = "execution-hint", .description = "Assume that the execution-hint facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_serialization)] = .{ + result[@backingInt(Feature.fast_serialization)] = .{ .llvm_name = "fast-serialization", .description = "Assume that the fast-serialization facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp_extension)] = .{ + result[@backingInt(Feature.fp_extension)] = .{ .llvm_name = "fp-extension", .description = "Assume that the floating-point extension facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.guarded_storage)] = .{ + result[@backingInt(Feature.guarded_storage)] = .{ .llvm_name = "guarded-storage", .description = "Assume that the guarded-storage facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.high_word)] = .{ + result[@backingInt(Feature.high_word)] = .{ .llvm_name = "high-word", .description = "Assume that the high-word facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.insert_reference_bits_multiple)] = .{ + result[@backingInt(Feature.insert_reference_bits_multiple)] = .{ .llvm_name = "insert-reference-bits-multiple", .description = "Assume that the insert-reference-bits-multiple facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.interlocked_access1)] = .{ + result[@backingInt(Feature.interlocked_access1)] = .{ .llvm_name = "interlocked-access1", .description = "Assume that interlocked-access facility 1 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.load_and_trap)] = .{ + result[@backingInt(Feature.load_and_trap)] = .{ .llvm_name = "load-and-trap", .description = "Assume that the load-and-trap facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.load_and_zero_rightmost_byte)] = .{ + result[@backingInt(Feature.load_and_zero_rightmost_byte)] = .{ .llvm_name = "load-and-zero-rightmost-byte", .description = "Assume that the load-and-zero-rightmost-byte facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.load_store_on_cond)] = .{ + result[@backingInt(Feature.load_store_on_cond)] = .{ .llvm_name = "load-store-on-cond", .description = "Assume that the load/store-on-condition facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.load_store_on_cond_2)] = .{ + result[@backingInt(Feature.load_store_on_cond_2)] = .{ .llvm_name = "load-store-on-cond-2", .description = "Assume that the load/store-on-condition facility 2 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.message_security_assist_extension12)] = .{ + result[@backingInt(Feature.message_security_assist_extension12)] = .{ .llvm_name = "message-security-assist-extension12", .description = "Assume that the message-security-assist extension facility 12 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.message_security_assist_extension3)] = .{ + result[@backingInt(Feature.message_security_assist_extension3)] = .{ .llvm_name = "message-security-assist-extension3", .description = "Assume that the message-security-assist extension facility 3 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.message_security_assist_extension4)] = .{ + result[@backingInt(Feature.message_security_assist_extension4)] = .{ .llvm_name = "message-security-assist-extension4", .description = "Assume that the message-security-assist extension facility 4 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.message_security_assist_extension5)] = .{ + result[@backingInt(Feature.message_security_assist_extension5)] = .{ .llvm_name = "message-security-assist-extension5", .description = "Assume that the message-security-assist extension facility 5 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.message_security_assist_extension7)] = .{ + result[@backingInt(Feature.message_security_assist_extension7)] = .{ .llvm_name = "message-security-assist-extension7", .description = "Assume that the message-security-assist extension facility 7 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.message_security_assist_extension8)] = .{ + result[@backingInt(Feature.message_security_assist_extension8)] = .{ .llvm_name = "message-security-assist-extension8", .description = "Assume that the message-security-assist extension facility 8 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.message_security_assist_extension9)] = .{ + result[@backingInt(Feature.message_security_assist_extension9)] = .{ .llvm_name = "message-security-assist-extension9", .description = "Assume that the message-security-assist extension facility 9 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.miscellaneous_extensions)] = .{ + result[@backingInt(Feature.miscellaneous_extensions)] = .{ .llvm_name = "miscellaneous-extensions", .description = "Assume that the miscellaneous-extensions facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.miscellaneous_extensions_2)] = .{ + result[@backingInt(Feature.miscellaneous_extensions_2)] = .{ .llvm_name = "miscellaneous-extensions-2", .description = "Assume that the miscellaneous-extensions facility 2 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.miscellaneous_extensions_3)] = .{ + result[@backingInt(Feature.miscellaneous_extensions_3)] = .{ .llvm_name = "miscellaneous-extensions-3", .description = "Assume that the miscellaneous-extensions facility 3 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.miscellaneous_extensions_4)] = .{ + result[@backingInt(Feature.miscellaneous_extensions_4)] = .{ .llvm_name = "miscellaneous-extensions-4", .description = "Assume that the miscellaneous-extensions facility 4 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nnp_assist)] = .{ + result[@backingInt(Feature.nnp_assist)] = .{ .llvm_name = "nnp-assist", .description = "Assume that the NNP-assist facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.population_count)] = .{ + result[@backingInt(Feature.population_count)] = .{ .llvm_name = "population-count", .description = "Assume that the population-count facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.processor_activity_instrumentation)] = .{ + result[@backingInt(Feature.processor_activity_instrumentation)] = .{ .llvm_name = "processor-activity-instrumentation", .description = "Assume that the processor-activity-instrumentation facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.processor_assist)] = .{ + result[@backingInt(Feature.processor_assist)] = .{ .llvm_name = "processor-assist", .description = "Assume that the processor-assist facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reset_dat_protection)] = .{ + result[@backingInt(Feature.reset_dat_protection)] = .{ .llvm_name = "reset-dat-protection", .description = "Assume that the reset-DAT-protection facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reset_reference_bits_multiple)] = .{ + result[@backingInt(Feature.reset_reference_bits_multiple)] = .{ .llvm_name = "reset-reference-bits-multiple", .description = "Assume that the reset-reference-bits-multiple facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.soft_float)] = .{ + result[@backingInt(Feature.soft_float)] = .{ .llvm_name = "soft-float", .description = "Use software emulation for floating point", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.test_pending_external_interruption)] = .{ + result[@backingInt(Feature.test_pending_external_interruption)] = .{ .llvm_name = "test-pending-external-interruption", .description = "Assume that the test-pending-external-interruption facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.transactional_execution)] = .{ + result[@backingInt(Feature.transactional_execution)] = .{ .llvm_name = "transactional-execution", .description = "Assume that the transactional-execution facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.unaligned_symbols)] = .{ + result[@backingInt(Feature.unaligned_symbols)] = .{ .llvm_name = "unaligned-symbols", .description = "Don't apply the ABI minimum alignment to external symbols.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector)] = .{ + result[@backingInt(Feature.vector)] = .{ .llvm_name = "vector", .description = "Assume that the vectory facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector_enhancements_1)] = .{ + result[@backingInt(Feature.vector_enhancements_1)] = .{ .llvm_name = "vector-enhancements-1", .description = "Assume that the vector enhancements facility 1 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector_enhancements_2)] = .{ + result[@backingInt(Feature.vector_enhancements_2)] = .{ .llvm_name = "vector-enhancements-2", .description = "Assume that the vector enhancements facility 2 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector_enhancements_3)] = .{ + result[@backingInt(Feature.vector_enhancements_3)] = .{ .llvm_name = "vector-enhancements-3", .description = "Assume that the vector enhancements facility 3 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector_packed_decimal)] = .{ + result[@backingInt(Feature.vector_packed_decimal)] = .{ .llvm_name = "vector-packed-decimal", .description = "Assume that the vector packed decimal facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector_packed_decimal_enhancement)] = .{ + result[@backingInt(Feature.vector_packed_decimal_enhancement)] = .{ .llvm_name = "vector-packed-decimal-enhancement", .description = "Assume that the vector packed decimal enhancement facility is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector_packed_decimal_enhancement_2)] = .{ + result[@backingInt(Feature.vector_packed_decimal_enhancement_2)] = .{ .llvm_name = "vector-packed-decimal-enhancement-2", .description = "Assume that the vector packed decimal enhancement facility 2 is installed", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vector_packed_decimal_enhancement_3)] = .{ + result[@backingInt(Feature.vector_packed_decimal_enhancement_3)] = .{ .llvm_name = "vector-packed-decimal-enhancement-3", .description = "Assume that the vector packed decimal enhancement facility 3 is installed", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/sparc.zig b/lib/std/Target/sparc.zig index c5d1d246157fcde19d233df30772f0077091880b..11080ecb6a8fbe3891a0997aa963ced516e00861 100644 --- a/lib/std/Target/sparc.zig +++ b/lib/std/Target/sparc.zig @@ -75,111 +75,111 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"64bit")] = .{ + result[@backingInt(Feature.@"64bit")] = .{ .llvm_name = "64bit", .description = "Enable 64-bit mode", .dependencies = featureSet(&[_]Feature{ .v9, }), }; - result[@intFromEnum(Feature.crypto)] = .{ + result[@backingInt(Feature.crypto)] = .{ .llvm_name = "crypto", .description = "Enable cryptographic extensions", .dependencies = featureSet(&[_]Feature{ .osa2011, }), }; - result[@intFromEnum(Feature.deprecated_v8)] = .{ + result[@backingInt(Feature.deprecated_v8)] = .{ .llvm_name = "deprecated-v8", .description = "Enable deprecated V8 instructions in V9 mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.detectroundchange)] = .{ + result[@backingInt(Feature.detectroundchange)] = .{ .llvm_name = "detectroundchange", .description = "LEON3 erratum detection: Detects any rounding mode change request: use only the round-to-nearest rounding mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_tn0009)] = .{ + result[@backingInt(Feature.fix_tn0009)] = .{ .llvm_name = "fix-tn0009", .description = "Enable workaround for errata described in GRLIB-TN-0009", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_tn0010)] = .{ + result[@backingInt(Feature.fix_tn0010)] = .{ .llvm_name = "fix-tn0010", .description = "Enable workaround for errata described in GRLIB-TN-0010", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_tn0011)] = .{ + result[@backingInt(Feature.fix_tn0011)] = .{ .llvm_name = "fix-tn0011", .description = "Enable workaround for errata described in GRLIB-TN-0011", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_tn0012)] = .{ + result[@backingInt(Feature.fix_tn0012)] = .{ .llvm_name = "fix-tn0012", .description = "Enable workaround for errata described in GRLIB-TN-0012", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fix_tn0013)] = .{ + result[@backingInt(Feature.fix_tn0013)] = .{ .llvm_name = "fix-tn0013", .description = "Enable workaround for errata described in GRLIB-TN-0013", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fixallfdivsqrt)] = .{ + result[@backingInt(Feature.fixallfdivsqrt)] = .{ .llvm_name = "fixallfdivsqrt", .description = "LEON erratum fix: Fix FDIVS/FDIVD/FSQRTS/FSQRTD instructions with NOPs and floating-point store", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hard_quad_float)] = .{ + result[@backingInt(Feature.hard_quad_float)] = .{ .llvm_name = "hard-quad-float", .description = "Enable quad-word floating point instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hasleoncasa)] = .{ + result[@backingInt(Feature.hasleoncasa)] = .{ .llvm_name = "hasleoncasa", .description = "Enable CASA instruction for LEON3 and LEON4 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hasumacsmac)] = .{ + result[@backingInt(Feature.hasumacsmac)] = .{ .llvm_name = "hasumacsmac", .description = "Enable UMAC and SMAC for LEON3 and LEON4 processors", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.insertnopload)] = .{ + result[@backingInt(Feature.insertnopload)] = .{ .llvm_name = "insertnopload", .description = "LEON3 erratum fix: Insert a NOP instruction after every single-cycle load instruction when the next instruction is another load/store instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.leon)] = .{ + result[@backingInt(Feature.leon)] = .{ .llvm_name = "leon", .description = "Enable LEON extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.leoncyclecounter)] = .{ + result[@backingInt(Feature.leoncyclecounter)] = .{ .llvm_name = "leoncyclecounter", .description = "Use the Leon cycle counter register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.leonpwrpsr)] = .{ + result[@backingInt(Feature.leonpwrpsr)] = .{ .llvm_name = "leonpwrpsr", .description = "Enable the PWRPSR instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_fmuls)] = .{ + result[@backingInt(Feature.no_fmuls)] = .{ .llvm_name = "no-fmuls", .description = "Disable the fmuls instruction.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_fsmuld)] = .{ + result[@backingInt(Feature.no_fsmuld)] = .{ .llvm_name = "no-fsmuld", .description = "Disable the fsmuld instruction.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_predictor)] = .{ + result[@backingInt(Feature.no_predictor)] = .{ .llvm_name = "no-predictor", .description = "Processor has no branch predictor, branches stall execution", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.osa2011)] = .{ + result[@backingInt(Feature.osa2011)] = .{ .llvm_name = "osa2011", .description = "Enable Oracle SPARC Architecture 2011 extensions", .dependencies = featureSet(&[_]Feature{ @@ -188,164 +188,164 @@ pub const all_features = blk: { .vis3, }), }; - result[@intFromEnum(Feature.popc)] = .{ + result[@backingInt(Feature.popc)] = .{ .llvm_name = "popc", .description = "Use the popc (population count) instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_g1)] = .{ + result[@backingInt(Feature.reserve_g1)] = .{ .llvm_name = "reserve-g1", .description = "Reserve G1, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_g2)] = .{ + result[@backingInt(Feature.reserve_g2)] = .{ .llvm_name = "reserve-g2", .description = "Reserve G2, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_g3)] = .{ + result[@backingInt(Feature.reserve_g3)] = .{ .llvm_name = "reserve-g3", .description = "Reserve G3, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_g4)] = .{ + result[@backingInt(Feature.reserve_g4)] = .{ .llvm_name = "reserve-g4", .description = "Reserve G4, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_g5)] = .{ + result[@backingInt(Feature.reserve_g5)] = .{ .llvm_name = "reserve-g5", .description = "Reserve G5, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_g6)] = .{ + result[@backingInt(Feature.reserve_g6)] = .{ .llvm_name = "reserve-g6", .description = "Reserve G6, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_g7)] = .{ + result[@backingInt(Feature.reserve_g7)] = .{ .llvm_name = "reserve-g7", .description = "Reserve G7, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_i0)] = .{ + result[@backingInt(Feature.reserve_i0)] = .{ .llvm_name = "reserve-i0", .description = "Reserve I0, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_i1)] = .{ + result[@backingInt(Feature.reserve_i1)] = .{ .llvm_name = "reserve-i1", .description = "Reserve I1, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_i2)] = .{ + result[@backingInt(Feature.reserve_i2)] = .{ .llvm_name = "reserve-i2", .description = "Reserve I2, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_i3)] = .{ + result[@backingInt(Feature.reserve_i3)] = .{ .llvm_name = "reserve-i3", .description = "Reserve I3, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_i4)] = .{ + result[@backingInt(Feature.reserve_i4)] = .{ .llvm_name = "reserve-i4", .description = "Reserve I4, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_i5)] = .{ + result[@backingInt(Feature.reserve_i5)] = .{ .llvm_name = "reserve-i5", .description = "Reserve I5, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l0)] = .{ + result[@backingInt(Feature.reserve_l0)] = .{ .llvm_name = "reserve-l0", .description = "Reserve L0, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l1)] = .{ + result[@backingInt(Feature.reserve_l1)] = .{ .llvm_name = "reserve-l1", .description = "Reserve L1, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l2)] = .{ + result[@backingInt(Feature.reserve_l2)] = .{ .llvm_name = "reserve-l2", .description = "Reserve L2, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l3)] = .{ + result[@backingInt(Feature.reserve_l3)] = .{ .llvm_name = "reserve-l3", .description = "Reserve L3, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l4)] = .{ + result[@backingInt(Feature.reserve_l4)] = .{ .llvm_name = "reserve-l4", .description = "Reserve L4, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l5)] = .{ + result[@backingInt(Feature.reserve_l5)] = .{ .llvm_name = "reserve-l5", .description = "Reserve L5, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l6)] = .{ + result[@backingInt(Feature.reserve_l6)] = .{ .llvm_name = "reserve-l6", .description = "Reserve L6, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_l7)] = .{ + result[@backingInt(Feature.reserve_l7)] = .{ .llvm_name = "reserve-l7", .description = "Reserve L7, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_o0)] = .{ + result[@backingInt(Feature.reserve_o0)] = .{ .llvm_name = "reserve-o0", .description = "Reserve O0, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_o1)] = .{ + result[@backingInt(Feature.reserve_o1)] = .{ .llvm_name = "reserve-o1", .description = "Reserve O1, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_o2)] = .{ + result[@backingInt(Feature.reserve_o2)] = .{ .llvm_name = "reserve-o2", .description = "Reserve O2, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_o3)] = .{ + result[@backingInt(Feature.reserve_o3)] = .{ .llvm_name = "reserve-o3", .description = "Reserve O3, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_o4)] = .{ + result[@backingInt(Feature.reserve_o4)] = .{ .llvm_name = "reserve-o4", .description = "Reserve O4, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reserve_o5)] = .{ + result[@backingInt(Feature.reserve_o5)] = .{ .llvm_name = "reserve-o5", .description = "Reserve O5, making it unavailable as a GPR", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_rdpc)] = .{ + result[@backingInt(Feature.slow_rdpc)] = .{ .llvm_name = "slow-rdpc", .description = "rd %pc, %XX is slow", .dependencies = featureSet(&[_]Feature{ .v9, }), }; - result[@intFromEnum(Feature.soft_float)] = .{ + result[@backingInt(Feature.soft_float)] = .{ .llvm_name = "soft-float", .description = "Use software emulation for floating point", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.soft_mul_div)] = .{ + result[@backingInt(Feature.soft_mul_div)] = .{ .llvm_name = "soft-mul-div", .description = "Use software emulation for integer multiply and divide", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ua2005)] = .{ + result[@backingInt(Feature.ua2005)] = .{ .llvm_name = "ua2005", .description = "Enable UltraSPARC Architecture 2005 extensions", .dependencies = featureSet(&[_]Feature{ @@ -353,7 +353,7 @@ pub const all_features = blk: { .vis2, }), }; - result[@intFromEnum(Feature.ua2007)] = .{ + result[@backingInt(Feature.ua2007)] = .{ .llvm_name = "ua2007", .description = "Enable UltraSPARC Architecture 2007 extensions", .dependencies = featureSet(&[_]Feature{ @@ -361,31 +361,31 @@ pub const all_features = blk: { .vis2, }), }; - result[@intFromEnum(Feature.v8plus)] = .{ + result[@backingInt(Feature.v8plus)] = .{ .llvm_name = "v8plus", .description = "Enable V8+ mode, allowing use of 64-bit V9 instructions in 32-bit code", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v9)] = .{ + result[@backingInt(Feature.v9)] = .{ .llvm_name = "v9", .description = "Enable SPARC-V9 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vis)] = .{ + result[@backingInt(Feature.vis)] = .{ .llvm_name = "vis", .description = "Enable UltraSPARC Visual Instruction Set extensions", .dependencies = featureSet(&[_]Feature{ .v9, }), }; - result[@intFromEnum(Feature.vis2)] = .{ + result[@backingInt(Feature.vis2)] = .{ .llvm_name = "vis2", .description = "Enable Visual Instruction Set extensions II", .dependencies = featureSet(&[_]Feature{ .v9, }), }; - result[@intFromEnum(Feature.vis3)] = .{ + result[@backingInt(Feature.vis3)] = .{ .llvm_name = "vis3", .description = "Enable Visual Instruction Set extensions III", .dependencies = featureSet(&[_]Feature{ diff --git a/lib/std/Target/spirv.zig b/lib/std/Target/spirv.zig index c988b645b8fc697e73c111cae74989303c8e5c53..29f40003e90d8e3e8bab8e10e95845b2104513f2 100644 --- a/lib/std/Target/spirv.zig +++ b/lib/std/Target/spirv.zig @@ -245,7 +245,7 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.abort_khr)] = .{ + result[@backingInt(Feature.abort_khr)] = .{ .llvm_name = null, .description = "Enable abort_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -253,7 +253,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.arithmetic_fence_ext)] = .{ + result[@backingInt(Feature.arithmetic_fence_ext)] = .{ .llvm_name = null, .description = "Enable arithmetic_fence_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -261,7 +261,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.atomic_float16add_ext)] = .{ + result[@backingInt(Feature.atomic_float16add_ext)] = .{ .llvm_name = null, .description = "Enable atomic_float16add_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -269,7 +269,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.atomic_float16min_max_ext)] = .{ + result[@backingInt(Feature.atomic_float16min_max_ext)] = .{ .llvm_name = null, .description = "Enable atomic_float16min_max_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -277,7 +277,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.atomic_float32add_ext)] = .{ + result[@backingInt(Feature.atomic_float32add_ext)] = .{ .llvm_name = null, .description = "Enable atomic_float32add_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -285,7 +285,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.atomic_float32min_max_ext)] = .{ + result[@backingInt(Feature.atomic_float32min_max_ext)] = .{ .llvm_name = null, .description = "Enable atomic_float32min_max_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -293,7 +293,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.atomic_float64add_ext)] = .{ + result[@backingInt(Feature.atomic_float64add_ext)] = .{ .llvm_name = null, .description = "Enable atomic_float64add_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -301,7 +301,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.atomic_float64min_max_ext)] = .{ + result[@backingInt(Feature.atomic_float64min_max_ext)] = .{ .llvm_name = null, .description = "Enable atomic_float64min_max_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -309,14 +309,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.atomic_storage)] = .{ + result[@backingInt(Feature.atomic_storage)] = .{ .llvm_name = null, .description = "Enable atomic_storage capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.atomic_storage_ops)] = .{ + result[@backingInt(Feature.atomic_storage_ops)] = .{ .llvm_name = null, .description = "Enable atomic_storage_ops capability", .dependencies = featureSet(&[_]Feature{ @@ -324,7 +324,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.b_float16cooperative_matrix_khr)] = .{ + result[@backingInt(Feature.b_float16cooperative_matrix_khr)] = .{ .llvm_name = null, .description = "Enable b_float16cooperative_matrix_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -332,7 +332,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.b_float16dot_product_khr)] = .{ + result[@backingInt(Feature.b_float16dot_product_khr)] = .{ .llvm_name = null, .description = "Enable b_float16dot_product_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -340,7 +340,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.b_float16type_khr)] = .{ + result[@backingInt(Feature.b_float16type_khr)] = .{ .llvm_name = null, .description = "Enable b_float16type_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -348,7 +348,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.bit_instructions)] = .{ + result[@backingInt(Feature.bit_instructions)] = .{ .llvm_name = null, .description = "Enable bit_instructions capability", .dependencies = featureSet(&[_]Feature{ @@ -356,14 +356,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.clip_distance)] = .{ + result[@backingInt(Feature.clip_distance)] = .{ .llvm_name = null, .description = "Enable clip_distance capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.compute_derivative_group_linear_khr)] = .{ + result[@backingInt(Feature.compute_derivative_group_linear_khr)] = .{ .llvm_name = null, .description = "Enable compute_derivative_group_linear_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -371,7 +371,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.compute_derivative_group_quads_khr)] = .{ + result[@backingInt(Feature.compute_derivative_group_quads_khr)] = .{ .llvm_name = null, .description = "Enable compute_derivative_group_quads_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -379,7 +379,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.constant_data_khr)] = .{ + result[@backingInt(Feature.constant_data_khr)] = .{ .llvm_name = null, .description = "Enable constant_data_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -387,7 +387,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.cooperative_matrix_khr)] = .{ + result[@backingInt(Feature.cooperative_matrix_khr)] = .{ .llvm_name = null, .description = "Enable cooperative_matrix_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -395,14 +395,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.cull_distance)] = .{ + result[@backingInt(Feature.cull_distance)] = .{ .llvm_name = null, .description = "Enable cull_distance capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.demote_to_helper_invocation)] = .{ + result[@backingInt(Feature.demote_to_helper_invocation)] = .{ .llvm_name = null, .description = "Enable demote_to_helper_invocation capability", .dependencies = featureSet(&[_]Feature{ @@ -410,7 +410,7 @@ pub const all_features = blk: { .v1_6, }), }; - result[@intFromEnum(Feature.denorm_flush_to_zero)] = .{ + result[@backingInt(Feature.denorm_flush_to_zero)] = .{ .llvm_name = null, .description = "Enable denorm_flush_to_zero capability", .dependencies = featureSet(&[_]Feature{ @@ -418,7 +418,7 @@ pub const all_features = blk: { .v1_4, }), }; - result[@intFromEnum(Feature.denorm_preserve)] = .{ + result[@backingInt(Feature.denorm_preserve)] = .{ .llvm_name = null, .description = "Enable denorm_preserve capability", .dependencies = featureSet(&[_]Feature{ @@ -426,14 +426,14 @@ pub const all_features = blk: { .v1_4, }), }; - result[@intFromEnum(Feature.derivative_control)] = .{ + result[@backingInt(Feature.derivative_control)] = .{ .llvm_name = null, .description = "Enable derivative_control capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.descriptor_heap_ext)] = .{ + result[@backingInt(Feature.descriptor_heap_ext)] = .{ .llvm_name = null, .description = "Enable descriptor_heap_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -441,14 +441,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.device_enqueue)] = .{ + result[@backingInt(Feature.device_enqueue)] = .{ .llvm_name = null, .description = "Enable device_enqueue capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.device_group)] = .{ + result[@backingInt(Feature.device_group)] = .{ .llvm_name = null, .description = "Enable device_group capability", .dependencies = featureSet(&[_]Feature{ @@ -456,7 +456,7 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.dot_product)] = .{ + result[@backingInt(Feature.dot_product)] = .{ .llvm_name = null, .description = "Enable dot_product capability", .dependencies = featureSet(&[_]Feature{ @@ -464,7 +464,7 @@ pub const all_features = blk: { .v1_6, }), }; - result[@intFromEnum(Feature.dot_product_input4x8bit)] = .{ + result[@backingInt(Feature.dot_product_input4x8bit)] = .{ .llvm_name = null, .description = "Enable dot_product_input4x8bit capability", .dependencies = featureSet(&[_]Feature{ @@ -472,7 +472,7 @@ pub const all_features = blk: { .v1_6, }), }; - result[@intFromEnum(Feature.dot_product_input4x8bit_packed)] = .{ + result[@backingInt(Feature.dot_product_input4x8bit_packed)] = .{ .llvm_name = null, .description = "Enable dot_product_input4x8bit_packed capability", .dependencies = featureSet(&[_]Feature{ @@ -480,7 +480,7 @@ pub const all_features = blk: { .v1_6, }), }; - result[@intFromEnum(Feature.dot_product_input_all)] = .{ + result[@backingInt(Feature.dot_product_input_all)] = .{ .llvm_name = null, .description = "Enable dot_product_input_all capability", .dependencies = featureSet(&[_]Feature{ @@ -488,7 +488,7 @@ pub const all_features = blk: { .v1_6, }), }; - result[@intFromEnum(Feature.draw_parameters)] = .{ + result[@backingInt(Feature.draw_parameters)] = .{ .llvm_name = null, .description = "Enable draw_parameters capability", .dependencies = featureSet(&[_]Feature{ @@ -496,7 +496,7 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.expect_assume_khr)] = .{ + result[@backingInt(Feature.expect_assume_khr)] = .{ .llvm_name = null, .description = "Enable expect_assume_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -504,28 +504,28 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.float16)] = .{ + result[@backingInt(Feature.float16)] = .{ .llvm_name = null, .description = "Enable float16 capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.float16buffer)] = .{ + result[@backingInt(Feature.float16buffer)] = .{ .llvm_name = null, .description = "Enable float16buffer capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.float64)] = .{ + result[@backingInt(Feature.float64)] = .{ .llvm_name = null, .description = "Enable float64 capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.float8cooperative_matrix_ext)] = .{ + result[@backingInt(Feature.float8cooperative_matrix_ext)] = .{ .llvm_name = null, .description = "Enable float8cooperative_matrix_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -533,7 +533,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.float8ext)] = .{ + result[@backingInt(Feature.float8ext)] = .{ .llvm_name = null, .description = "Enable float8ext capability", .dependencies = featureSet(&[_]Feature{ @@ -541,7 +541,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.float_controls2)] = .{ + result[@backingInt(Feature.float_controls2)] = .{ .llvm_name = null, .description = "Enable float_controls2 capability", .dependencies = featureSet(&[_]Feature{ @@ -549,7 +549,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fmakhr)] = .{ + result[@backingInt(Feature.fmakhr)] = .{ .llvm_name = null, .description = "Enable fmakhr capability", .dependencies = featureSet(&[_]Feature{ @@ -557,7 +557,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fragment_barycentric_khr)] = .{ + result[@backingInt(Feature.fragment_barycentric_khr)] = .{ .llvm_name = null, .description = "Enable fragment_barycentric_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -565,7 +565,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fragment_density_ext)] = .{ + result[@backingInt(Feature.fragment_density_ext)] = .{ .llvm_name = null, .description = "Enable fragment_density_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -573,7 +573,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fragment_fully_covered_ext)] = .{ + result[@backingInt(Feature.fragment_fully_covered_ext)] = .{ .llvm_name = null, .description = "Enable fragment_fully_covered_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -581,7 +581,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fragment_shader_pixel_interlock_ext)] = .{ + result[@backingInt(Feature.fragment_shader_pixel_interlock_ext)] = .{ .llvm_name = null, .description = "Enable fragment_shader_pixel_interlock_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -589,7 +589,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fragment_shader_sample_interlock_ext)] = .{ + result[@backingInt(Feature.fragment_shader_sample_interlock_ext)] = .{ .llvm_name = null, .description = "Enable fragment_shader_sample_interlock_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -597,7 +597,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fragment_shader_shading_rate_interlock_ext)] = .{ + result[@backingInt(Feature.fragment_shader_shading_rate_interlock_ext)] = .{ .llvm_name = null, .description = "Enable fragment_shader_shading_rate_interlock_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -605,7 +605,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.fragment_shading_rate_khr)] = .{ + result[@backingInt(Feature.fragment_shading_rate_khr)] = .{ .llvm_name = null, .description = "Enable fragment_shading_rate_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -613,63 +613,63 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.generic_pointer)] = .{ + result[@backingInt(Feature.generic_pointer)] = .{ .llvm_name = null, .description = "Enable generic_pointer capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.geometry)] = .{ + result[@backingInt(Feature.geometry)] = .{ .llvm_name = null, .description = "Enable geometry capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.geometry_point_size)] = .{ + result[@backingInt(Feature.geometry_point_size)] = .{ .llvm_name = null, .description = "Enable geometry_point_size capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.geometry_streams)] = .{ + result[@backingInt(Feature.geometry_streams)] = .{ .llvm_name = null, .description = "Enable geometry_streams capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.group_non_uniform)] = .{ + result[@backingInt(Feature.group_non_uniform)] = .{ .llvm_name = null, .description = "Enable group_non_uniform capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_non_uniform_arithmetic)] = .{ + result[@backingInt(Feature.group_non_uniform_arithmetic)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_arithmetic capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_non_uniform_ballot)] = .{ + result[@backingInt(Feature.group_non_uniform_ballot)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_ballot capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_non_uniform_clustered)] = .{ + result[@backingInt(Feature.group_non_uniform_clustered)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_clustered capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_non_uniform_partitioned_ext)] = .{ + result[@backingInt(Feature.group_non_uniform_partitioned_ext)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_partitioned_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -677,14 +677,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.group_non_uniform_quad)] = .{ + result[@backingInt(Feature.group_non_uniform_quad)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_quad capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_non_uniform_rotate_khr)] = .{ + result[@backingInt(Feature.group_non_uniform_rotate_khr)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_rotate_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -692,28 +692,28 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.group_non_uniform_shuffle)] = .{ + result[@backingInt(Feature.group_non_uniform_shuffle)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_shuffle capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_non_uniform_shuffle_relative)] = .{ + result[@backingInt(Feature.group_non_uniform_shuffle_relative)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_shuffle_relative capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_non_uniform_vote)] = .{ + result[@backingInt(Feature.group_non_uniform_vote)] = .{ .llvm_name = null, .description = "Enable group_non_uniform_vote capability", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.group_uniform_arithmetic_khr)] = .{ + result[@backingInt(Feature.group_uniform_arithmetic_khr)] = .{ .llvm_name = null, .description = "Enable group_uniform_arithmetic_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -721,84 +721,84 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.groups)] = .{ + result[@backingInt(Feature.groups)] = .{ .llvm_name = null, .description = "Enable groups capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_basic)] = .{ + result[@backingInt(Feature.image_basic)] = .{ .llvm_name = null, .description = "Enable image_basic capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_buffer)] = .{ + result[@backingInt(Feature.image_buffer)] = .{ .llvm_name = null, .description = "Enable image_buffer capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_cube_array)] = .{ + result[@backingInt(Feature.image_cube_array)] = .{ .llvm_name = null, .description = "Enable image_cube_array capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_gather_extended)] = .{ + result[@backingInt(Feature.image_gather_extended)] = .{ .llvm_name = null, .description = "Enable image_gather_extended capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_mipmap)] = .{ + result[@backingInt(Feature.image_mipmap)] = .{ .llvm_name = null, .description = "Enable image_mipmap capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_ms_array)] = .{ + result[@backingInt(Feature.image_ms_array)] = .{ .llvm_name = null, .description = "Enable image_ms_array capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_query)] = .{ + result[@backingInt(Feature.image_query)] = .{ .llvm_name = null, .description = "Enable image_query capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_read_write)] = .{ + result[@backingInt(Feature.image_read_write)] = .{ .llvm_name = null, .description = "Enable image_read_write capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.image_rect)] = .{ + result[@backingInt(Feature.image_rect)] = .{ .llvm_name = null, .description = "Enable image_rect capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.input_attachment)] = .{ + result[@backingInt(Feature.input_attachment)] = .{ .llvm_name = null, .description = "Enable input_attachment capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.input_attachment_array_dynamic_indexing)] = .{ + result[@backingInt(Feature.input_attachment_array_dynamic_indexing)] = .{ .llvm_name = null, .description = "Enable input_attachment_array_dynamic_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -806,7 +806,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.input_attachment_array_non_uniform_indexing)] = .{ + result[@backingInt(Feature.input_attachment_array_non_uniform_indexing)] = .{ .llvm_name = null, .description = "Enable input_attachment_array_non_uniform_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -814,28 +814,28 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.int16)] = .{ + result[@backingInt(Feature.int16)] = .{ .llvm_name = null, .description = "Enable int16 capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.int64)] = .{ + result[@backingInt(Feature.int64)] = .{ .llvm_name = null, .description = "Enable int64 capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.int64atomics)] = .{ + result[@backingInt(Feature.int64atomics)] = .{ .llvm_name = null, .description = "Enable int64atomics capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.int64image_ext)] = .{ + result[@backingInt(Feature.int64image_ext)] = .{ .llvm_name = null, .description = "Enable int64image_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -843,28 +843,28 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.int8)] = .{ + result[@backingInt(Feature.int8)] = .{ .llvm_name = null, .description = "Enable int8 capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.interpolation_function)] = .{ + result[@backingInt(Feature.interpolation_function)] = .{ .llvm_name = null, .description = "Enable interpolation_function capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.literal_sampler)] = .{ + result[@backingInt(Feature.literal_sampler)] = .{ .llvm_name = null, .description = "Enable literal_sampler capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.long_vector_ext)] = .{ + result[@backingInt(Feature.long_vector_ext)] = .{ .llvm_name = null, .description = "Enable long_vector_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -872,14 +872,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.matrix)] = .{ + result[@backingInt(Feature.matrix)] = .{ .llvm_name = null, .description = "Enable matrix capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.mesh_shading_ext)] = .{ + result[@backingInt(Feature.mesh_shading_ext)] = .{ .llvm_name = null, .description = "Enable mesh_shading_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -887,14 +887,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.min_lod)] = .{ + result[@backingInt(Feature.min_lod)] = .{ .llvm_name = null, .description = "Enable min_lod capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.multi_view)] = .{ + result[@backingInt(Feature.multi_view)] = .{ .llvm_name = null, .description = "Enable multi_view capability", .dependencies = featureSet(&[_]Feature{ @@ -902,21 +902,21 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.multi_viewport)] = .{ + result[@backingInt(Feature.multi_viewport)] = .{ .llvm_name = null, .description = "Enable multi_viewport capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.named_barrier)] = .{ + result[@backingInt(Feature.named_barrier)] = .{ .llvm_name = null, .description = "Enable named_barrier capability", .dependencies = featureSet(&[_]Feature{ .v1_1, }), }; - result[@intFromEnum(Feature.opt_none_ext)] = .{ + result[@backingInt(Feature.opt_none_ext)] = .{ .llvm_name = null, .description = "Enable opt_none_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -924,21 +924,21 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.pipe_storage)] = .{ + result[@backingInt(Feature.pipe_storage)] = .{ .llvm_name = null, .description = "Enable pipe_storage capability", .dependencies = featureSet(&[_]Feature{ .v1_1, }), }; - result[@intFromEnum(Feature.pipes)] = .{ + result[@backingInt(Feature.pipes)] = .{ .llvm_name = null, .description = "Enable pipes capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.poison_freeze_khr)] = .{ + result[@backingInt(Feature.poison_freeze_khr)] = .{ .llvm_name = null, .description = "Enable poison_freeze_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -946,7 +946,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.quad_control_khr)] = .{ + result[@backingInt(Feature.quad_control_khr)] = .{ .llvm_name = null, .description = "Enable quad_control_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -954,7 +954,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_cull_mask_khr)] = .{ + result[@backingInt(Feature.ray_cull_mask_khr)] = .{ .llvm_name = null, .description = "Enable ray_cull_mask_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -962,7 +962,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_query_khr)] = .{ + result[@backingInt(Feature.ray_query_khr)] = .{ .llvm_name = null, .description = "Enable ray_query_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -970,7 +970,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_query_position_fetch_khr)] = .{ + result[@backingInt(Feature.ray_query_position_fetch_khr)] = .{ .llvm_name = null, .description = "Enable ray_query_position_fetch_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -978,7 +978,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_query_provisional_khr)] = .{ + result[@backingInt(Feature.ray_query_provisional_khr)] = .{ .llvm_name = null, .description = "Enable ray_query_provisional_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -986,7 +986,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_tracing_khr)] = .{ + result[@backingInt(Feature.ray_tracing_khr)] = .{ .llvm_name = null, .description = "Enable ray_tracing_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -994,7 +994,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_tracing_opacity_micromap_ext)] = .{ + result[@backingInt(Feature.ray_tracing_opacity_micromap_ext)] = .{ .llvm_name = null, .description = "Enable ray_tracing_opacity_micromap_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1002,7 +1002,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_tracing_position_fetch_khr)] = .{ + result[@backingInt(Feature.ray_tracing_position_fetch_khr)] = .{ .llvm_name = null, .description = "Enable ray_tracing_position_fetch_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1010,7 +1010,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_tracing_provisional_khr)] = .{ + result[@backingInt(Feature.ray_tracing_provisional_khr)] = .{ .llvm_name = null, .description = "Enable ray_tracing_provisional_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1018,7 +1018,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.ray_traversal_primitive_culling_khr)] = .{ + result[@backingInt(Feature.ray_traversal_primitive_culling_khr)] = .{ .llvm_name = null, .description = "Enable ray_traversal_primitive_culling_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1027,7 +1027,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.replicated_composites_ext)] = .{ + result[@backingInt(Feature.replicated_composites_ext)] = .{ .llvm_name = null, .description = "Enable replicated_composites_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1035,7 +1035,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.runtime_descriptor_array)] = .{ + result[@backingInt(Feature.runtime_descriptor_array)] = .{ .llvm_name = null, .description = "Enable runtime_descriptor_array capability", .dependencies = featureSet(&[_]Feature{ @@ -1043,7 +1043,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.sample_mask_post_depth_coverage)] = .{ + result[@backingInt(Feature.sample_mask_post_depth_coverage)] = .{ .llvm_name = null, .description = "Enable sample_mask_post_depth_coverage capability", .dependencies = featureSet(&[_]Feature{ @@ -1051,35 +1051,35 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.sample_rate_shading)] = .{ + result[@backingInt(Feature.sample_rate_shading)] = .{ .llvm_name = null, .description = "Enable sample_rate_shading capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.sampled_buffer)] = .{ + result[@backingInt(Feature.sampled_buffer)] = .{ .llvm_name = null, .description = "Enable sampled_buffer capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.sampled_cube_array)] = .{ + result[@backingInt(Feature.sampled_cube_array)] = .{ .llvm_name = null, .description = "Enable sampled_cube_array capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.sampled_image_array_dynamic_indexing)] = .{ + result[@backingInt(Feature.sampled_image_array_dynamic_indexing)] = .{ .llvm_name = null, .description = "Enable sampled_image_array_dynamic_indexing capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.sampled_image_array_non_uniform_indexing)] = .{ + result[@backingInt(Feature.sampled_image_array_non_uniform_indexing)] = .{ .llvm_name = null, .description = "Enable sampled_image_array_non_uniform_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1087,14 +1087,14 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.sampled_rect)] = .{ + result[@backingInt(Feature.sampled_rect)] = .{ .llvm_name = null, .description = "Enable sampled_rect capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.shader64bit_indexing_ext)] = .{ + result[@backingInt(Feature.shader64bit_indexing_ext)] = .{ .llvm_name = null, .description = "Enable shader64bit_indexing_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1102,7 +1102,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.shader_clock_khr)] = .{ + result[@backingInt(Feature.shader_clock_khr)] = .{ .llvm_name = null, .description = "Enable shader_clock_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1110,7 +1110,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.shader_invocation_reorder_ext)] = .{ + result[@backingInt(Feature.shader_invocation_reorder_ext)] = .{ .llvm_name = null, .description = "Enable shader_invocation_reorder_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1118,14 +1118,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.shader_layer)] = .{ + result[@backingInt(Feature.shader_layer)] = .{ .llvm_name = null, .description = "Enable shader_layer capability", .dependencies = featureSet(&[_]Feature{ .v1_5, }), }; - result[@intFromEnum(Feature.shader_non_uniform)] = .{ + result[@backingInt(Feature.shader_non_uniform)] = .{ .llvm_name = null, .description = "Enable shader_non_uniform capability", .dependencies = featureSet(&[_]Feature{ @@ -1133,14 +1133,14 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.shader_viewport_index)] = .{ + result[@backingInt(Feature.shader_viewport_index)] = .{ .llvm_name = null, .description = "Enable shader_viewport_index capability", .dependencies = featureSet(&[_]Feature{ .v1_5, }), }; - result[@intFromEnum(Feature.shader_viewport_index_layer_ext)] = .{ + result[@backingInt(Feature.shader_viewport_index_layer_ext)] = .{ .llvm_name = null, .description = "Enable shader_viewport_index_layer_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1148,7 +1148,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.signed_zero_inf_nan_preserve)] = .{ + result[@backingInt(Feature.signed_zero_inf_nan_preserve)] = .{ .llvm_name = null, .description = "Enable signed_zero_inf_nan_preserve capability", .dependencies = featureSet(&[_]Feature{ @@ -1156,309 +1156,309 @@ pub const all_features = blk: { .v1_4, }), }; - result[@intFromEnum(Feature.sparse_residency)] = .{ + result[@backingInt(Feature.sparse_residency)] = .{ .llvm_name = null, .description = "Enable sparse_residency capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.SPV_EXT_arithmetic_fence)] = .{ + result[@backingInt(Feature.SPV_EXT_arithmetic_fence)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_arithmetic_fence extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_demote_to_helper_invocation)] = .{ + result[@backingInt(Feature.SPV_EXT_demote_to_helper_invocation)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_demote_to_helper_invocation extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_descriptor_heap)] = .{ + result[@backingInt(Feature.SPV_EXT_descriptor_heap)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_descriptor_heap extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_descriptor_indexing)] = .{ + result[@backingInt(Feature.SPV_EXT_descriptor_indexing)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_descriptor_indexing extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_float8)] = .{ + result[@backingInt(Feature.SPV_EXT_float8)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_float8 extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_fragment_fully_covered)] = .{ + result[@backingInt(Feature.SPV_EXT_fragment_fully_covered)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_fragment_fully_covered extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_fragment_invocation_density)] = .{ + result[@backingInt(Feature.SPV_EXT_fragment_invocation_density)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_fragment_invocation_density extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_fragment_shader_interlock)] = .{ + result[@backingInt(Feature.SPV_EXT_fragment_shader_interlock)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_fragment_shader_interlock extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_long_vector)] = .{ + result[@backingInt(Feature.SPV_EXT_long_vector)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_long_vector extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_mesh_shader)] = .{ + result[@backingInt(Feature.SPV_EXT_mesh_shader)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_mesh_shader extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_opacity_micromap)] = .{ + result[@backingInt(Feature.SPV_EXT_opacity_micromap)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_opacity_micromap extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_optnone)] = .{ + result[@backingInt(Feature.SPV_EXT_optnone)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_optnone extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_physical_storage_buffer)] = .{ + result[@backingInt(Feature.SPV_EXT_physical_storage_buffer)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_physical_storage_buffer extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_replicated_composites)] = .{ + result[@backingInt(Feature.SPV_EXT_replicated_composites)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_replicated_composites extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_64bit_indexing)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_64bit_indexing)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_64bit_indexing extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_atomic_float16_add)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_atomic_float16_add)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_atomic_float16_add extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_atomic_float_add)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_atomic_float_add)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_atomic_float_add extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_atomic_float_min_max)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_atomic_float_min_max)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_atomic_float_min_max extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_image_int64)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_image_int64)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_image_int64 extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_invocation_reorder)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_invocation_reorder)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_invocation_reorder extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_stencil_export)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_stencil_export)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_stencil_export extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_subgroup_partitioned)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_subgroup_partitioned)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_subgroup_partitioned extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_tile_image)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_tile_image)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_tile_image extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_EXT_shader_viewport_index_layer)] = .{ + result[@backingInt(Feature.SPV_EXT_shader_viewport_index_layer)] = .{ .llvm_name = null, .description = "Enable SPV_EXT_shader_viewport_index_layer extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_16bit_storage)] = .{ + result[@backingInt(Feature.SPV_KHR_16bit_storage)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_16bit_storage extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_8bit_storage)] = .{ + result[@backingInt(Feature.SPV_KHR_8bit_storage)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_8bit_storage extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_abort)] = .{ + result[@backingInt(Feature.SPV_KHR_abort)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_abort extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_bfloat16)] = .{ + result[@backingInt(Feature.SPV_KHR_bfloat16)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_bfloat16 extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_bit_instructions)] = .{ + result[@backingInt(Feature.SPV_KHR_bit_instructions)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_bit_instructions extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_compute_shader_derivatives)] = .{ + result[@backingInt(Feature.SPV_KHR_compute_shader_derivatives)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_compute_shader_derivatives extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_constant_data)] = .{ + result[@backingInt(Feature.SPV_KHR_constant_data)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_constant_data extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_cooperative_matrix)] = .{ + result[@backingInt(Feature.SPV_KHR_cooperative_matrix)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_cooperative_matrix extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_device_group)] = .{ + result[@backingInt(Feature.SPV_KHR_device_group)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_device_group extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_expect_assume)] = .{ + result[@backingInt(Feature.SPV_KHR_expect_assume)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_expect_assume extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_float_controls)] = .{ + result[@backingInt(Feature.SPV_KHR_float_controls)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_float_controls extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_float_controls2)] = .{ + result[@backingInt(Feature.SPV_KHR_float_controls2)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_float_controls2 extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_fma)] = .{ + result[@backingInt(Feature.SPV_KHR_fma)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_fma extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_fragment_shader_barycentric)] = .{ + result[@backingInt(Feature.SPV_KHR_fragment_shader_barycentric)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_fragment_shader_barycentric extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_fragment_shading_rate)] = .{ + result[@backingInt(Feature.SPV_KHR_fragment_shading_rate)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_fragment_shading_rate extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_integer_dot_product)] = .{ + result[@backingInt(Feature.SPV_KHR_integer_dot_product)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_integer_dot_product extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_multiview)] = .{ + result[@backingInt(Feature.SPV_KHR_multiview)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_multiview extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_poison_freeze)] = .{ + result[@backingInt(Feature.SPV_KHR_poison_freeze)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_poison_freeze extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_post_depth_coverage)] = .{ + result[@backingInt(Feature.SPV_KHR_post_depth_coverage)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_post_depth_coverage extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_quad_control)] = .{ + result[@backingInt(Feature.SPV_KHR_quad_control)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_quad_control extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_ray_cull_mask)] = .{ + result[@backingInt(Feature.SPV_KHR_ray_cull_mask)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_ray_cull_mask extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_ray_query)] = .{ + result[@backingInt(Feature.SPV_KHR_ray_query)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_ray_query extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_ray_tracing)] = .{ + result[@backingInt(Feature.SPV_KHR_ray_tracing)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_ray_tracing extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_ray_tracing_position_fetch)] = .{ + result[@backingInt(Feature.SPV_KHR_ray_tracing_position_fetch)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_ray_tracing_position_fetch extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_shader_atomic_counter_ops)] = .{ + result[@backingInt(Feature.SPV_KHR_shader_atomic_counter_ops)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_shader_atomic_counter_ops extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_shader_ballot)] = .{ + result[@backingInt(Feature.SPV_KHR_shader_ballot)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_shader_ballot extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_shader_clock)] = .{ + result[@backingInt(Feature.SPV_KHR_shader_clock)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_shader_clock extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_shader_draw_parameters)] = .{ + result[@backingInt(Feature.SPV_KHR_shader_draw_parameters)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_shader_draw_parameters extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_subgroup_rotate)] = .{ + result[@backingInt(Feature.SPV_KHR_subgroup_rotate)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_subgroup_rotate extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_subgroup_vote)] = .{ + result[@backingInt(Feature.SPV_KHR_subgroup_vote)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_subgroup_vote extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_uniform_group_instructions)] = .{ + result[@backingInt(Feature.SPV_KHR_uniform_group_instructions)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_uniform_group_instructions extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_untyped_pointers)] = .{ + result[@backingInt(Feature.SPV_KHR_untyped_pointers)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_untyped_pointers extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_variable_pointers)] = .{ + result[@backingInt(Feature.SPV_KHR_variable_pointers)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_variable_pointers extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_vulkan_memory_model)] = .{ + result[@backingInt(Feature.SPV_KHR_vulkan_memory_model)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_vulkan_memory_model extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.SPV_KHR_workgroup_memory_explicit_layout)] = .{ + result[@backingInt(Feature.SPV_KHR_workgroup_memory_explicit_layout)] = .{ .llvm_name = null, .description = "Enable SPV_KHR_workgroup_memory_explicit_layout extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.stencil_export_ext)] = .{ + result[@backingInt(Feature.stencil_export_ext)] = .{ .llvm_name = null, .description = "Enable stencil_export_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1466,7 +1466,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.storage_buffer16bit_access)] = .{ + result[@backingInt(Feature.storage_buffer16bit_access)] = .{ .llvm_name = null, .description = "Enable storage_buffer16bit_access capability", .dependencies = featureSet(&[_]Feature{ @@ -1474,7 +1474,7 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.storage_buffer8bit_access)] = .{ + result[@backingInt(Feature.storage_buffer8bit_access)] = .{ .llvm_name = null, .description = "Enable storage_buffer8bit_access capability", .dependencies = featureSet(&[_]Feature{ @@ -1482,14 +1482,14 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.storage_buffer_array_dynamic_indexing)] = .{ + result[@backingInt(Feature.storage_buffer_array_dynamic_indexing)] = .{ .llvm_name = null, .description = "Enable storage_buffer_array_dynamic_indexing capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.storage_buffer_array_non_uniform_indexing)] = .{ + result[@backingInt(Feature.storage_buffer_array_non_uniform_indexing)] = .{ .llvm_name = null, .description = "Enable storage_buffer_array_non_uniform_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1497,14 +1497,14 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.storage_image_array_dynamic_indexing)] = .{ + result[@backingInt(Feature.storage_image_array_dynamic_indexing)] = .{ .llvm_name = null, .description = "Enable storage_image_array_dynamic_indexing capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.storage_image_array_non_uniform_indexing)] = .{ + result[@backingInt(Feature.storage_image_array_non_uniform_indexing)] = .{ .llvm_name = null, .description = "Enable storage_image_array_non_uniform_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1512,35 +1512,35 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.storage_image_extended_formats)] = .{ + result[@backingInt(Feature.storage_image_extended_formats)] = .{ .llvm_name = null, .description = "Enable storage_image_extended_formats capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.storage_image_multisample)] = .{ + result[@backingInt(Feature.storage_image_multisample)] = .{ .llvm_name = null, .description = "Enable storage_image_multisample capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.storage_image_read_without_format)] = .{ + result[@backingInt(Feature.storage_image_read_without_format)] = .{ .llvm_name = null, .description = "Enable storage_image_read_without_format capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.storage_image_write_without_format)] = .{ + result[@backingInt(Feature.storage_image_write_without_format)] = .{ .llvm_name = null, .description = "Enable storage_image_write_without_format capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.storage_input_output16)] = .{ + result[@backingInt(Feature.storage_input_output16)] = .{ .llvm_name = null, .description = "Enable storage_input_output16 capability", .dependencies = featureSet(&[_]Feature{ @@ -1548,7 +1548,7 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.storage_push_constant16)] = .{ + result[@backingInt(Feature.storage_push_constant16)] = .{ .llvm_name = null, .description = "Enable storage_push_constant16 capability", .dependencies = featureSet(&[_]Feature{ @@ -1556,7 +1556,7 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.storage_push_constant8)] = .{ + result[@backingInt(Feature.storage_push_constant8)] = .{ .llvm_name = null, .description = "Enable storage_push_constant8 capability", .dependencies = featureSet(&[_]Feature{ @@ -1564,7 +1564,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.storage_texel_buffer_array_dynamic_indexing)] = .{ + result[@backingInt(Feature.storage_texel_buffer_array_dynamic_indexing)] = .{ .llvm_name = null, .description = "Enable storage_texel_buffer_array_dynamic_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1572,7 +1572,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.storage_texel_buffer_array_non_uniform_indexing)] = .{ + result[@backingInt(Feature.storage_texel_buffer_array_non_uniform_indexing)] = .{ .llvm_name = null, .description = "Enable storage_texel_buffer_array_non_uniform_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1580,7 +1580,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.subgroup_ballot_khr)] = .{ + result[@backingInt(Feature.subgroup_ballot_khr)] = .{ .llvm_name = null, .description = "Enable subgroup_ballot_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1588,14 +1588,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.subgroup_dispatch)] = .{ + result[@backingInt(Feature.subgroup_dispatch)] = .{ .llvm_name = null, .description = "Enable subgroup_dispatch capability", .dependencies = featureSet(&[_]Feature{ .v1_1, }), }; - result[@intFromEnum(Feature.subgroup_vote_khr)] = .{ + result[@backingInt(Feature.subgroup_vote_khr)] = .{ .llvm_name = null, .description = "Enable subgroup_vote_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1603,21 +1603,21 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.tessellation)] = .{ + result[@backingInt(Feature.tessellation)] = .{ .llvm_name = null, .description = "Enable tessellation capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.tessellation_point_size)] = .{ + result[@backingInt(Feature.tessellation_point_size)] = .{ .llvm_name = null, .description = "Enable tessellation_point_size capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.tile_image_color_read_access_ext)] = .{ + result[@backingInt(Feature.tile_image_color_read_access_ext)] = .{ .llvm_name = null, .description = "Enable tile_image_color_read_access_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1625,7 +1625,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.tile_image_depth_read_access_ext)] = .{ + result[@backingInt(Feature.tile_image_depth_read_access_ext)] = .{ .llvm_name = null, .description = "Enable tile_image_depth_read_access_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1633,7 +1633,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.tile_image_stencil_read_access_ext)] = .{ + result[@backingInt(Feature.tile_image_stencil_read_access_ext)] = .{ .llvm_name = null, .description = "Enable tile_image_stencil_read_access_ext capability", .dependencies = featureSet(&[_]Feature{ @@ -1641,14 +1641,14 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.transform_feedback)] = .{ + result[@backingInt(Feature.transform_feedback)] = .{ .llvm_name = null, .description = "Enable transform_feedback capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.uniform_and_storage_buffer16bit_access)] = .{ + result[@backingInt(Feature.uniform_and_storage_buffer16bit_access)] = .{ .llvm_name = null, .description = "Enable uniform_and_storage_buffer16bit_access capability", .dependencies = featureSet(&[_]Feature{ @@ -1656,7 +1656,7 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.uniform_and_storage_buffer8bit_access)] = .{ + result[@backingInt(Feature.uniform_and_storage_buffer8bit_access)] = .{ .llvm_name = null, .description = "Enable uniform_and_storage_buffer8bit_access capability", .dependencies = featureSet(&[_]Feature{ @@ -1664,14 +1664,14 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.uniform_buffer_array_dynamic_indexing)] = .{ + result[@backingInt(Feature.uniform_buffer_array_dynamic_indexing)] = .{ .llvm_name = null, .description = "Enable uniform_buffer_array_dynamic_indexing capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.uniform_buffer_array_non_uniform_indexing)] = .{ + result[@backingInt(Feature.uniform_buffer_array_non_uniform_indexing)] = .{ .llvm_name = null, .description = "Enable uniform_buffer_array_non_uniform_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1679,14 +1679,14 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.uniform_decoration)] = .{ + result[@backingInt(Feature.uniform_decoration)] = .{ .llvm_name = null, .description = "Enable uniform_decoration capability", .dependencies = featureSet(&[_]Feature{ .v1_6, }), }; - result[@intFromEnum(Feature.uniform_texel_buffer_array_dynamic_indexing)] = .{ + result[@backingInt(Feature.uniform_texel_buffer_array_dynamic_indexing)] = .{ .llvm_name = null, .description = "Enable uniform_texel_buffer_array_dynamic_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1694,7 +1694,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.uniform_texel_buffer_array_non_uniform_indexing)] = .{ + result[@backingInt(Feature.uniform_texel_buffer_array_non_uniform_indexing)] = .{ .llvm_name = null, .description = "Enable uniform_texel_buffer_array_non_uniform_indexing capability", .dependencies = featureSet(&[_]Feature{ @@ -1702,7 +1702,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.untyped_pointers_khr)] = .{ + result[@backingInt(Feature.untyped_pointers_khr)] = .{ .llvm_name = null, .description = "Enable untyped_pointers_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1710,54 +1710,54 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.v1_0)] = .{ + result[@backingInt(Feature.v1_0)] = .{ .llvm_name = null, .description = "Enable v1_0 extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.v1_1)] = .{ + result[@backingInt(Feature.v1_1)] = .{ .llvm_name = null, .description = "Enable v1_1 extension", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.v1_2)] = .{ + result[@backingInt(Feature.v1_2)] = .{ .llvm_name = null, .description = "Enable v1_2 extension", .dependencies = featureSet(&[_]Feature{ .v1_1, }), }; - result[@intFromEnum(Feature.v1_3)] = .{ + result[@backingInt(Feature.v1_3)] = .{ .llvm_name = null, .description = "Enable v1_3 extension", .dependencies = featureSet(&[_]Feature{ .v1_2, }), }; - result[@intFromEnum(Feature.v1_4)] = .{ + result[@backingInt(Feature.v1_4)] = .{ .llvm_name = null, .description = "Enable v1_4 extension", .dependencies = featureSet(&[_]Feature{ .v1_3, }), }; - result[@intFromEnum(Feature.v1_5)] = .{ + result[@backingInt(Feature.v1_5)] = .{ .llvm_name = null, .description = "Enable v1_5 extension", .dependencies = featureSet(&[_]Feature{ .v1_4, }), }; - result[@intFromEnum(Feature.v1_6)] = .{ + result[@backingInt(Feature.v1_6)] = .{ .llvm_name = null, .description = "Enable v1_6 extension", .dependencies = featureSet(&[_]Feature{ .v1_5, }), }; - result[@intFromEnum(Feature.variable_pointers)] = .{ + result[@backingInt(Feature.variable_pointers)] = .{ .llvm_name = null, .description = "Enable variable_pointers capability", .dependencies = featureSet(&[_]Feature{ @@ -1765,7 +1765,7 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.variable_pointers_storage_buffer)] = .{ + result[@backingInt(Feature.variable_pointers_storage_buffer)] = .{ .llvm_name = null, .description = "Enable variable_pointers_storage_buffer capability", .dependencies = featureSet(&[_]Feature{ @@ -1773,14 +1773,14 @@ pub const all_features = blk: { .v1_3, }), }; - result[@intFromEnum(Feature.vector16)] = .{ + result[@backingInt(Feature.vector16)] = .{ .llvm_name = null, .description = "Enable vector16 capability", .dependencies = featureSet(&[_]Feature{ .v1_0, }), }; - result[@intFromEnum(Feature.vulkan_memory_model)] = .{ + result[@backingInt(Feature.vulkan_memory_model)] = .{ .llvm_name = null, .description = "Enable vulkan_memory_model capability", .dependencies = featureSet(&[_]Feature{ @@ -1788,7 +1788,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.vulkan_memory_model_device_scope)] = .{ + result[@backingInt(Feature.vulkan_memory_model_device_scope)] = .{ .llvm_name = null, .description = "Enable vulkan_memory_model_device_scope capability", .dependencies = featureSet(&[_]Feature{ @@ -1796,7 +1796,7 @@ pub const all_features = blk: { .v1_5, }), }; - result[@intFromEnum(Feature.workgroup_memory_explicit_layout16bit_access_khr)] = .{ + result[@backingInt(Feature.workgroup_memory_explicit_layout16bit_access_khr)] = .{ .llvm_name = null, .description = "Enable workgroup_memory_explicit_layout16bit_access_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1804,7 +1804,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.workgroup_memory_explicit_layout8bit_access_khr)] = .{ + result[@backingInt(Feature.workgroup_memory_explicit_layout8bit_access_khr)] = .{ .llvm_name = null, .description = "Enable workgroup_memory_explicit_layout8bit_access_khr capability", .dependencies = featureSet(&[_]Feature{ @@ -1812,7 +1812,7 @@ pub const all_features = blk: { .v1_0, }), }; - result[@intFromEnum(Feature.workgroup_memory_explicit_layout_khr)] = .{ + result[@backingInt(Feature.workgroup_memory_explicit_layout_khr)] = .{ .llvm_name = null, .description = "Enable workgroup_memory_explicit_layout_khr capability", .dependencies = featureSet(&[_]Feature{ diff --git a/lib/std/Target/ve.zig b/lib/std/Target/ve.zig index ef02c8439bc945e24d7521f16fe449f46b792195..3be114eef3329afc1e263d5a42a8ee0b256a0ae9 100644 --- a/lib/std/Target/ve.zig +++ b/lib/std/Target/ve.zig @@ -17,7 +17,7 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.vpu)] = .{ + result[@backingInt(Feature.vpu)] = .{ .llvm_name = "vpu", .description = "Enable the VPU", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/wasm.zig b/lib/std/Target/wasm.zig index b72b66361fc1ecf42dff9777db24a899b13ec45a..4f1df4e2720408c5f9cec0257ff89a648f135df5 100644 --- a/lib/std/Target/wasm.zig +++ b/lib/std/Target/wasm.zig @@ -35,103 +35,103 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.atomics)] = .{ + result[@backingInt(Feature.atomics)] = .{ .llvm_name = "atomics", .description = "Enable Atomics", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bulk_memory)] = .{ + result[@backingInt(Feature.bulk_memory)] = .{ .llvm_name = "bulk-memory", .description = "Enable bulk memory operations", .dependencies = featureSet(&[_]Feature{ .bulk_memory_opt, }), }; - result[@intFromEnum(Feature.bulk_memory_opt)] = .{ + result[@backingInt(Feature.bulk_memory_opt)] = .{ .llvm_name = "bulk-memory-opt", .description = "Enable bulk memory optimization operations", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.call_indirect_overlong)] = .{ + result[@backingInt(Feature.call_indirect_overlong)] = .{ .llvm_name = "call-indirect-overlong", .description = "Enable overlong encoding for call_indirect immediates", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.exception_handling)] = .{ + result[@backingInt(Feature.exception_handling)] = .{ .llvm_name = "exception-handling", .description = "Enable Wasm exception handling", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.extended_const)] = .{ + result[@backingInt(Feature.extended_const)] = .{ .llvm_name = "extended-const", .description = "Enable extended const expressions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp16)] = .{ + result[@backingInt(Feature.fp16)] = .{ .llvm_name = "fp16", .description = "Enable FP16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gc)] = .{ + result[@backingInt(Feature.gc)] = .{ .llvm_name = "gc", .description = "Enable wasm gc", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.multimemory)] = .{ + result[@backingInt(Feature.multimemory)] = .{ .llvm_name = "multimemory", .description = "Enable multiple memories", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.multivalue)] = .{ + result[@backingInt(Feature.multivalue)] = .{ .llvm_name = "multivalue", .description = "Enable multivalue blocks, instructions, and functions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mutable_globals)] = .{ + result[@backingInt(Feature.mutable_globals)] = .{ .llvm_name = "mutable-globals", .description = "Enable mutable globals", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nontrapping_bulk_memory_len0)] = .{ + result[@backingInt(Feature.nontrapping_bulk_memory_len0)] = .{ .llvm_name = null, .description = "Bulk memory operations with a zero length do not trap", .dependencies = featureSet(&[_]Feature{ .bulk_memory_opt, }), }; - result[@intFromEnum(Feature.nontrapping_fptoint)] = .{ + result[@backingInt(Feature.nontrapping_fptoint)] = .{ .llvm_name = "nontrapping-fptoint", .description = "Enable non-trapping float-to-int conversion operators", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.reference_types)] = .{ + result[@backingInt(Feature.reference_types)] = .{ .llvm_name = "reference-types", .description = "Enable reference types", .dependencies = featureSet(&[_]Feature{ .call_indirect_overlong, }), }; - result[@intFromEnum(Feature.relaxed_simd)] = .{ + result[@backingInt(Feature.relaxed_simd)] = .{ .llvm_name = "relaxed-simd", .description = "Enable relaxed-simd instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sign_ext)] = .{ + result[@backingInt(Feature.sign_ext)] = .{ .llvm_name = "sign-ext", .description = "Enable sign extension operators", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.simd128)] = .{ + result[@backingInt(Feature.simd128)] = .{ .llvm_name = "simd128", .description = "Enable 128-bit SIMD", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tail_call)] = .{ + result[@backingInt(Feature.tail_call)] = .{ .llvm_name = "tail-call", .description = "Enable tail call instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wide_arithmetic)] = .{ + result[@backingInt(Feature.wide_arithmetic)] = .{ .llvm_name = "wide-arithmetic", .description = "Enable wide-arithmetic instructions", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/x86.zig b/lib/std/Target/x86.zig index ca5f4b23006278086f49ccef315bfa9ad6a55cea..8e6823918c41ddd951082d5c4d117011fd532783 100644 --- a/lib/std/Target/x86.zig +++ b/lib/std/Target/x86.zig @@ -218,121 +218,121 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.@"16bit_mode")] = .{ + result[@backingInt(Feature.@"16bit_mode")] = .{ .llvm_name = "16bit-mode", .description = "16-bit mode (i8086)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"32bit_mode")] = .{ + result[@backingInt(Feature.@"32bit_mode")] = .{ .llvm_name = "32bit-mode", .description = "32-bit mode (80386)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.@"3dnow")] = .{ + result[@backingInt(Feature.@"3dnow")] = .{ .llvm_name = null, .description = "Enable 3DNow! instructions", .dependencies = featureSet(&[_]Feature{ .mmx, }), }; - result[@intFromEnum(Feature.@"3dnowa")] = .{ + result[@backingInt(Feature.@"3dnowa")] = .{ .llvm_name = null, .description = "Enable 3DNow! Athlon instructions", .dependencies = featureSet(&[_]Feature{ .@"3dnow", }), }; - result[@intFromEnum(Feature.@"64bit")] = .{ + result[@backingInt(Feature.@"64bit")] = .{ .llvm_name = "64bit", .description = "Support 64-bit instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.adx)] = .{ + result[@backingInt(Feature.adx)] = .{ .llvm_name = "adx", .description = "Support ADX instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.aes)] = .{ + result[@backingInt(Feature.aes)] = .{ .llvm_name = "aes", .description = "Enable AES instructions", .dependencies = featureSet(&[_]Feature{ .sse2, }), }; - result[@intFromEnum(Feature.allow_light_256_bit)] = .{ + result[@backingInt(Feature.allow_light_256_bit)] = .{ .llvm_name = "allow-light-256-bit", .description = "Enable generation of 256-bit load/stores even if we prefer 128-bit", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.amx_avx512)] = .{ + result[@backingInt(Feature.amx_avx512)] = .{ .llvm_name = "amx-avx512", .description = "Support AMX-AVX512 instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_bf16)] = .{ + result[@backingInt(Feature.amx_bf16)] = .{ .llvm_name = "amx-bf16", .description = "Support AMX-BF16 instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_complex)] = .{ + result[@backingInt(Feature.amx_complex)] = .{ .llvm_name = "amx-complex", .description = "Support AMX-COMPLEX instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_fp16)] = .{ + result[@backingInt(Feature.amx_fp16)] = .{ .llvm_name = "amx-fp16", .description = "Support AMX amx-fp16 instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_fp8)] = .{ + result[@backingInt(Feature.amx_fp8)] = .{ .llvm_name = "amx-fp8", .description = "Support AMX-FP8 instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_int8)] = .{ + result[@backingInt(Feature.amx_int8)] = .{ .llvm_name = "amx-int8", .description = "Support AMX-INT8 instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_movrs)] = .{ + result[@backingInt(Feature.amx_movrs)] = .{ .llvm_name = "amx-movrs", .description = "Support AMX-MOVRS instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_tf32)] = .{ + result[@backingInt(Feature.amx_tf32)] = .{ .llvm_name = "amx-tf32", .description = "Support AMX-TF32 instructions", .dependencies = featureSet(&[_]Feature{ .amx_tile, }), }; - result[@intFromEnum(Feature.amx_tile)] = .{ + result[@backingInt(Feature.amx_tile)] = .{ .llvm_name = "amx-tile", .description = "Support AMX-TILE instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.avx)] = .{ + result[@backingInt(Feature.avx)] = .{ .llvm_name = "avx", .description = "Enable AVX instructions", .dependencies = featureSet(&[_]Feature{ .sse4_2, }), }; - result[@intFromEnum(Feature.avx10_1)] = .{ + result[@backingInt(Feature.avx10_1)] = .{ .llvm_name = "avx10.1", .description = "Support AVX10.1 instruction", .dependencies = featureSet(&[_]Feature{ @@ -349,63 +349,63 @@ pub const all_features = blk: { .avx512vpopcntdq, }), }; - result[@intFromEnum(Feature.avx10_2)] = .{ + result[@backingInt(Feature.avx10_2)] = .{ .llvm_name = "avx10.2", .description = "Support AVX10.2 instruction", .dependencies = featureSet(&[_]Feature{ .avx10_1, }), }; - result[@intFromEnum(Feature.avx2)] = .{ + result[@backingInt(Feature.avx2)] = .{ .llvm_name = "avx2", .description = "Enable AVX2 instructions", .dependencies = featureSet(&[_]Feature{ .avx, }), }; - result[@intFromEnum(Feature.avx512bf16)] = .{ + result[@backingInt(Feature.avx512bf16)] = .{ .llvm_name = "avx512bf16", .description = "Support bfloat16 floating point", .dependencies = featureSet(&[_]Feature{ .avx512bw, }), }; - result[@intFromEnum(Feature.avx512bitalg)] = .{ + result[@backingInt(Feature.avx512bitalg)] = .{ .llvm_name = "avx512bitalg", .description = "Enable AVX-512 Bit Algorithms", .dependencies = featureSet(&[_]Feature{ .avx512bw, }), }; - result[@intFromEnum(Feature.avx512bw)] = .{ + result[@backingInt(Feature.avx512bw)] = .{ .llvm_name = "avx512bw", .description = "Enable AVX-512 Byte and Word Instructions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512cd)] = .{ + result[@backingInt(Feature.avx512cd)] = .{ .llvm_name = "avx512cd", .description = "Enable AVX-512 Conflict Detection Instructions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512dq)] = .{ + result[@backingInt(Feature.avx512dq)] = .{ .llvm_name = "avx512dq", .description = "Enable AVX-512 Doubleword and Quadword Instructions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512er)] = .{ + result[@backingInt(Feature.avx512er)] = .{ .llvm_name = null, .description = "Enable AVX-512 Exponential and Reciprocal Instructions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512f)] = .{ + result[@backingInt(Feature.avx512f)] = .{ .llvm_name = "avx512f", .description = "Enable AVX-512 instructions", .dependencies = featureSet(&[_]Feature{ @@ -414,341 +414,341 @@ pub const all_features = blk: { .fma, }), }; - result[@intFromEnum(Feature.avx512fp16)] = .{ + result[@backingInt(Feature.avx512fp16)] = .{ .llvm_name = "avx512fp16", .description = "Support 16-bit floating point", .dependencies = featureSet(&[_]Feature{ .avx512bw, }), }; - result[@intFromEnum(Feature.avx512ifma)] = .{ + result[@backingInt(Feature.avx512ifma)] = .{ .llvm_name = "avx512ifma", .description = "Enable AVX-512 Integer Fused Multiple-Add", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512pf)] = .{ + result[@backingInt(Feature.avx512pf)] = .{ .llvm_name = null, .description = "Enable AVX-512 PreFetch Instructions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512vbmi)] = .{ + result[@backingInt(Feature.avx512vbmi)] = .{ .llvm_name = "avx512vbmi", .description = "Enable AVX-512 Vector Byte Manipulation Instructions", .dependencies = featureSet(&[_]Feature{ .avx512bw, }), }; - result[@intFromEnum(Feature.avx512vbmi2)] = .{ + result[@backingInt(Feature.avx512vbmi2)] = .{ .llvm_name = "avx512vbmi2", .description = "Enable AVX-512 further Vector Byte Manipulation Instructions", .dependencies = featureSet(&[_]Feature{ .avx512bw, }), }; - result[@intFromEnum(Feature.avx512vl)] = .{ + result[@backingInt(Feature.avx512vl)] = .{ .llvm_name = "avx512vl", .description = "Enable AVX-512 Vector Length eXtensions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512vnni)] = .{ + result[@backingInt(Feature.avx512vnni)] = .{ .llvm_name = "avx512vnni", .description = "Enable AVX-512 Vector Neural Network Instructions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512vp2intersect)] = .{ + result[@backingInt(Feature.avx512vp2intersect)] = .{ .llvm_name = "avx512vp2intersect", .description = "Enable AVX-512 vp2intersect", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avx512vpopcntdq)] = .{ + result[@backingInt(Feature.avx512vpopcntdq)] = .{ .llvm_name = "avx512vpopcntdq", .description = "Enable AVX-512 Population Count Instructions", .dependencies = featureSet(&[_]Feature{ .avx512f, }), }; - result[@intFromEnum(Feature.avxifma)] = .{ + result[@backingInt(Feature.avxifma)] = .{ .llvm_name = "avxifma", .description = "Enable AVX-IFMA", .dependencies = featureSet(&[_]Feature{ .avx2, }), }; - result[@intFromEnum(Feature.avxneconvert)] = .{ + result[@backingInt(Feature.avxneconvert)] = .{ .llvm_name = "avxneconvert", .description = "Support AVX-NE-CONVERT instructions", .dependencies = featureSet(&[_]Feature{ .avx2, }), }; - result[@intFromEnum(Feature.avxvnni)] = .{ + result[@backingInt(Feature.avxvnni)] = .{ .llvm_name = "avxvnni", .description = "Support AVX_VNNI encoding", .dependencies = featureSet(&[_]Feature{ .avx2, }), }; - result[@intFromEnum(Feature.avxvnniint16)] = .{ + result[@backingInt(Feature.avxvnniint16)] = .{ .llvm_name = "avxvnniint16", .description = "Enable AVX-VNNI-INT16", .dependencies = featureSet(&[_]Feature{ .avx2, }), }; - result[@intFromEnum(Feature.avxvnniint8)] = .{ + result[@backingInt(Feature.avxvnniint8)] = .{ .llvm_name = "avxvnniint8", .description = "Enable AVX-VNNI-INT8", .dependencies = featureSet(&[_]Feature{ .avx2, }), }; - result[@intFromEnum(Feature.bmi)] = .{ + result[@backingInt(Feature.bmi)] = .{ .llvm_name = "bmi", .description = "Support BMI instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bmi2)] = .{ + result[@backingInt(Feature.bmi2)] = .{ .llvm_name = "bmi2", .description = "Support BMI2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.branch_hint)] = .{ + result[@backingInt(Feature.branch_hint)] = .{ .llvm_name = "branch-hint", .description = "Target has branch hint feature", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.branchfusion)] = .{ + result[@backingInt(Feature.branchfusion)] = .{ .llvm_name = "branchfusion", .description = "CMP/TEST can be fused with conditional branches", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.bsf_bsr_0_clobbers_result)] = .{ + result[@backingInt(Feature.bsf_bsr_0_clobbers_result)] = .{ .llvm_name = null, .description = "BSF/BSR may clobber the lower 32-bits of the result register when the source is zero", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ccmp)] = .{ + result[@backingInt(Feature.ccmp)] = .{ .llvm_name = "ccmp", .description = "Support conditional cmp & test instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cf)] = .{ + result[@backingInt(Feature.cf)] = .{ .llvm_name = "cf", .description = "Support conditional faulting", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cldemote)] = .{ + result[@backingInt(Feature.cldemote)] = .{ .llvm_name = "cldemote", .description = "Enable Cache Line Demote", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.clflushopt)] = .{ + result[@backingInt(Feature.clflushopt)] = .{ .llvm_name = "clflushopt", .description = "Flush A Cache Line Optimized", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.clwb)] = .{ + result[@backingInt(Feature.clwb)] = .{ .llvm_name = "clwb", .description = "Cache Line Write Back", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.clzero)] = .{ + result[@backingInt(Feature.clzero)] = .{ .llvm_name = "clzero", .description = "Enable Cache Line Zero", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cmov)] = .{ + result[@backingInt(Feature.cmov)] = .{ .llvm_name = "cmov", .description = "Enable conditional move instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cmpccxadd)] = .{ + result[@backingInt(Feature.cmpccxadd)] = .{ .llvm_name = "cmpccxadd", .description = "Support CMPCCXADD instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.crc32)] = .{ + result[@backingInt(Feature.crc32)] = .{ .llvm_name = "crc32", .description = "Enable SSE 4.2 CRC32 instruction (used when SSE4.2 is supported but function is GPR only)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.cx16)] = .{ + result[@backingInt(Feature.cx16)] = .{ .llvm_name = "cx16", .description = "64-bit with cmpxchg16b (this is true for most x86-64 chips, but not the first AMD chips)", .dependencies = featureSet(&[_]Feature{ .cx8, }), }; - result[@intFromEnum(Feature.cx8)] = .{ + result[@backingInt(Feature.cx8)] = .{ .llvm_name = "cx8", .description = "Support CMPXCHG8B instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.egpr)] = .{ + result[@backingInt(Feature.egpr)] = .{ .llvm_name = "egpr", .description = "Support extended general purpose register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.enqcmd)] = .{ + result[@backingInt(Feature.enqcmd)] = .{ .llvm_name = "enqcmd", .description = "Has ENQCMD instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ermsb)] = .{ + result[@backingInt(Feature.ermsb)] = .{ .llvm_name = "ermsb", .description = "REP MOVS/STOS are fast", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.f16c)] = .{ + result[@backingInt(Feature.f16c)] = .{ .llvm_name = "f16c", .description = "Support 16-bit floating point conversion instructions", .dependencies = featureSet(&[_]Feature{ .avx, }), }; - result[@intFromEnum(Feature.false_deps_getmant)] = .{ + result[@backingInt(Feature.false_deps_getmant)] = .{ .llvm_name = "false-deps-getmant", .description = "VGETMANTSS/SD/SH and VGETMANDPS/PD(memory version) has a false dependency on dest register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.false_deps_lzcnt_tzcnt)] = .{ + result[@backingInt(Feature.false_deps_lzcnt_tzcnt)] = .{ .llvm_name = "false-deps-lzcnt-tzcnt", .description = "LZCNT/TZCNT have a false dependency on dest register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.false_deps_mulc)] = .{ + result[@backingInt(Feature.false_deps_mulc)] = .{ .llvm_name = "false-deps-mulc", .description = "VF[C]MULCPH/SH has a false dependency on dest register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.false_deps_mullq)] = .{ + result[@backingInt(Feature.false_deps_mullq)] = .{ .llvm_name = "false-deps-mullq", .description = "VPMULLQ has a false dependency on dest register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.false_deps_perm)] = .{ + result[@backingInt(Feature.false_deps_perm)] = .{ .llvm_name = "false-deps-perm", .description = "VPERMD/Q/PS/PD has a false dependency on dest register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.false_deps_popcnt)] = .{ + result[@backingInt(Feature.false_deps_popcnt)] = .{ .llvm_name = "false-deps-popcnt", .description = "POPCNT has a false dependency on dest register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.false_deps_range)] = .{ + result[@backingInt(Feature.false_deps_range)] = .{ .llvm_name = "false-deps-range", .description = "VRANGEPD/PS/SD/SS has a false dependency on dest register", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_11bytenop)] = .{ + result[@backingInt(Feature.fast_11bytenop)] = .{ .llvm_name = "fast-11bytenop", .description = "Target can quickly decode up to 11 byte NOPs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_15bytenop)] = .{ + result[@backingInt(Feature.fast_15bytenop)] = .{ .llvm_name = "fast-15bytenop", .description = "Target can quickly decode up to 15 byte NOPs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_7bytenop)] = .{ + result[@backingInt(Feature.fast_7bytenop)] = .{ .llvm_name = "fast-7bytenop", .description = "Target can quickly decode up to 7 byte NOPs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_bextr)] = .{ + result[@backingInt(Feature.fast_bextr)] = .{ .llvm_name = "fast-bextr", .description = "Indicates that the BEXTR instruction is implemented as a single uop with good throughput", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_dpwssd)] = .{ + result[@backingInt(Feature.fast_dpwssd)] = .{ .llvm_name = "fast-dpwssd", .description = "Prefer vpdpwssd instruction over vpmaddwd+vpaddd instruction sequence", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_gather)] = .{ + result[@backingInt(Feature.fast_gather)] = .{ .llvm_name = "fast-gather", .description = "Indicates if gather is reasonably fast (this is true for Skylake client and all AVX-512 CPUs)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_hops)] = .{ + result[@backingInt(Feature.fast_hops)] = .{ .llvm_name = "fast-hops", .description = "Prefer horizontal vector math instructions (haddp, phsub, etc.) over normal vector instructions with shuffles", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_imm16)] = .{ + result[@backingInt(Feature.fast_imm16)] = .{ .llvm_name = "fast-imm16", .description = "Prefer a i16 instruction with i16 immediate over extension to i32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_lzcnt)] = .{ + result[@backingInt(Feature.fast_lzcnt)] = .{ .llvm_name = "fast-lzcnt", .description = "LZCNT instructions are as fast as most simple integer ops", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_movbe)] = .{ + result[@backingInt(Feature.fast_movbe)] = .{ .llvm_name = "fast-movbe", .description = "Prefer a movbe over a single-use load + bswap / single-use bswap + store", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_scalar_fsqrt)] = .{ + result[@backingInt(Feature.fast_scalar_fsqrt)] = .{ .llvm_name = "fast-scalar-fsqrt", .description = "Scalar SQRT is fast (disable Newton-Raphson)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_scalar_shift_masks)] = .{ + result[@backingInt(Feature.fast_scalar_shift_masks)] = .{ .llvm_name = "fast-scalar-shift-masks", .description = "Prefer a left/right scalar logical shift pair over a shift+and pair", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_shld_rotate)] = .{ + result[@backingInt(Feature.fast_shld_rotate)] = .{ .llvm_name = "fast-shld-rotate", .description = "SHLD can be used as a faster rotate", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_variable_crosslane_shuffle)] = .{ + result[@backingInt(Feature.fast_variable_crosslane_shuffle)] = .{ .llvm_name = "fast-variable-crosslane-shuffle", .description = "Cross-lane shuffles with variable masks are fast", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_variable_perlane_shuffle)] = .{ + result[@backingInt(Feature.fast_variable_perlane_shuffle)] = .{ .llvm_name = "fast-variable-perlane-shuffle", .description = "Per-lane shuffles with variable masks are fast", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_vector_fsqrt)] = .{ + result[@backingInt(Feature.fast_vector_fsqrt)] = .{ .llvm_name = "fast-vector-fsqrt", .description = "Vector SQRT is fast (disable Newton-Raphson)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fast_vector_shift_masks)] = .{ + result[@backingInt(Feature.fast_vector_shift_masks)] = .{ .llvm_name = "fast-vector-shift-masks", .description = "Prefer a left/right vector logical shift pair over a shift+and pair", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.faster_shift_than_shuffle)] = .{ + result[@backingInt(Feature.faster_shift_than_shuffle)] = .{ .llvm_name = "faster-shift-than-shuffle", .description = "Shifts are faster (or as fast) as shuffle", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fma)] = .{ + result[@backingInt(Feature.fma)] = .{ .llvm_name = "fma", .description = "Enable three-operand fused multiple-add", .dependencies = featureSet(&[_]Feature{ .avx, }), }; - result[@intFromEnum(Feature.fma4)] = .{ + result[@backingInt(Feature.fma4)] = .{ .llvm_name = "fma4", .description = "Enable four-operand fused multiple-add", .dependencies = featureSet(&[_]Feature{ @@ -756,288 +756,288 @@ pub const all_features = blk: { .sse4a, }), }; - result[@intFromEnum(Feature.fsgsbase)] = .{ + result[@backingInt(Feature.fsgsbase)] = .{ .llvm_name = "fsgsbase", .description = "Support FS/GS Base instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fsrm)] = .{ + result[@backingInt(Feature.fsrm)] = .{ .llvm_name = "fsrm", .description = "REP MOVSB of short lengths is faster", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fxsr)] = .{ + result[@backingInt(Feature.fxsr)] = .{ .llvm_name = "fxsr", .description = "Support fxsave/fxrestore instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.gfni)] = .{ + result[@backingInt(Feature.gfni)] = .{ .llvm_name = "gfni", .description = "Enable Galois Field Arithmetic Instructions", .dependencies = featureSet(&[_]Feature{ .sse2, }), }; - result[@intFromEnum(Feature.harden_sls_ijmp)] = .{ + result[@backingInt(Feature.harden_sls_ijmp)] = .{ .llvm_name = "harden-sls-ijmp", .description = "Harden against straight line speculation across indirect JMP instructions.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.harden_sls_ret)] = .{ + result[@backingInt(Feature.harden_sls_ret)] = .{ .llvm_name = "harden-sls-ret", .description = "Harden against straight line speculation across RET instructions.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.hreset)] = .{ + result[@backingInt(Feature.hreset)] = .{ .llvm_name = "hreset", .description = "Has hreset instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.idivl_to_divb)] = .{ + result[@backingInt(Feature.idivl_to_divb)] = .{ .llvm_name = "idivl-to-divb", .description = "Use 8-bit divide for positive values less than 256", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.idivq_to_divl)] = .{ + result[@backingInt(Feature.idivq_to_divl)] = .{ .llvm_name = "idivq-to-divl", .description = "Use 32-bit divide for positive values less than 2^32", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.inline_asm_use_gpr32)] = .{ + result[@backingInt(Feature.inline_asm_use_gpr32)] = .{ .llvm_name = "inline-asm-use-gpr32", .description = "Enable use of GPR32 in inline assembly for APX", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.invpcid)] = .{ + result[@backingInt(Feature.invpcid)] = .{ .llvm_name = "invpcid", .description = "Invalidate Process-Context Identifier", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.kl)] = .{ + result[@backingInt(Feature.kl)] = .{ .llvm_name = "kl", .description = "Support Key Locker kl Instructions", .dependencies = featureSet(&[_]Feature{ .sse2, }), }; - result[@intFromEnum(Feature.lea_sp)] = .{ + result[@backingInt(Feature.lea_sp)] = .{ .llvm_name = "lea-sp", .description = "Use LEA for adjusting the stack pointer (this is an optimization for Intel Atom processors)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lea_uses_ag)] = .{ + result[@backingInt(Feature.lea_uses_ag)] = .{ .llvm_name = "lea-uses-ag", .description = "LEA instruction needs inputs at AG stage", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lvi_cfi)] = .{ + result[@backingInt(Feature.lvi_cfi)] = .{ .llvm_name = "lvi-cfi", .description = "Prevent indirect calls/branches from using a memory operand, and precede all indirect calls/branches from a register with an LFENCE instruction to serialize control flow. Also decompose RET instructions into a POP+LFENCE+JMP sequence.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lvi_load_hardening)] = .{ + result[@backingInt(Feature.lvi_load_hardening)] = .{ .llvm_name = "lvi-load-hardening", .description = "Insert LFENCE instructions to prevent data speculatively injected into loads from being used maliciously.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lwp)] = .{ + result[@backingInt(Feature.lwp)] = .{ .llvm_name = "lwp", .description = "Enable LWP instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.lzcnt)] = .{ + result[@backingInt(Feature.lzcnt)] = .{ .llvm_name = "lzcnt", .description = "Support LZCNT instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.macrofusion)] = .{ + result[@backingInt(Feature.macrofusion)] = .{ .llvm_name = "macrofusion", .description = "Various instructions can be fused with conditional branches", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mmx)] = .{ + result[@backingInt(Feature.mmx)] = .{ .llvm_name = "mmx", .description = "Enable MMX instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.movbe)] = .{ + result[@backingInt(Feature.movbe)] = .{ .llvm_name = "movbe", .description = "Support MOVBE instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.movdir64b)] = .{ + result[@backingInt(Feature.movdir64b)] = .{ .llvm_name = "movdir64b", .description = "Support movdir64b instruction (direct store 64 bytes)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.movdiri)] = .{ + result[@backingInt(Feature.movdiri)] = .{ .llvm_name = "movdiri", .description = "Support movdiri instruction (direct store integer)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.movrs)] = .{ + result[@backingInt(Feature.movrs)] = .{ .llvm_name = "movrs", .description = "Enable MOVRS", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mwaitx)] = .{ + result[@backingInt(Feature.mwaitx)] = .{ .llvm_name = "mwaitx", .description = "Enable MONITORX/MWAITX timer functionality", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ndd)] = .{ + result[@backingInt(Feature.ndd)] = .{ .llvm_name = "ndd", .description = "Support non-destructive destination", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nf)] = .{ + result[@backingInt(Feature.nf)] = .{ .llvm_name = "nf", .description = "Support status flags update suppression", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_bypass_delay)] = .{ + result[@backingInt(Feature.no_bypass_delay)] = .{ .llvm_name = "no-bypass-delay", .description = "Has no bypass delay when using the 'wrong' domain", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_bypass_delay_blend)] = .{ + result[@backingInt(Feature.no_bypass_delay_blend)] = .{ .llvm_name = "no-bypass-delay-blend", .description = "Has no bypass delay when using the 'wrong' blend type", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_bypass_delay_mov)] = .{ + result[@backingInt(Feature.no_bypass_delay_mov)] = .{ .llvm_name = "no-bypass-delay-mov", .description = "Has no bypass delay when using the 'wrong' mov type", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.no_bypass_delay_shuffle)] = .{ + result[@backingInt(Feature.no_bypass_delay_shuffle)] = .{ .llvm_name = "no-bypass-delay-shuffle", .description = "Has no bypass delay when using the 'wrong' shuffle type", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nopl)] = .{ + result[@backingInt(Feature.nopl)] = .{ .llvm_name = "nopl", .description = "Enable NOPL instruction (generally pentium pro+)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pad_short_functions)] = .{ + result[@backingInt(Feature.pad_short_functions)] = .{ .llvm_name = "pad-short-functions", .description = "Pad short functions (to prevent a stall when returning too early)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pclmul)] = .{ + result[@backingInt(Feature.pclmul)] = .{ .llvm_name = "pclmul", .description = "Enable packed carry-less multiplication instructions", .dependencies = featureSet(&[_]Feature{ .sse2, }), }; - result[@intFromEnum(Feature.pconfig)] = .{ + result[@backingInt(Feature.pconfig)] = .{ .llvm_name = "pconfig", .description = "platform configuration instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.pku)] = .{ + result[@backingInt(Feature.pku)] = .{ .llvm_name = "pku", .description = "Enable protection keys", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.popcnt)] = .{ + result[@backingInt(Feature.popcnt)] = .{ .llvm_name = "popcnt", .description = "Support POPCNT instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ppx)] = .{ + result[@backingInt(Feature.ppx)] = .{ .llvm_name = "ppx", .description = "Support Push-Pop Acceleration", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_128_bit)] = .{ + result[@backingInt(Feature.prefer_128_bit)] = .{ .llvm_name = "prefer-128-bit", .description = "Prefer 128-bit AVX instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_256_bit)] = .{ + result[@backingInt(Feature.prefer_256_bit)] = .{ .llvm_name = "prefer-256-bit", .description = "Prefer 256-bit AVX instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_legacy_setcc)] = .{ + result[@backingInt(Feature.prefer_legacy_setcc)] = .{ .llvm_name = "prefer-legacy-setcc", .description = "Prefer to emit legacy SetCC.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_mask_registers)] = .{ + result[@backingInt(Feature.prefer_mask_registers)] = .{ .llvm_name = "prefer-mask-registers", .description = "Prefer AVX512 mask registers over PTEST/MOVMSK", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_movmsk_over_vtest)] = .{ + result[@backingInt(Feature.prefer_movmsk_over_vtest)] = .{ .llvm_name = "prefer-movmsk-over-vtest", .description = "Prefer movmsk over vtest instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_no_gather)] = .{ + result[@backingInt(Feature.prefer_no_gather)] = .{ .llvm_name = "prefer-no-gather", .description = "Prefer no gather instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefer_no_scatter)] = .{ + result[@backingInt(Feature.prefer_no_scatter)] = .{ .llvm_name = "prefer-no-scatter", .description = "Prefer no scatter instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefetchi)] = .{ + result[@backingInt(Feature.prefetchi)] = .{ .llvm_name = "prefetchi", .description = "Prefetch instruction with T0 or T1 Hint", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prefetchwt1)] = .{ + result[@backingInt(Feature.prefetchwt1)] = .{ .llvm_name = null, .description = "Prefetch with Intent to Write and T1 Hint", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prfchw)] = .{ + result[@backingInt(Feature.prfchw)] = .{ .llvm_name = "prfchw", .description = "Support PRFCHW instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ptwrite)] = .{ + result[@backingInt(Feature.ptwrite)] = .{ .llvm_name = "ptwrite", .description = "Support ptwrite instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.push2pop2)] = .{ + result[@backingInt(Feature.push2pop2)] = .{ .llvm_name = "push2pop2", .description = "Support PUSH2/POP2 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.raoint)] = .{ + result[@backingInt(Feature.raoint)] = .{ .llvm_name = "raoint", .description = "Support RAO-INT instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rdpid)] = .{ + result[@backingInt(Feature.rdpid)] = .{ .llvm_name = "rdpid", .description = "Support RDPID instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rdpru)] = .{ + result[@backingInt(Feature.rdpru)] = .{ .llvm_name = "rdpru", .description = "Support RDPRU instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rdrnd)] = .{ + result[@backingInt(Feature.rdrnd)] = .{ .llvm_name = "rdrnd", .description = "Support RDRAND instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rdseed)] = .{ + result[@backingInt(Feature.rdseed)] = .{ .llvm_name = "rdseed", .description = "Support RDSEED instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.retpoline)] = .{ + result[@backingInt(Feature.retpoline)] = .{ .llvm_name = "retpoline", .description = "Remove speculation of indirect branches from the generated code, either by avoiding them entirely or lowering them with a speculation blocking construct", .dependencies = featureSet(&[_]Feature{ @@ -1045,180 +1045,180 @@ pub const all_features = blk: { .retpoline_indirect_calls, }), }; - result[@intFromEnum(Feature.retpoline_external_thunk)] = .{ + result[@backingInt(Feature.retpoline_external_thunk)] = .{ .llvm_name = "retpoline-external-thunk", .description = "When lowering an indirect call or branch using a `retpoline`, rely on the specified user provided thunk rather than emitting one ourselves. Only has effect when combined with some other retpoline feature", .dependencies = featureSet(&[_]Feature{ .retpoline_indirect_calls, }), }; - result[@intFromEnum(Feature.retpoline_indirect_branches)] = .{ + result[@backingInt(Feature.retpoline_indirect_branches)] = .{ .llvm_name = "retpoline-indirect-branches", .description = "Remove speculation of indirect branches from the generated code", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.retpoline_indirect_calls)] = .{ + result[@backingInt(Feature.retpoline_indirect_calls)] = .{ .llvm_name = "retpoline-indirect-calls", .description = "Remove speculation of indirect calls from the generated code", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rtm)] = .{ + result[@backingInt(Feature.rtm)] = .{ .llvm_name = "rtm", .description = "Support RTM instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sahf)] = .{ + result[@backingInt(Feature.sahf)] = .{ .llvm_name = "sahf", .description = "Support LAHF and SAHF instructions in 64-bit mode", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sbb_dep_breaking)] = .{ + result[@backingInt(Feature.sbb_dep_breaking)] = .{ .llvm_name = "sbb-dep-breaking", .description = "SBB with same register has no source dependency", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.serialize)] = .{ + result[@backingInt(Feature.serialize)] = .{ .llvm_name = "serialize", .description = "Has serialize instruction", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.seses)] = .{ + result[@backingInt(Feature.seses)] = .{ .llvm_name = "seses", .description = "Prevent speculative execution side channel timing attacks by inserting a speculation barrier before memory reads, memory writes, and conditional branches. Implies LVI Control Flow integrity.", .dependencies = featureSet(&[_]Feature{ .lvi_cfi, }), }; - result[@intFromEnum(Feature.sgx)] = .{ + result[@backingInt(Feature.sgx)] = .{ .llvm_name = "sgx", .description = "Enable Software Guard Extensions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sha)] = .{ + result[@backingInt(Feature.sha)] = .{ .llvm_name = "sha", .description = "Enable SHA instructions", .dependencies = featureSet(&[_]Feature{ .sse2, }), }; - result[@intFromEnum(Feature.sha512)] = .{ + result[@backingInt(Feature.sha512)] = .{ .llvm_name = "sha512", .description = "Support SHA512 instructions", .dependencies = featureSet(&[_]Feature{ .avx2, }), }; - result[@intFromEnum(Feature.shstk)] = .{ + result[@backingInt(Feature.shstk)] = .{ .llvm_name = "shstk", .description = "Support CET Shadow-Stack instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_3ops_lea)] = .{ + result[@backingInt(Feature.slow_3ops_lea)] = .{ .llvm_name = "slow-3ops-lea", .description = "LEA instruction with 3 ops or certain registers is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_incdec)] = .{ + result[@backingInt(Feature.slow_incdec)] = .{ .llvm_name = "slow-incdec", .description = "INC and DEC instructions are slower than ADD and SUB", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_lea)] = .{ + result[@backingInt(Feature.slow_lea)] = .{ .llvm_name = "slow-lea", .description = "LEA instruction with certain arguments is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_pmaddwd)] = .{ + result[@backingInt(Feature.slow_pmaddwd)] = .{ .llvm_name = "slow-pmaddwd", .description = "PMADDWD is slower than PMULLD", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_pmulld)] = .{ + result[@backingInt(Feature.slow_pmulld)] = .{ .llvm_name = "slow-pmulld", .description = "PMULLD instruction is slow (compared to PMULLW/PMULHW and PMULUDQ)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_pmullq)] = .{ + result[@backingInt(Feature.slow_pmullq)] = .{ .llvm_name = "slow-pmullq", .description = "PMULLQ instruction is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_shld)] = .{ + result[@backingInt(Feature.slow_shld)] = .{ .llvm_name = "slow-shld", .description = "SHLD instruction is slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_two_mem_ops)] = .{ + result[@backingInt(Feature.slow_two_mem_ops)] = .{ .llvm_name = "slow-two-mem-ops", .description = "Two memory operand instructions are slow", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_unaligned_mem_16)] = .{ + result[@backingInt(Feature.slow_unaligned_mem_16)] = .{ .llvm_name = "slow-unaligned-mem-16", .description = "Slow unaligned 16-byte memory access", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.slow_unaligned_mem_32)] = .{ + result[@backingInt(Feature.slow_unaligned_mem_32)] = .{ .llvm_name = "slow-unaligned-mem-32", .description = "Slow unaligned 32-byte memory access", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sm3)] = .{ + result[@backingInt(Feature.sm3)] = .{ .llvm_name = "sm3", .description = "Support SM3 instructions", .dependencies = featureSet(&[_]Feature{ .avx, }), }; - result[@intFromEnum(Feature.sm4)] = .{ + result[@backingInt(Feature.sm4)] = .{ .llvm_name = "sm4", .description = "Support SM4 instructions", .dependencies = featureSet(&[_]Feature{ .avx2, }), }; - result[@intFromEnum(Feature.smap)] = .{ + result[@backingInt(Feature.smap)] = .{ .llvm_name = null, .description = "Enable Supervisor Mode Access Prevention", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.smep)] = .{ + result[@backingInt(Feature.smep)] = .{ .llvm_name = null, .description = "Enable Supervisor Mode Execution Prevention", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.soft_float)] = .{ + result[@backingInt(Feature.soft_float)] = .{ .llvm_name = "soft-float", .description = "Use software floating point features", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sse)] = .{ + result[@backingInt(Feature.sse)] = .{ .llvm_name = "sse", .description = "Enable SSE instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sse2)] = .{ + result[@backingInt(Feature.sse2)] = .{ .llvm_name = "sse2", .description = "Enable SSE2 instructions", .dependencies = featureSet(&[_]Feature{ .sse, }), }; - result[@intFromEnum(Feature.sse3)] = .{ + result[@backingInt(Feature.sse3)] = .{ .llvm_name = "sse3", .description = "Enable SSE3 instructions", .dependencies = featureSet(&[_]Feature{ .sse2, }), }; - result[@intFromEnum(Feature.sse4_1)] = .{ + result[@backingInt(Feature.sse4_1)] = .{ .llvm_name = "sse4.1", .description = "Enable SSE 4.1 instructions", .dependencies = featureSet(&[_]Feature{ .ssse3, }), }; - result[@intFromEnum(Feature.sse4_2)] = .{ + result[@backingInt(Feature.sse4_2)] = .{ .llvm_name = "sse4.2", .description = "Enable SSE 4.2 instructions", .dependencies = featureSet(&[_]Feature{ @@ -1226,66 +1226,66 @@ pub const all_features = blk: { .sse4_1, }), }; - result[@intFromEnum(Feature.sse4a)] = .{ + result[@backingInt(Feature.sse4a)] = .{ .llvm_name = "sse4a", .description = "Support SSE 4a instructions", .dependencies = featureSet(&[_]Feature{ .sse3, }), }; - result[@intFromEnum(Feature.sse_unaligned_mem)] = .{ + result[@backingInt(Feature.sse_unaligned_mem)] = .{ .llvm_name = "sse-unaligned-mem", .description = "Allow unaligned memory operands with SSE instructions (this may require setting a configuration bit in the processor)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.ssse3)] = .{ + result[@backingInt(Feature.ssse3)] = .{ .llvm_name = "ssse3", .description = "Enable SSSE3 instructions", .dependencies = featureSet(&[_]Feature{ .sse3, }), }; - result[@intFromEnum(Feature.tagged_globals)] = .{ + result[@backingInt(Feature.tagged_globals)] = .{ .llvm_name = "tagged-globals", .description = "Use an instruction sequence for taking the address of a global that allows a memory tag in the upper address bits.", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tbm)] = .{ + result[@backingInt(Feature.tbm)] = .{ .llvm_name = "tbm", .description = "Enable TBM instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tsxldtrk)] = .{ + result[@backingInt(Feature.tsxldtrk)] = .{ .llvm_name = "tsxldtrk", .description = "Support TSXLDTRK instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.tuning_fast_imm_vector_shift)] = .{ + result[@backingInt(Feature.tuning_fast_imm_vector_shift)] = .{ .llvm_name = "tuning-fast-imm-vector-shift", .description = "Vector shifts are fast (2/cycle) as opposed to slow (1/cycle)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.uintr)] = .{ + result[@backingInt(Feature.uintr)] = .{ .llvm_name = "uintr", .description = "Has UINTR Instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_glm_div_sqrt_costs)] = .{ + result[@backingInt(Feature.use_glm_div_sqrt_costs)] = .{ .llvm_name = "use-glm-div-sqrt-costs", .description = "Use Goldmont specific floating point div/sqrt costs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.use_slm_arith_costs)] = .{ + result[@backingInt(Feature.use_slm_arith_costs)] = .{ .llvm_name = "use-slm-arith-costs", .description = "Use Silvermont specific arithmetic costs", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.usermsr)] = .{ + result[@backingInt(Feature.usermsr)] = .{ .llvm_name = "usermsr", .description = "Support USERMSR instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.vaes)] = .{ + result[@backingInt(Feature.vaes)] = .{ .llvm_name = "vaes", .description = "Promote selected AES instructions to AVX512/AVX registers", .dependencies = featureSet(&[_]Feature{ @@ -1293,7 +1293,7 @@ pub const all_features = blk: { .avx2, }), }; - result[@intFromEnum(Feature.vpclmulqdq)] = .{ + result[@backingInt(Feature.vpclmulqdq)] = .{ .llvm_name = "vpclmulqdq", .description = "Enable vpclmulqdq instructions", .dependencies = featureSet(&[_]Feature{ @@ -1301,72 +1301,72 @@ pub const all_features = blk: { .pclmul, }), }; - result[@intFromEnum(Feature.vzeroupper)] = .{ + result[@backingInt(Feature.vzeroupper)] = .{ .llvm_name = "vzeroupper", .description = "Should insert vzeroupper instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.waitpkg)] = .{ + result[@backingInt(Feature.waitpkg)] = .{ .llvm_name = "waitpkg", .description = "Wait and pause enhancements", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.wbnoinvd)] = .{ + result[@backingInt(Feature.wbnoinvd)] = .{ .llvm_name = "wbnoinvd", .description = "Write Back No Invalidate", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.widekl)] = .{ + result[@backingInt(Feature.widekl)] = .{ .llvm_name = "widekl", .description = "Support Key Locker wide Instructions", .dependencies = featureSet(&[_]Feature{ .kl, }), }; - result[@intFromEnum(Feature.x32)] = .{ + result[@backingInt(Feature.x32)] = .{ .llvm_name = "x32", .description = "64-bit with ILP32 programming model (e.g. x32 ABI)", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.x87)] = .{ + result[@backingInt(Feature.x87)] = .{ .llvm_name = "x87", .description = "Enable X87 float instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xop)] = .{ + result[@backingInt(Feature.xop)] = .{ .llvm_name = "xop", .description = "Enable XOP instructions", .dependencies = featureSet(&[_]Feature{ .fma4, }), }; - result[@intFromEnum(Feature.xsave)] = .{ + result[@backingInt(Feature.xsave)] = .{ .llvm_name = "xsave", .description = "Support xsave instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.xsavec)] = .{ + result[@backingInt(Feature.xsavec)] = .{ .llvm_name = "xsavec", .description = "Support xsavec instructions", .dependencies = featureSet(&[_]Feature{ .xsave, }), }; - result[@intFromEnum(Feature.xsaveopt)] = .{ + result[@backingInt(Feature.xsaveopt)] = .{ .llvm_name = "xsaveopt", .description = "Support xsaveopt instructions", .dependencies = featureSet(&[_]Feature{ .xsave, }), }; - result[@intFromEnum(Feature.xsaves)] = .{ + result[@backingInt(Feature.xsaves)] = .{ .llvm_name = "xsaves", .description = "Support xsaves instructions", .dependencies = featureSet(&[_]Feature{ .xsave, }), }; - result[@intFromEnum(Feature.zu)] = .{ + result[@backingInt(Feature.zu)] = .{ .llvm_name = "zu", .description = "Support zero-upper SETcc/IMUL", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Target/xtensa.zig b/lib/std/Target/xtensa.zig index c2c2b4005c7b5014cc9ed5d6fc6427194c053433..f2ca1f44043e75ced107f19002b51967edf3af08 100644 --- a/lib/std/Target/xtensa.zig +++ b/lib/std/Target/xtensa.zig @@ -53,197 +53,197 @@ pub const all_features = blk: { const len = @typeInfo(Feature).@"enum".field_names.len; std.debug.assert(len <= CpuFeature.Set.needed_bit_count); var result: [len]CpuFeature = undefined; - result[@intFromEnum(Feature.bool)] = .{ + result[@backingInt(Feature.bool)] = .{ .llvm_name = "bool", .description = "Enable Xtensa Boolean extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.clamps)] = .{ + result[@backingInt(Feature.clamps)] = .{ .llvm_name = "clamps", .description = "Enable Xtensa CLAMPS option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.coprocessor)] = .{ + result[@backingInt(Feature.coprocessor)] = .{ .llvm_name = "coprocessor", .description = "Enable Xtensa Coprocessor option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dcache)] = .{ + result[@backingInt(Feature.dcache)] = .{ .llvm_name = "dcache", .description = "Enable Xtensa Data Cache option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.debug)] = .{ + result[@backingInt(Feature.debug)] = .{ .llvm_name = "debug", .description = "Enable Xtensa Debug option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.density)] = .{ + result[@backingInt(Feature.density)] = .{ .llvm_name = "density", .description = "Enable Density instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.dfpaccel)] = .{ + result[@backingInt(Feature.dfpaccel)] = .{ .llvm_name = "dfpaccel", .description = "Enable Xtensa Double Precision FP acceleration", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.div32)] = .{ + result[@backingInt(Feature.div32)] = .{ .llvm_name = "div32", .description = "Enable Xtensa Div32 option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.exception)] = .{ + result[@backingInt(Feature.exception)] = .{ .llvm_name = "exception", .description = "Enable Xtensa Exception option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.extendedl32r)] = .{ + result[@backingInt(Feature.extendedl32r)] = .{ .llvm_name = "extendedl32r", .description = "Enable Xtensa Extended L32R option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.forced_atomics)] = .{ + result[@backingInt(Feature.forced_atomics)] = .{ .llvm_name = "forced-atomics", .description = "Assume that lock-free native-width atomics are available", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.fp)] = .{ + result[@backingInt(Feature.fp)] = .{ .llvm_name = "fp", .description = "Enable Xtensa Single FP instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.highpriinterrupts)] = .{ + result[@backingInt(Feature.highpriinterrupts)] = .{ .llvm_name = "highpriinterrupts", .description = "Enable Xtensa HighPriInterrupts option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.highpriinterrupts_level3)] = .{ + result[@backingInt(Feature.highpriinterrupts_level3)] = .{ .llvm_name = "highpriinterrupts-level3", .description = "Enable Xtensa HighPriInterrupts Level3", .dependencies = featureSet(&[_]Feature{ .highpriinterrupts, }), }; - result[@intFromEnum(Feature.highpriinterrupts_level4)] = .{ + result[@backingInt(Feature.highpriinterrupts_level4)] = .{ .llvm_name = "highpriinterrupts-level4", .description = "Enable Xtensa HighPriInterrupts Level4", .dependencies = featureSet(&[_]Feature{ .highpriinterrupts, }), }; - result[@intFromEnum(Feature.highpriinterrupts_level5)] = .{ + result[@backingInt(Feature.highpriinterrupts_level5)] = .{ .llvm_name = "highpriinterrupts-level5", .description = "Enable Xtensa HighPriInterrupts Level5", .dependencies = featureSet(&[_]Feature{ .highpriinterrupts, }), }; - result[@intFromEnum(Feature.highpriinterrupts_level6)] = .{ + result[@backingInt(Feature.highpriinterrupts_level6)] = .{ .llvm_name = "highpriinterrupts-level6", .description = "Enable Xtensa HighPriInterrupts Level6", .dependencies = featureSet(&[_]Feature{ .highpriinterrupts, }), }; - result[@intFromEnum(Feature.highpriinterrupts_level7)] = .{ + result[@backingInt(Feature.highpriinterrupts_level7)] = .{ .llvm_name = "highpriinterrupts-level7", .description = "Enable Xtensa HighPriInterrupts Level7", .dependencies = featureSet(&[_]Feature{ .highpriinterrupts, }), }; - result[@intFromEnum(Feature.interrupt)] = .{ + result[@backingInt(Feature.interrupt)] = .{ .llvm_name = "interrupt", .description = "Enable Xtensa Interrupt option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.loop)] = .{ + result[@backingInt(Feature.loop)] = .{ .llvm_name = "loop", .description = "Enable Xtensa Loop extension", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mac16)] = .{ + result[@backingInt(Feature.mac16)] = .{ .llvm_name = "mac16", .description = "Enable Xtensa MAC16 instructions", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.minmax)] = .{ + result[@backingInt(Feature.minmax)] = .{ .llvm_name = "minmax", .description = "Enable Xtensa MINMAX option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.miscsr)] = .{ + result[@backingInt(Feature.miscsr)] = .{ .llvm_name = "miscsr", .description = "Enable Xtensa Miscellaneous SR option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mul16)] = .{ + result[@backingInt(Feature.mul16)] = .{ .llvm_name = "mul16", .description = "Enable Xtensa Mul16 option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mul32)] = .{ + result[@backingInt(Feature.mul32)] = .{ .llvm_name = "mul32", .description = "Enable Xtensa Mul32 option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.mul32high)] = .{ + result[@backingInt(Feature.mul32high)] = .{ .llvm_name = "mul32high", .description = "Enable Xtensa Mul32High option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.nsa)] = .{ + result[@backingInt(Feature.nsa)] = .{ .llvm_name = "nsa", .description = "Enable Xtensa NSA option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.prid)] = .{ + result[@backingInt(Feature.prid)] = .{ .llvm_name = "prid", .description = "Enable Xtensa Processor ID option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.regprotect)] = .{ + result[@backingInt(Feature.regprotect)] = .{ .llvm_name = "regprotect", .description = "Enable Xtensa Region Protection option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.rvector)] = .{ + result[@backingInt(Feature.rvector)] = .{ .llvm_name = "rvector", .description = "Enable Xtensa Relocatable Vector option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.s32c1i)] = .{ + result[@backingInt(Feature.s32c1i)] = .{ .llvm_name = "s32c1i", .description = "Enable Xtensa S32C1I option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.sext)] = .{ + result[@backingInt(Feature.sext)] = .{ .llvm_name = "sext", .description = "Enable Xtensa Sign Extend option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.threadptr)] = .{ + result[@backingInt(Feature.threadptr)] = .{ .llvm_name = "threadptr", .description = "Enable Xtensa THREADPTR option", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.timers1)] = .{ + result[@backingInt(Feature.timers1)] = .{ .llvm_name = "timers1", .description = "Enable Xtensa Timers 1", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.timers2)] = .{ + result[@backingInt(Feature.timers2)] = .{ .llvm_name = "timers2", .description = "Enable Xtensa Timers 2", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.timers3)] = .{ + result[@backingInt(Feature.timers3)] = .{ .llvm_name = "timers3", .description = "Enable Xtensa Timers 3", .dependencies = featureSet(&[_]Feature{}), }; - result[@intFromEnum(Feature.windowed)] = .{ + result[@backingInt(Feature.windowed)] = .{ .llvm_name = "windowed", .description = "Enable Xtensa Windowed Register option", .dependencies = featureSet(&[_]Feature{}), diff --git a/lib/std/Thread.zig b/lib/std/Thread.zig index 4f7b457c287f65311239290cce9019c6a9622cf7..6eb76719a55d2787d04f124e58fa8829cbc7e8e9 100644 --- a/lib/std/Thread.zig +++ b/lib/std/Thread.zig @@ -67,7 +67,7 @@ pub fn setName(self: Thread, io: Io, name: []const u8) SetNameError!void { return; } else { const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return, .RANGE => unreachable, else => |e| return posix.unexpectedErrno(e), @@ -101,14 +101,14 @@ pub fn setName(self: Thread, io: Io, name: []const u8) SetNameError!void { if (self.getHandle() != std.c.pthread_self()) return error.Unsupported; const err = std.c.pthread_setname_np(name_with_terminator.ptr); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return, else => |e| return posix.unexpectedErrno(e), } }, .serenity => if (use_pthreads) { const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return, .NAMETOOLONG => unreachable, .SRCH => unreachable, @@ -117,7 +117,7 @@ pub fn setName(self: Thread, io: Io, name: []const u8) SetNameError!void { }, .netbsd, .illumos => if (use_pthreads) { const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr, null); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return, .INVAL => unreachable, .SRCH => unreachable, @@ -135,7 +135,7 @@ pub fn setName(self: Thread, io: Io, name: []const u8) SetNameError!void { }, .dragonfly => if (use_pthreads) { const err = std.c.pthread_setname_np(self.getHandle(), name_with_terminator.ptr); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return, .INVAL => unreachable, .FAULT => unreachable, @@ -168,7 +168,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co return std.mem.sliceTo(buffer, 0); } else { const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return std.mem.sliceTo(buffer, 0), .RANGE => unreachable, else => |e| return posix.unexpectedErrno(e), @@ -211,7 +211,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co }, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => if (use_pthreads) { const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return std.mem.sliceTo(buffer, 0), .SRCH => unreachable, else => |e| return posix.unexpectedErrno(e), @@ -219,7 +219,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co }, .serenity => if (use_pthreads) { const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return, .NAMETOOLONG => unreachable, .SRCH => unreachable, @@ -229,7 +229,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co }, .netbsd, .illumos => if (use_pthreads) { const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return std.mem.sliceTo(buffer, 0), .INVAL => unreachable, .SRCH => unreachable, @@ -245,7 +245,7 @@ pub fn getName(self: Thread, buffer_ptr: *[max_name_len:0]u8) GetNameError!?[]co }, .dragonfly => if (use_pthreads) { const err = std.c.pthread_getname_np(self.getHandle(), buffer.ptr, max_name_len + 1); - switch (@as(posix.E, @enumFromInt(err))) { + switch (@as(posix.E, @fromBackingInt(@intCast(err)))) { .SUCCESS => return std.mem.sliceTo(buffer, 0), .INVAL => unreachable, .FAULT => unreachable, @@ -429,7 +429,7 @@ fn callFn(comptime f: anytype, args: anytype) switch (Impl) { const status = @call(.auto, f, args); switch (Impl) { - WindowsThreadImpl => return @enumFromInt(status), + WindowsThreadImpl => return @fromBackingInt(@intCast(status)), LinuxThreadImpl => return status, // pthreads don't support exit status, ignore value PosixThreadImpl => return default_value, @@ -598,7 +598,7 @@ const WindowsThreadImpl = struct { instance, .{ .CREATE_SUSPENDED = true }, 0, - @enumFromInt(stack_size), + @fromBackingInt(@intCast(stack_size)), .default, &attr_list, )) { @@ -712,7 +712,7 @@ const PosixThreadImpl = struct { // The "proper" way to get the cpu count would be to query // /dev/kstat via ioctls, and traverse a linked list for each // cpu. (illumos) - const rc = c.sysconf(@intFromEnum(std.c._SC.NPROCESSORS_ONLN)); + const rc = c.sysconf(@backingInt(std.c._SC.NPROCESSORS_ONLN)); return switch (posix.errno(rc)) { .SUCCESS => @as(usize, @intCast(rc)), else => |err| posix.unexpectedErrno(err), diff --git a/lib/std/c.zig b/lib/std/c.zig index 4e00a76af698e864b047afb0cc084ada9a666e07..c6a3739972ca0f4b105d9f8168f7e329f15ff184 100644 --- a/lib/std/c.zig +++ b/lib/std/c.zig @@ -74,7 +74,7 @@ pub inline fn versionCheck(comptime version: std.SemanticVersion) bool { /// Get the errno if rc is -1 and SUCCESS if rc is not -1. pub fn errno(rc: anytype) E { - return if (rc == -1) @enumFromInt(_errno().*) else .SUCCESS; + return if (rc == -1) @fromBackingInt(@intCast(_errno().*)) else .SUCCESS; } pub const ino_t = switch (native_os) { @@ -3720,16 +3720,16 @@ pub const W = switch (native_os) { return @as(u8, @intCast(x >> 8)); } pub fn TERMSIG(x: u32) SIG { - return @enumFromInt(status(x)); + return @fromBackingInt(@intCast(status(x))); } pub fn STOPSIG(x: u32) SIG { - return @enumFromInt(x >> 8); + return @fromBackingInt(@intCast(x >> 8)); } pub fn IFEXITED(x: u32) bool { return status(x) == 0; } pub fn IFSTOPPED(x: u32) bool { - return status(x) == stopped and @as(u32, @intFromEnum(STOPSIG(x))) != 0x13; + return status(x) == stopped and @as(u32, @backingInt(STOPSIG(x))) != 0x13; } pub fn IFSIGNALED(x: u32) bool { return status(x) != stopped and status(x) != 0; @@ -3753,10 +3753,10 @@ pub const W = switch (native_os) { return @as(u8, @intCast((s & 0xff00) >> 8)); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn IFEXITED(s: u32) bool { return (s & 0x7f) == 0; @@ -3781,10 +3781,10 @@ pub const W = switch (native_os) { return @as(u8, @intCast((s >> 8) & 0xff)); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn IFEXITED(s: u32) bool { return (s & 0x7f) == 0; @@ -3815,10 +3815,10 @@ pub const W = switch (native_os) { return @as(u8, @intCast((s >> 8) & 0xff)); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn IFEXITED(s: u32) bool { return (s & 0x7f) == 0; @@ -3849,10 +3849,10 @@ pub const W = switch (native_os) { return @as(u8, @intCast((s & 0xff00) >> 8)); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn IFEXITED(s: u32) bool { return (s & 0x7f) == 0; @@ -3877,11 +3877,11 @@ pub const W = switch (native_os) { } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt((s >> 8) & 0xff); + return @fromBackingInt(@intCast((s >> 8) & 0xff)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt((s >> 16) & 0xff); + return @fromBackingInt(@intCast((s >> 16) & 0xff)); } pub fn IFEXITED(s: u32) bool { @@ -3905,10 +3905,10 @@ pub const W = switch (native_os) { return @as(u8, @intCast((s >> 8) & 0xff)); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn IFEXITED(s: u32) bool { return (s & 0x7f) == 0; @@ -3940,11 +3940,11 @@ pub const W = switch (native_os) { } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn IFEXITED(s: u32) bool { @@ -10551,7 +10551,7 @@ const sigrt_private = struct { return switch (native_os) { .freebsd => 65, .netbsd => 33, - .illumos => @truncate(sysconf(@intFromEnum(_SC.SIGRT_MIN))), + .illumos => @truncate(sysconf(@backingInt(_SC.SIGRT_MIN))), .haiku => @truncate(@as(c_uint, @bitCast(private.__signal_get_sigrtmin()))), else => @truncate(@as(c_uint, @bitCast(private.__libc_current_sigrtmin()))), }; @@ -10561,7 +10561,7 @@ const sigrt_private = struct { return switch (native_os) { .freebsd => 126, .netbsd => 63, - .illumos => @truncate(sysconf(@intFromEnum(_SC.SIGRT_MAX))), + .illumos => @truncate(sysconf(@backingInt(_SC.SIGRT_MAX))), .haiku => @truncate(@as(c_uint, @bitCast(private.__signal_get_sigrtmax()))), else => @truncate(@as(c_uint, @bitCast(private.__libc_current_sigrtmax()))), }; diff --git a/lib/std/c/darwin.zig b/lib/std/c/darwin.zig index b9d7b67ef52652a7e5dfd0bcd608c33f693ac90a..19ff7897d8a4297dedcd565d4f01b5f903f60667 100644 --- a/lib/std/c/darwin.zig +++ b/lib/std/c/darwin.zig @@ -1138,10 +1138,10 @@ pub const mach_msg_return_t = enum(kern_return_t) { error_code: mach_msg_return_t, resource_error: ?MACH.MSG, } { - const return_code: mach_msg_return_t = @enumFromInt(@intFromEnum(ret) & ~MACH.MSG.MASK); + const return_code: mach_msg_return_t = @fromBackingInt(@intCast(@backingInt(ret) & ~MACH.MSG.MASK)); switch (return_code) { .RCV_HEADER_ERROR, .RCV_BODY_ERROR => { - const resource_error: MACH.MSG = @bitCast(@intFromEnum(ret) & MACH.MSG.MASK); + const resource_error: MACH.MSG = @bitCast(@backingInt(ret) & MACH.MSG.MASK); return .{ .error_code = return_code, .resource_error = resource_error, diff --git a/lib/std/c/illumos.zig b/lib/std/c/illumos.zig index 39b2f9db2f08acb142eafe0c51e51694d51ef3c8..634c0c124e33c6fb655049083d14ef459a95d350 100644 --- a/lib/std/c/illumos.zig +++ b/lib/std/c/illumos.zig @@ -322,7 +322,7 @@ const IoCtlCommand = enum(u32) { fn ioImpl(cmd: IoCtlCommand, io_type: u8, nr: u8, comptime IOT: type) i32 { const size = @as(u32, @intCast(@as(u8, @truncate(@sizeOf(IOT))))) << 16; const t = @as(u32, @intCast(io_type)) << 8; - return @as(i32, @bitCast(@intFromEnum(cmd) | size | t | nr)); + return @as(i32, @bitCast(@backingInt(cmd) | size | t | nr)); } pub fn IO(io_type: u8, nr: u8) i32 { diff --git a/lib/std/coff.zig b/lib/std/coff.zig index d855495e399fff55db9a02ade2be45d0566a7095..a9a125f3e43e67a82dd509198bb396ee4e856f12 100644 --- a/lib/std/coff.zig +++ b/lib/std/coff.zig @@ -99,8 +99,8 @@ pub const Header = extern struct { // OptionalHeader.magic values // see https://msdn.microsoft.com/en-us/library/windows/desktop/ms680339(v=vs.85).aspx -pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC = @intFromEnum(OptionalHeader.Magic.PE32); -pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC = @intFromEnum(OptionalHeader.Magic.@"PE32+"); +pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC = @backingInt(OptionalHeader.Magic.PE32); +pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC = @backingInt(OptionalHeader.Magic.@"PE32+"); pub const DllFlags = packed struct(u16) { _reserved_0: u5 = 0, @@ -655,12 +655,12 @@ pub const SectionHeader = extern struct { pub fn toByteUnits(a: Align) ?u16 { if (a == .NONE) return null; - return @as(u16, 1) << (@intFromEnum(a) - 1); + return @as(u16, 1) << (@backingInt(a) - 1); } pub fn fromByteUnits(n: u16) Align { std.debug.assert(std.math.isPowerOfTwo(n)); - return @enumFromInt(@ctz(n) + 1); + return @fromBackingInt(@intCast(@ctz(n) + 1)); } pub fn alignment(a: Align) ?std.mem.Alignment { @@ -1058,9 +1058,9 @@ pub const Coff = struct { assert(self.is_image); const data_dirs = self.getDataDirectories(); - if (@intFromEnum(IMAGE.DIRECTORY_ENTRY.DEBUG) >= data_dirs.len) return null; + if (@backingInt(IMAGE.DIRECTORY_ENTRY.DEBUG) >= data_dirs.len) return null; - const debug_dir = data_dirs[@intFromEnum(IMAGE.DIRECTORY_ENTRY.DEBUG)]; + const debug_dir = data_dirs[@backingInt(IMAGE.DIRECTORY_ENTRY.DEBUG)]; var reader: std.Io.Reader = .fixed(self.data); if (self.is_loaded) { @@ -1125,7 +1125,7 @@ pub const Coff = struct { pub fn getImageBase(self: Coff) u64 { const hdr = self.getOptionalHeader(); - return switch (@intFromEnum(hdr.magic)) { + return switch (@backingInt(hdr.magic)) { IMAGE_NT_OPTIONAL_HDR32_MAGIC => self.getOptionalHeader32().image_base, IMAGE_NT_OPTIONAL_HDR64_MAGIC => self.getOptionalHeader64().image_base, else => unreachable, // We assume we have validated the header already @@ -1134,7 +1134,7 @@ pub const Coff = struct { pub fn getNumberOfDataDirectories(self: Coff) u32 { const hdr = self.getOptionalHeader(); - return switch (@intFromEnum(hdr.magic)) { + return switch (@backingInt(hdr.magic)) { IMAGE_NT_OPTIONAL_HDR32_MAGIC => self.getOptionalHeader32().number_of_rva_and_sizes, IMAGE_NT_OPTIONAL_HDR64_MAGIC => self.getOptionalHeader64().number_of_rva_and_sizes, else => unreachable, // We assume we have validated the header already @@ -1143,7 +1143,7 @@ pub const Coff = struct { pub fn getDataDirectories(self: *const Coff) []align(1) const ImageDataDirectory { const hdr = self.getOptionalHeader(); - const size: usize = switch (@intFromEnum(hdr.magic)) { + const size: usize = switch (@backingInt(hdr.magic)) { IMAGE_NT_OPTIONAL_HDR32_MAGIC => @sizeOf(OptionalHeader.PE32), IMAGE_NT_OPTIONAL_HDR64_MAGIC => @sizeOf(OptionalHeader.@"PE32+"), else => unreachable, // We assume we have validated the header already @@ -1268,9 +1268,9 @@ pub const Symtab = struct { return .{ .name = raw[0..8].*, .value = mem.readInt(u32, raw[8..12], .little), - .section_number = @as(SectionNumber, @enumFromInt(mem.readInt(u16, raw[12..14], .little))), + .section_number = @as(SectionNumber, @fromBackingInt(@intCast(mem.readInt(u16, raw[12..14], .little)))), .type = @as(SymType, @bitCast(mem.readInt(u16, raw[14..16], .little))), - .storage_class = @as(StorageClass, @enumFromInt(raw[16])), + .storage_class = @as(StorageClass, @fromBackingInt(@intCast(raw[16]))), .number_of_aux_symbols = raw[17], }; } @@ -1298,7 +1298,7 @@ pub const Symtab = struct { fn asWeakExtDef(raw: []const u8) WeakExternalDefinition { return .{ .tag_index = mem.readInt(u32, raw[0..4], .little), - .flag = @as(WeakExternalFlag, @enumFromInt(mem.readInt(u32, raw[4..8], .little))), + .flag = @as(WeakExternalFlag, @fromBackingInt(@intCast(mem.readInt(u32, raw[4..8], .little)))), .unused = raw[8..18].*, }; } @@ -1316,7 +1316,7 @@ pub const Symtab = struct { .number_of_linenumbers = mem.readInt(u16, raw[6..8], .little), .checksum = mem.readInt(u32, raw[8..12], .little), .number = mem.readInt(u16, raw[12..14], .little), - .selection = @as(ComdatSelection, @enumFromInt(raw[14])), + .selection = @as(ComdatSelection, @fromBackingInt(@intCast(raw[14]))), .unused = raw[15..18].*, }; } diff --git a/lib/std/compress/flate/Compress.zig b/lib/std/compress/flate/Compress.zig index e0dad84bc5c39d9f323f9b03a6c92511c8794a6e..23ca2cb634a086080d49ddede293691046f13b4c 100644 --- a/lib/std/compress/flate/Compress.zig +++ b/lib/std/compress/flate/Compress.zig @@ -1679,7 +1679,7 @@ pub const Raw = struct { const is_pattern = rem_splat != splat and vec.len == pattern.len; if (is_pattern) assert(pattern.len != 0); // exceeded countSplat - if (!is_pattern or rem_splat == 0 or pattern.len > @intFromEnum(block_limit) / 2) { + if (!is_pattern or rem_splat == 0 or pattern.len > @backingInt(block_limit) / 2) { rem_data_elem = rem_data_elem[vec.len..]; block_limit = block_limit.subtract(vec.len).?; @@ -1701,7 +1701,7 @@ pub const Raw = struct { } if (block_limit == .nothing) break; } else { - const out_splat = @intFromEnum(block_limit) / pattern.len; + const out_splat = @backingInt(block_limit) / pattern.len; assert(out_splat >= 2); try r.output.writeSplatAll(vecs[0..vecs_n], out_splat); @@ -2155,7 +2155,7 @@ pub const Huffman = struct { const bytes = block_limit.sliceConst(rem_data_elem); const is_pattern = rem_splat != splat and bytes.len == pattern.len; - const mul = if (!is_pattern) 1 else @intFromEnum(block_limit) / pattern.len; + const mul = if (!is_pattern) 1 else @backingInt(block_limit) / pattern.len; assert(mul != 0); if (is_pattern) assert(mul <= rem_splat + 1); // one more for `rem_data` @@ -2231,11 +2231,11 @@ pub const Huffman = struct { @subWithOverflow(data.len - (rem_data.len - @intFromBool(in_pattern)), 1); const is_elem = in_data == 0 and data[vec_elem_i].len == rem_data_elem.len; - if (!is_elem or rem_data_elem.len > @intFromEnum(block_limit)) { + if (!is_elem or rem_data_elem.len > @backingInt(block_limit)) { block_limit = block_limit.subtract(rem_data_elem.len) orelse { - try h.bit_writer.output.writeAll(rem_data_elem[0..@intFromEnum(block_limit)]); - h.hasher.update(rem_data_elem[0..@intFromEnum(block_limit)]); - rem_data_elem = rem_data_elem[@intFromEnum(block_limit)..]; + try h.bit_writer.output.writeAll(rem_data_elem[0..@backingInt(block_limit)]); + h.hasher.update(rem_data_elem[0..@backingInt(block_limit)]); + rem_data_elem = rem_data_elem[@backingInt(block_limit)..]; assert(rem_data_elem.len != 0); break; }; @@ -2259,7 +2259,7 @@ pub const Huffman = struct { vec_n += 1; } else vec_splat: { // For `pattern.len == 0`, the value of `vec_splat` does not matter. - const vec_splat = @intFromEnum(vlimit) / @max(1, pattern.len); + const vec_splat = @backingInt(vlimit) / @max(1, pattern.len); if (pattern.len != 0) assert(vec_splat <= rem_splat + 1); vlimit = vlimit.subtract(pattern.len * vec_splat).?; vec_n += 1; @@ -2267,7 +2267,7 @@ pub const Huffman = struct { }; const n = if (vec_n != 0) n: { - assert(@intFromEnum(block_limit) - @intFromEnum(vlimit) == + assert(@backingInt(block_limit) - @backingInt(vlimit) == Writer.countSplat(rem_data[0..vec_n], vec_splat)); break :n try h.bit_writer.output.writeSplat(rem_data[0..vec_n], vec_splat); } else 0; // Still go into the case below to advance the vector @@ -2278,8 +2278,8 @@ pub const Huffman = struct { const elem = rem_data[0]; rem_data = rem_data[1..]; consumed = consumed.subtract(elem.len) orelse { - h.hasher.update(elem[0..@intFromEnum(consumed)]); - rem_data_elem = elem[@intFromEnum(consumed)..]; + h.hasher.update(elem[0..@backingInt(consumed)]); + rem_data_elem = elem[@backingInt(consumed)..]; break; }; h.hasher.update(elem); @@ -2297,8 +2297,8 @@ pub const Huffman = struct { break; } - const splatted = @intFromEnum(consumed) / pattern.len; - const partial = @intFromEnum(consumed) % pattern.len; + const splatted = @backingInt(consumed) / pattern.len; + const partial = @backingInt(consumed) % pattern.len; for (0..splatted) |_| h.hasher.update(pattern); h.hasher.update(pattern[0..partial]); diff --git a/lib/std/compress/flate/Decompress.zig b/lib/std/compress/flate/Decompress.zig index 8251c0c5f230c42565d77b6b05dca38be0cd6e11..9c03512ce8db943d98ddb26e27e4171693fc719a 100644 --- a/lib/std/compress/flate/Decompress.zig +++ b/lib/std/compress/flate/Decompress.zig @@ -131,7 +131,7 @@ fn discardDirect(r: *Reader, limit: std.Io.Limit) Reader.Error!usize { error.WriteFailed => unreachable, error.ReadFailed, error.EndOfStream => |e| return e, }; - assert(n <= @intFromEnum(limit)); + assert(n <= @backingInt(limit)); return n; } @@ -268,7 +268,7 @@ fn streamFallible(d: *Decompress, w: *Writer, limit: std.Io.Limit) Reader.Stream } fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader.StreamError)!usize { - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); const in = d.input; sw: switch (d.state) { .protocol_header => switch (d.container_metadata.container()) { @@ -316,7 +316,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader }, .block_header => { d.final_block = (try d.takeIntBits(u1)) != 0; - const block_type: BlockType = @enumFromInt(try d.takeIntBits(u2)); + const block_type: BlockType = @fromBackingInt(@intCast(try d.takeIntBits(u2))); switch (block_type) { .stored => { d.alignBitsForward(); @@ -380,7 +380,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader d.state = .{ .stored_block = @intCast(remaining_len - n) }; } w.advance(n); - return @intFromEnum(limit) - remaining + n; + return @backingInt(limit) - remaining + n; }, .fixed_block => while (true) { // Consume bytes @@ -408,7 +408,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader try w.writeBytePreserve(flate.history_len, byte); } else { d.state = .{ .fixed_block_literal = byte }; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } }, .fixed_block_literal => |symbol| { @@ -426,7 +426,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader continue :sw .fixed_block; } else { d.state = .{ .fixed_block_match = length }; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } }, // In larger archives most blocks are usually dynamic, so @@ -457,7 +457,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader try w.writeBytePreserve(flate.history_len, byte); } else { d.state = .{ .dynamic_block_literal = byte }; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } }, .dynamic_block_literal => |symbol| { @@ -476,7 +476,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader continue :sw .dynamic_block; } else { d.state = .{ .dynamic_block_match = length }; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; } }, .protocol_footer => { @@ -492,7 +492,7 @@ fn streamInner(d: *Decompress, w: *Writer, limit: std.Io.Limit) (Error || Reader .raw => {}, } d.state = .end; - return @intFromEnum(limit) - remaining; + return @backingInt(limit) - remaining; }, .end => return error.EndOfStream, } diff --git a/lib/std/compress/xz/Decompress.zig b/lib/std/compress/xz/Decompress.zig index 5fc5a6068eb41137c604a6ba26e7fe35ed5ab7d3..daba320ce2e3ff06b24548dfd224cbd41936e0da 100644 --- a/lib/std/compress/xz/Decompress.zig +++ b/lib/std/compress/xz/Decompress.zig @@ -219,7 +219,7 @@ fn readBlock(input: *Reader, allocating: *Writer.Allocating) !void { _, }; - const filter_id: FilterId = @enumFromInt(try input.takeLeb128(u64)); + const filter_id: FilterId = @fromBackingInt(@intCast(try input.takeLeb128(u64))); if (filter_id != .lzma2) return error.Unsupported; const properties_size = try input.takeLeb128(u64); diff --git a/lib/std/compress/zstd/Decompress.zig b/lib/std/compress/zstd/Decompress.zig index 8acb2650a293e9d5f72cfefd585f6f10585d86e5..d8fd3d6e3e8abec16d4b92f7214c77639cb6349c 100644 --- a/lib/std/compress/zstd/Decompress.zig +++ b/lib/std/compress/zstd/Decompress.zig @@ -175,7 +175,7 @@ fn discardDirect(r: *Reader, limit: std.Io.Limit) Reader.Error!usize { error.WriteFailed => unreachable, error.ReadFailed, error.EndOfStream => |e| return e, }; - assert(n <= @intFromEnum(limit)); + assert(n <= @backingInt(limit)); return n; } @@ -297,7 +297,7 @@ fn readInFrame(d: *Decompress, w: *Writer, limit: Limit, state: *State.InFrame) const block_size = block_header.size; const frame_block_size_max = state.frame.block_size_max; if (frame_block_size_max < block_size) return error.BlockOversize; - if (@intFromEnum(limit) < block_size) return error.OutputBufferUndersize; + if (@backingInt(limit) < block_size) return error.OutputBufferUndersize; var bytes_written: usize = 0; switch (block_header.type) { .raw => { @@ -320,7 +320,7 @@ fn readInFrame(d: *Decompress, w: *Writer, limit: Limit, state: *State.InFrame) try decode.prepare(in, &remaining, literals, sequences_header); { - if (sequence_buffer.len < @intFromEnum(remaining)) + if (sequence_buffer.len < @backingInt(remaining)) return error.SequenceBufferUndersize; const seq_slice = remaining.slice(&sequence_buffer); try in.readSliceAll(seq_slice); @@ -409,16 +409,16 @@ pub const Frame = struct { _, pub fn kind(m: Magic) ?Kind { - return switch (@intFromEnum(m)) { - @intFromEnum(Magic.zstandard) => .zstandard, - @intFromEnum(Skippable.magic_min)...@intFromEnum(Skippable.magic_max) => .skippable, + return switch (@backingInt(m)) { + @backingInt(Magic.zstandard) => .zstandard, + @backingInt(Skippable.magic_min)...@backingInt(Skippable.magic_max) => .skippable, else => null, }; } pub fn isSkippable(m: Magic) bool { - return switch (@intFromEnum(m)) { - @intFromEnum(Skippable.magic_min)...@intFromEnum(Skippable.magic_max) => true, + return switch (@backingInt(m)) { + @backingInt(Skippable.magic_min)...@backingInt(Skippable.magic_max) => true, else => false, }; } @@ -902,8 +902,8 @@ pub const Frame = struct { }; pub const Skippable = struct { - pub const magic_min: Magic = @enumFromInt(0x184D2A50); - pub const magic_max: Magic = @enumFromInt(0x184D2A5F); + pub const magic_min: Magic = @fromBackingInt(@intCast(0x184D2A50)); + pub const magic_max: Magic = @fromBackingInt(@intCast(0x184D2A5F)); pub const Header = struct { magic_number: u32, @@ -1001,7 +1001,7 @@ pub const LiteralsSection = struct { pub fn decode(in: *Reader, remaining: *Limit) !Header { remaining.* = remaining.subtract(1) orelse return error.EndOfStream; const byte0 = try in.takeByte(); - const block_type: BlockType = @enumFromInt(byte0 & 0b11); + const block_type: BlockType = @fromBackingInt(@intCast(byte0 & 0b11)); const size_format: u2 = @intCast((byte0 & 0b1100) >> 2); var regenerated_size: u20 = undefined; var compressed_size: ?u18 = null; @@ -1330,7 +1330,7 @@ pub const LiteralsSection = struct { try HuffmanTree.decode(in, remaining) else null; - const huffman_tree_size = @intFromEnum(before_remaining) - @intFromEnum(remaining.*); + const huffman_tree_size = @backingInt(before_remaining) - @backingInt(remaining.*); const total_streams_size = std.math.sub(usize, header.compressed_size.?, huffman_tree_size) catch return error.MalformedLiteralsSection; if (total_streams_size > buffer.len) return error.MalformedLiteralsSection; @@ -1398,9 +1398,9 @@ pub const SequencesSection = struct { const compression_modes = try in.takeByte(); - const matches_mode: Header.Mode = @enumFromInt((compression_modes & 0b00001100) >> 2); - const offsets_mode: Header.Mode = @enumFromInt((compression_modes & 0b00110000) >> 4); - const literal_mode: Header.Mode = @enumFromInt((compression_modes & 0b11000000) >> 6); + const matches_mode: Header.Mode = @fromBackingInt(@intCast((compression_modes & 0b00001100) >> 2)); + const offsets_mode: Header.Mode = @fromBackingInt(@intCast((compression_modes & 0b00110000) >> 4)); + const literal_mode: Header.Mode = @fromBackingInt(@intCast((compression_modes & 0b11000000) >> 6)); if (compression_modes & 0b11 != 0) return error.ReservedBitSet; return .{ diff --git a/lib/std/crypto/Certificate.zig b/lib/std/crypto/Certificate.zig index 1fd93328421d6f5d1978cec4009ecfe0bf839839..33502074f661d86b2b6778361e85ab89172242d9 100644 --- a/lib/std/crypto/Certificate.zig +++ b/lib/std/crypto/Certificate.zig @@ -327,7 +327,7 @@ pub const Parsed = struct { while (name_i < general_names.slice.end) { const general_name = try der.Element.parse(subject_alt_name, name_i); name_i = general_name.slice.end; - switch (@as(GeneralNameTag, @enumFromInt(@intFromEnum(general_name.identifier.tag)))) { + switch (@as(GeneralNameTag, @fromBackingInt(@intCast(@backingInt(general_name.identifier.tag))))) { .dNSName => { const dns_name = subject_alt_name[general_name.slice.start..general_name.slice.end]; if (checkHostName(host_name, dns_name)) return; @@ -642,7 +642,7 @@ const Date = struct { while (month < date.month) : (month += 1) { const days: u64 = std.time.epoch.getDaysInMonth( date.year, - @enumFromInt(month), + @fromBackingInt(@intCast(month)), ); sec += days * std.time.epoch.secs_per_day; } diff --git a/lib/std/crypto/Certificate/Bundle/macos.zig b/lib/std/crypto/Certificate/Bundle/macos.zig index ea8a91702d6f82767973e1f830159518ac08e7e0..5b33a2c814fc5b46c2b26079b214a97b029f10b6 100644 --- a/lib/std/crypto/Certificate/Bundle/macos.zig +++ b/lib/std/crypto/Certificate/Bundle/macos.zig @@ -55,7 +55,7 @@ fn scanReader(cb: *Bundle, gpa: Allocator, reader: *Io.Reader, now_sec: i64) !vo const table_header = try reader.takeStruct(TableHeader, .big); - if (@as(std.c.DB_RECORDTYPE, @enumFromInt(table_header.table_id)) != .X509_CERTIFICATE) { + if (@as(std.c.DB_RECORDTYPE, @fromBackingInt(@intCast(table_header.table_id))) != .X509_CERTIFICATE) { continue; } diff --git a/lib/std/crypto/argon2.zig b/lib/std/crypto/argon2.zig index e3550abe1d7cfcad3cdc738ac5f2f01e2606e0a5..b8136ef8788c46ef7b1b2e7ae5f7405b2a16e85b 100644 --- a/lib/std/crypto/argon2.zig +++ b/lib/std/crypto/argon2.zig @@ -119,7 +119,7 @@ fn initHash( mem.writeInt(u32, parameters[8..12], params.m, .little); mem.writeInt(u32, parameters[12..16], params.t, .little); mem.writeInt(u32, parameters[16..20], version, .little); - mem.writeInt(u32, parameters[20..24], @intFromEnum(mode), .little); + mem.writeInt(u32, parameters[20..24], @backingInt(mode), .little); b2.update(¶meters); mem.writeInt(u32, &tmp, @as(u32, @intCast(password.len)), .little); b2.update(&tmp); @@ -290,7 +290,7 @@ fn processSegment( in[2] = slice; in[3] = memory; in[4] = passes; - in[5] = @intFromEnum(mode); + in[5] = @backingInt(mode); } var index: u32 = 0; if (n == 0 and slice == 0) { diff --git a/lib/std/crypto/codecs/asn1.zig b/lib/std/crypto/codecs/asn1.zig index cac37d9d0ca83c4f0c6fa9a84151aade2ceb1c8d..68110155122c38418078aea1ebe433c106aafa3a 100644 --- a/lib/std/crypto/codecs/asn1.zig +++ b/lib/std/crypto/codecs/asn1.zig @@ -86,14 +86,14 @@ pub const Tag = struct { } return Tag{ - .number = @enumFromInt(number), + .number = @fromBackingInt(@intCast(number)), .constructed = tag1.constructed, .class = tag1.class, }; } pub fn encodeToSlice(self: Tag, buf: *[max_encoded_len]u8) []const u8 { - const n = @intFromEnum(self.number); + const n = @backingInt(self.number); var tag1: FirstTag = .{ .number = undefined, .constructed = self.constructed, @@ -175,7 +175,7 @@ test Tag { const buf = [_]u8{0xa3}; var reader: std.Io.Reader = .fixed(&buf); const t = Tag.decode(&reader); - try std.testing.expectEqual(Tag.init(@enumFromInt(3), true, .context_specific), t); + try std.testing.expectEqual(Tag.init(@fromBackingInt(@intCast(3)), true, .context_specific), t); } test "Tag.encode produces the exact bytes from X.690" { @@ -190,7 +190,7 @@ test "Tag.encode produces the exact bytes from X.690" { .{ .number = 65535, .expected = &.{ 0x1f, 0x83, 0xff, 0x7f } }, }; for (cases) |c| { - const tag = Tag.init(@enumFromInt(c.number), false, .universal); + const tag = Tag.init(@fromBackingInt(@intCast(c.number)), false, .universal); var buf: [Tag.max_encoded_len]u8 = undefined; try std.testing.expectEqualSlices(u8, c.expected, tag.encodeToSlice(&buf)); } @@ -198,7 +198,7 @@ test "Tag.encode produces the exact bytes from X.690" { test "Tag.encode/decode round trip" { for ([_]u16{ 0, 30, 31, 32, 127, 128, 16383, 16384, 65535 }) |n| { - const tag = Tag.init(@enumFromInt(n), false, .universal); + const tag = Tag.init(@fromBackingInt(@intCast(n)), false, .universal); var buf: [Tag.max_encoded_len]u8 = undefined; const encoded = tag.encodeToSlice(&buf); var reader: std.Io.Reader = .fixed(encoded); @@ -346,7 +346,7 @@ pub const FieldTag = struct { } pub fn toTag(self: FieldTag) Tag { - return Tag.init(@enumFromInt(self.number), self.explicit, self.class); + return Tag.init(@fromBackingInt(@intCast(self.number)), self.explicit, self.class); } }; diff --git a/lib/std/crypto/codecs/asn1/Oid.zig b/lib/std/crypto/codecs/asn1/Oid.zig index 2cc6dfc090edf767848ae55899a5ac46c23c1638..91fb8712b1bf5a80aabd192c950a9722e689fac5 100644 --- a/lib/std/crypto/codecs/asn1/Oid.zig +++ b/lib/std/crypto/codecs/asn1/Oid.zig @@ -191,7 +191,7 @@ pub fn StaticMap(comptime Enum: type) type { @compileError("Field '" ++ f_name ++ "' missing Oid.StaticMap entry"); } const encoded = &encodeComptime(@field(key_pairs, f_name)); - const tag: Enum = @enumFromInt(f_value); + const tag: Enum = @fromBackingInt(@intCast(f_value)); static_key_pairs[i] = .{ encoded, tag }; enum_to_oid.set(tag, encoded); }; diff --git a/lib/std/crypto/codecs/asn1/der/Decoder.zig b/lib/std/crypto/codecs/asn1/der/Decoder.zig index 3b5cf70a436c6925c81947d7a3247cea3d799127..cc80a2899e0f87d31941f7cb4320bf56788d4a83 100644 --- a/lib/std/crypto/codecs/asn1/der/Decoder.zig +++ b/lib/std/crypto/codecs/asn1/der/Decoder.zig @@ -72,7 +72,7 @@ pub fn any(self: *Decoder, comptime T: type) !T { if (@hasDecl(T, "oids")) { return T.oids.oidToEnum(bytes) orelse return error.UnknownOid; } - return @enumFromInt(try int(e.tag_type, bytes)); + return @fromBackingInt(@intCast(try int(e.tag_type, bytes))); }, .optional => |o| return self.any(o.child) catch return null, else => @compileError("cannot decode type " ++ @typeName(T)), @@ -94,7 +94,7 @@ pub fn element( const res = try Element.decode(self.bytes, self.index); var e = expected; if (self.field_tag) |ft| { - e.number = @enumFromInt(ft.number); + e.number = @fromBackingInt(@intCast(ft.number)); e.class = ft.class; } if (!e.match(res.tag)) { diff --git a/lib/std/crypto/codecs/asn1/der/Encoder.zig b/lib/std/crypto/codecs/asn1/der/Encoder.zig index 7f1913df628d7caace906fe905b423a60d9a8300..f3e58ea7a5e9cf7665335f95150c5ce17a60c059 100644 --- a/lib/std/crypto/codecs/asn1/der/Encoder.zig +++ b/lib/std/crypto/codecs/asn1/der/Encoder.zig @@ -68,7 +68,7 @@ fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void { if (@hasDecl(T, "oids")) { return self.any(T.oids.enumToOid(val)); } else { - try self.int(e.tag_type, @intFromEnum(val)); + try self.int(e.tag_type, @backingInt(val)); } }, .optional => if (val) |v| return try self.anyTag(tag_, v) else return, @@ -91,7 +91,7 @@ fn mergedTag(self: *Encoder, tag_: Tag) Tag { var res = tag_; if (self.field_tag) |ft| { if (!ft.explicit) { - res.number = @enumFromInt(ft.number); + res.number = @fromBackingInt(@intCast(ft.number)); res.class = ft.class; } } diff --git a/lib/std/crypto/tls.zig b/lib/std/crypto/tls.zig index 1d18e7a995542d5e73bdf72415d9ccfe8c38928f..d15c6fb7b326b368431961e794d08a5dfc101341 100644 --- a/lib/std/crypto/tls.zig +++ b/lib/std/crypto/tls.zig @@ -48,8 +48,8 @@ pub const hello_retry_request_sequence = [32]u8{ }; pub const close_notify_alert = [_]u8{ - @intFromEnum(Alert.Level.warning), - @intFromEnum(Alert.Description.close_notify), + @backingInt(Alert.Level.warning), + @backingInt(Alert.Description.close_notify), }; pub const ProtocolVersion = enum(u16) { @@ -595,7 +595,7 @@ pub fn hmac(comptime Hmac: type, message: []const u8, key: [Hmac.key_length]u8) } pub fn extension(et: ExtensionType, bytes: anytype) [2 + 2 + bytes.len]u8 { - return int(u16, @intFromEnum(et)) ++ array(u16, u8, bytes); + return int(u16, @backingInt(et)) ++ array(u16, u8, bytes); } pub fn array( @@ -614,7 +614,7 @@ pub fn array( arr[len_size + elem_size * index ..][0..elem_size], switch (@typeInfo(Elem)) { .int => @as(Elem, elem), - .@"enum" => @intFromEnum(@as(Elem, elem)), + .@"enum" => @backingInt(@as(Elem, elem)), else => @bitCast(@as(Elem, elem)), }, .big, @@ -711,7 +711,7 @@ pub const Decoder = struct { }, .@"enum" => |info| { if (info.mode == .exhaustive) @compileError("exhaustive enum cannot be used"); - return @enumFromInt(d.decode(info.tag_type)); + return @fromBackingInt(@intCast(d.decode(info.tag_type))); }, else => @compileError("unsupported type: " ++ @typeName(T)), } diff --git a/lib/std/crypto/tls/Client.zig b/lib/std/crypto/tls/Client.zig index f69a976c32ff6439daf587688304b6bc3d3df90b..1eb3aca852c0fb6025ee35dcf7cee896606af4df 100644 --- a/lib/std/crypto/tls/Client.zig +++ b/lib/std/crypto/tls/Client.zig @@ -237,16 +237,16 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client })) ++ tls.extension(.key_share, array( u16, u8, - int(u16, @intFromEnum(tls.NamedGroup.x25519_ml_kem768)) ++ + int(u16, @backingInt(tls.NamedGroup.x25519_ml_kem768)) ++ array(u16, u8, key_share.ml_kem768_kp.public_key.toBytes() ++ key_share.x25519_kp.public_key) ++ - int(u16, @intFromEnum(tls.NamedGroup.secp256r1)) ++ + int(u16, @backingInt(tls.NamedGroup.secp256r1)) ++ array(u16, u8, key_share.secp256r1_kp.public_key.toUncompressedSec1()) ++ - int(u16, @intFromEnum(tls.NamedGroup.secp384r1)) ++ + int(u16, @backingInt(tls.NamedGroup.secp384r1)) ++ array(u16, u8, key_share.secp384r1_kp.public_key.toUncompressedSec1()) ++ - int(u16, @intFromEnum(tls.NamedGroup.x25519)) ++ + int(u16, @backingInt(tls.NamedGroup.x25519)) ++ array(u16, u8, key_share.x25519_kp.public_key), )); - const server_name_extension = int(u16, @intFromEnum(tls.ExtensionType.server_name)) ++ + const server_name_extension = int(u16, @backingInt(tls.ExtensionType.server_name)) ++ int(u16, 2 + 1 + 2 + host_len) ++ // byte length of this extension payload int(u16, 1 + 2 + host_len) ++ // server_name_list byte count .{0x00} ++ // name_type @@ -262,19 +262,19 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client server_name_extension; const client_hello = - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ client_hello_rand ++ [1]u8{32} ++ legacy_session_id ++ cipher_suites ++ array(u8, tls.CompressionMethod, .{.null}) ++ extensions_header; - const out_handshake = .{@intFromEnum(tls.HandshakeType.client_hello)} ++ + const out_handshake = .{@backingInt(tls.HandshakeType.client_hello)} ++ int(u24, @intCast(client_hello.len - server_name_extension.len + server_name_extension_len)) ++ client_hello; - const cleartext_header_buf = .{@intFromEnum(tls.ContentType.handshake)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_0)) ++ + const cleartext_header_buf = .{@backingInt(tls.ContentType.handshake)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_0)) ++ int(u16, @intCast(out_handshake.len - server_name_extension.len + server_name_extension_len)) ++ out_handshake; const cleartext_header = switch (options.host) { @@ -389,7 +389,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client } read_seq += 1; cleartext_fragment_end -= 1; - const ct: tls.ContentType = @enumFromInt(cleartext_buf[cleartext_fragment_end]); + const ct: tls.ContentType = @fromBackingInt(@intCast(cleartext_buf[cleartext_fragment_end])); if (ct != .handshake) return error.TlsUnexpectedMessage; break :content .{ tls.Decoder.fromTheirSlice(@constCast(cleartext_buf[cleartext_fragment_start..cleartext_fragment_end])), ct }; }, @@ -495,7 +495,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client } } - tls_version = @enumFromInt(supported_version orelse legacy_version); + tls_version = @fromBackingInt(@intCast(supported_version orelse legacy_version)); switch (tls_version) { .tls_1_3 => if (!mem.eql(u8, legacy_session_id_echo, &legacy_session_id)) return error.TlsIllegalParameter, .tls_1_2 => if (mem.eql(u8, server_hello_rand[24..31], "DOWNGRD") and @@ -739,14 +739,14 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client else => return error.TlsIllegalParameter, }; - const client_key_exchange_prefix = .{@intFromEnum(tls.ContentType.handshake)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + const client_key_exchange_prefix = .{@backingInt(tls.ContentType.handshake)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ int(u16, @intCast(public_key_bytes.len + 5)) ++ // record length - .{@intFromEnum(tls.HandshakeType.client_key_exchange)} ++ + .{@backingInt(tls.HandshakeType.client_key_exchange)} ++ int(u24, @intCast(public_key_bytes.len + 1)) ++ // handshake message length .{@as(u8, @intCast(public_key_bytes.len))}; // public key length - const client_change_cipher_spec_msg = .{@intFromEnum(tls.ContentType.change_cipher_spec)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + const client_change_cipher_spec_msg = .{@backingInt(tls.ContentType.change_cipher_spec)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ array(u16, tls.ChangeCipherSpecType, .{.change_cipher_spec}); const pre_master_secret = key_share.getSharedSecret().?; switch (handshake_cipher) { @@ -771,7 +771,7 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client &.{ "key expansion", &server_hello_rand, &client_hello_rand }, @sizeOf(P.Tls_1_2), ); - const client_verify_cleartext = .{@intFromEnum(tls.HandshakeType.finished)} ++ + const client_verify_cleartext = .{@backingInt(tls.HandshakeType.finished)} ++ array(u24, u8, hmacExpandLabel( P.Hmac, &master_secret, @@ -795,8 +795,8 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client const operand: V = pad ++ @as([8]u8, @bitCast(@byteSwap(write_seq))); break :nonce @as(V, pv.app_cipher.client_write_IV ++ pv.app_cipher.client_salt) ^ operand; }; - var client_verify_msg = .{@intFromEnum(tls.ContentType.handshake)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + var client_verify_msg = .{@backingInt(tls.ContentType.handshake)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ array(u16, u8, nonce[P.fixed_iv_length..].* ++ @as([client_verify_cleartext.len + P.mac_length]u8, undefined)); P.AEAD.encrypt( @@ -846,8 +846,8 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client if (cipher_state == .cleartext) return error.TlsUnexpectedMessage; if (handshake_state != .finished) return error.TlsUnexpectedMessage; // This message is to trick buggy proxies into behaving correctly. - const client_change_cipher_spec_msg = .{@intFromEnum(tls.ContentType.change_cipher_spec)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + const client_change_cipher_spec_msg = .{@backingInt(tls.ContentType.change_cipher_spec)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ array(u16, tls.ChangeCipherSpecType, .{.change_cipher_spec}); const app_cipher = app_cipher: switch (handshake_cipher) { inline else => |*p, tag| switch (tls_version) { @@ -861,14 +861,14 @@ pub fn init(input: *Reader, output: *Writer, options: Options) InitError!Client if (!std.crypto.timing_safe.eql([P.Hmac.mac_length]u8, expected_server_verify_data, hsd.array(P.Hmac.mac_length).*)) return error.TlsDecryptError; const handshake_hash = p.transcript_hash.finalResult(); const verify_data = tls.hmac(P.Hmac, &handshake_hash, pv.client_finished_key); - const out_cleartext = .{@intFromEnum(tls.HandshakeType.finished)} ++ + const out_cleartext = .{@backingInt(tls.HandshakeType.finished)} ++ array(u24, u8, verify_data) ++ - .{@intFromEnum(tls.ContentType.handshake)}; + .{@backingInt(tls.ContentType.handshake)}; const wrapped_len = out_cleartext.len + P.AEAD.tag_length; - var finished_msg = .{@intFromEnum(tls.ContentType.application_data)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + var finished_msg = .{@backingInt(tls.ContentType.application_data)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ array(u16, u8, @as([wrapped_len]u8, undefined)); const ad = finished_msg[0..tls.record_header_len]; @@ -1051,14 +1051,14 @@ fn prepareCiphertextRecord( }; @memcpy(cleartext_buf[0..encrypted_content_len], bytes[bytes_i..][0..encrypted_content_len]); - cleartext_buf[encrypted_content_len] = @intFromEnum(inner_content_type); + cleartext_buf[encrypted_content_len] = @backingInt(inner_content_type); bytes_i += encrypted_content_len; const ciphertext_len = encrypted_content_len + 1; const cleartext = cleartext_buf[0..ciphertext_len]; const ad = ciphertext_buf[ciphertext_end..][0..tls.record_header_len]; - ad.* = .{@intFromEnum(tls.ContentType.application_data)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + ad.* = .{@backingInt(tls.ContentType.application_data)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ int(u16, ciphertext_len + P.AEAD.tag_length); ciphertext_end += ad.len; const ciphertext = ciphertext_buf[ciphertext_end..][0..ciphertext_len]; @@ -1096,8 +1096,8 @@ fn prepareCiphertextRecord( const record_header = ciphertext_buf[ciphertext_end..][0..tls.record_header_len]; ciphertext_end += tls.record_header_len; - record_header.* = .{@intFromEnum(inner_content_type)} ++ - int(u16, @intFromEnum(tls.ProtocolVersion.tls_1_2)) ++ + record_header.* = .{@backingInt(inner_content_type)} ++ + int(u16, @backingInt(tls.ProtocolVersion.tls_1_2)) ++ int(u16, P.record_iv_length + message_len + P.mac_length); const ad = mem.toBytes(big(c.write_seq)) ++ record_header[0 .. 1 + 2] ++ int(u16, message_len); const record_iv = ciphertext_buf[ciphertext_end..][0..P.record_iv_length]; @@ -1160,7 +1160,7 @@ fn readIndirect(c: *Client) Reader.Error!usize { }, error.ReadFailed => |e| return e, }; - const ct: tls.ContentType = @enumFromInt(record_header[0]); + const ct: tls.ContentType = @fromBackingInt(@intCast(record_header[0])); const legacy_version = mem.readInt(u16, record_header[1..][0..2], .big); _ = legacy_version; const record_len = mem.readInt(u16, record_header[3..][0..2], .big); @@ -1197,7 +1197,7 @@ fn readIndirect(c: *Client) Reader.Error!usize { // TODO use scalar, non-slice version const msg = mem.trimEnd(u8, cleartext, "\x00"); if (msg.len == 0) return failRead(c, error.TlsDecodeError); - break :cleartext .{ msg.len - 1, @enumFromInt(msg[msg.len - 1]) }; + break :cleartext .{ msg.len - 1, @fromBackingInt(@intCast(msg[msg.len - 1])) }; }, .tls_1_2 => { const pv = &p.tls_1_2; @@ -1234,8 +1234,8 @@ fn readIndirect(c: *Client) Reader.Error!usize { .alert => { if (cleartext.len != 2) return failRead(c, error.TlsDecodeError); const alert: tls.Alert = .{ - .level = @enumFromInt(cleartext[0]), - .description = @enumFromInt(cleartext[1]), + .level = @fromBackingInt(@intCast(cleartext[0])), + .description = @fromBackingInt(@intCast(cleartext[1])), }; switch (alert.description) { .close_notify => { @@ -1255,7 +1255,7 @@ fn readIndirect(c: *Client) Reader.Error!usize { .handshake => { var ct_i: usize = 0; while (true) { - const handshake_type: tls.HandshakeType = @enumFromInt(cleartext[ct_i]); + const handshake_type: tls.HandshakeType = @fromBackingInt(@intCast(cleartext[ct_i])); ct_i += 1; const handshake_len = mem.readInt(u24, cleartext[ct_i..][0..3], .big); ct_i += 3; @@ -1286,7 +1286,7 @@ fn readIndirect(c: *Client) Reader.Error!usize { } c.read_seq = 0; - switch (@as(tls.KeyUpdateRequest, @enumFromInt(handshake[0]))) { + switch (@as(tls.KeyUpdateRequest, @fromBackingInt(@intCast(handshake[0])))) { .update_requested => { switch (c.application_cipher) { inline else => |*p| { diff --git a/lib/std/debug.zig b/lib/std/debug.zig index db6060d7e8bc620c9c05b88bead578c2b09f548a..9a83de8e1061d603b3e82c80d6e84cc8a640441b 100644 --- a/lib/std/debug.zig +++ b/lib/std/debug.zig @@ -844,7 +844,7 @@ pub fn writeErrorReturnTrace(et: *const std.builtin.StackTrace, t: Io.Terminal) // writing the stack trace. const len = @min(et.instruction_addresses.len, et.index); const skipped = et.index - len; - try writeTrace(et.instruction_addresses[0..len], @enumFromInt(skipped), t, false); + try writeTrace(et.instruction_addresses[0..len], @fromBackingInt(@intCast(skipped)), t, false); } /// Write a previously captured stack trace to `writer`, annotated with source locations. diff --git a/lib/std/debug/Coverage.zig b/lib/std/debug/Coverage.zig index 7bbc58a5b71f541734aafd75d75fdfb2c3858efb..3f6d67cf034f3ca47b3b8398a9ff9243fe3c55ad 100644 --- a/lib/std/debug/Coverage.zig +++ b/lib/std/debug/Coverage.zig @@ -41,13 +41,13 @@ pub const String = enum(u32) { pub fn eql(self: @This(), a: String, b: String, b_index: usize) bool { _ = b_index; - const a_slice = span(self.string_bytes[@intFromEnum(a)..]); - const b_slice = span(self.string_bytes[@intFromEnum(b)..]); + const a_slice = span(self.string_bytes[@backingInt(a)..]); + const b_slice = span(self.string_bytes[@backingInt(b)..]); return std.mem.eql(u8, a_slice, b_slice); } pub fn hash(self: @This(), a: String) u32 { - return @truncate(Hash.hash(0, span(self.string_bytes[@intFromEnum(a)..]))); + return @truncate(Hash.hash(0, span(self.string_bytes[@backingInt(a)..]))); } }; @@ -56,7 +56,7 @@ pub const String = enum(u32) { pub fn eql(self: @This(), a_slice: []const u8, b: String, b_index: usize) bool { _ = b_index; - const b_slice = span(self.string_bytes[@intFromEnum(b)..]); + const b_slice = span(self.string_bytes[@backingInt(b)..]); return std.mem.eql(u8, a_slice, b_slice); } pub fn hash(self: @This(), a: []const u8) u32 { @@ -91,15 +91,15 @@ pub const File = extern struct { string_bytes: []const u8, pub fn hash(self: MapContext, a: File) u32 { - const a_basename = span(self.string_bytes[@intFromEnum(a.basename)..]); + const a_basename = span(self.string_bytes[@backingInt(a.basename)..]); return @truncate(Hash.hash(a.directory_index, a_basename)); } pub fn eql(self: MapContext, a: File, b: File, b_index: usize) bool { _ = b_index; if (a.directory_index != b.directory_index) return false; - const a_basename = span(self.string_bytes[@intFromEnum(a.basename)..]); - const b_basename = span(self.string_bytes[@intFromEnum(b.basename)..]); + const a_basename = span(self.string_bytes[@backingInt(a.basename)..]); + const b_basename = span(self.string_bytes[@backingInt(b.basename)..]); return std.mem.eql(u8, a_basename, b_basename); } }; @@ -120,7 +120,7 @@ pub const File = extern struct { pub fn eql(self: @This(), a: Entry, b: File, b_index: usize) bool { _ = b_index; if (a.directory_index != b.directory_index) return false; - const b_basename = span(self.string_bytes[@intFromEnum(b.basename)..]); + const b_basename = span(self.string_bytes[@backingInt(b.basename)..]); return std.mem.eql(u8, a.basename, b_basename); } }; @@ -134,11 +134,11 @@ pub fn deinit(cov: *Coverage, gpa: Allocator) void { } pub fn fileAt(cov: *Coverage, index: File.Index) *File { - return &cov.files.keys()[@intFromEnum(index)]; + return &cov.files.keys()[@backingInt(index)]; } pub fn stringAt(cov: *Coverage, index: String) [:0]const u8 { - return span(cov.string_bytes.items[@intFromEnum(index)..]); + return span(cov.string_bytes.items[@backingInt(index)..]); } pub const ResolveAddressesDwarfError = Dwarf.ScanError || Io.Cancelable; @@ -232,7 +232,7 @@ pub fn resolveAddressesDwarf( .basename = addStringAssumeCapacity(cov, file_entry.path), }; out.* = .{ - .file = @enumFromInt(file_gop.index), + .file = @fromBackingInt(@intCast(file_gop.index)), .line = entry.line, .column = entry.column, }; @@ -240,7 +240,7 @@ pub fn resolveAddressesDwarf( } pub fn addStringAssumeCapacity(cov: *Coverage, s: []const u8) String { - const result: String = @enumFromInt(cov.string_bytes.items.len); + const result: String = @fromBackingInt(@intCast(cov.string_bytes.items.len)); cov.string_bytes.appendSliceAssumeCapacity(s); cov.string_bytes.appendAssumeCapacity(0); return result; diff --git a/lib/std/debug/Dwarf.zig b/lib/std/debug/Dwarf.zig index a5f290039f4c57138832360a7fecf4183ecc04b5..75b6d71f2d488fdf24fd53c96bab1fa5d8bb4573 100644 --- a/lib/std/debug/Dwarf.zig +++ b/lib/std/debug/Dwarf.zig @@ -323,7 +323,7 @@ const Func = struct { }; pub fn section(di: Dwarf, dwarf_section: Section.Id) ?[]const u8 { - return if (di.sections[@intFromEnum(dwarf_section)]) |s| s.data else null; + return if (di.sections[@backingInt(dwarf_section)]) |s| s.data else null; } pub fn deinit(di: *Dwarf, gpa: Allocator) void { diff --git a/lib/std/debug/Dwarf/Unwind/VirtualMachine.zig b/lib/std/debug/Dwarf/Unwind/VirtualMachine.zig index ff4d0967e9d8524f61c24ae89e2620eaa5c24f9f..8f84550d6c4479e3ce9e765e7a87fc549fb64989 100644 --- a/lib/std/debug/Dwarf/Unwind/VirtualMachine.zig +++ b/lib/std/debug/Dwarf/Unwind/VirtualMachine.zig @@ -459,7 +459,7 @@ pub const Instruction = union(enum) { .def_cfa_offset_sf => .{ .def_cfa_offset_sf = try reader.takeLeb128(i64) }, .def_cfa_expression => .{ .def_cfa_expr = try reader.takeLeb128(usize) }, - _ => switch (@intFromEnum(inst.low.extended)) { + _ => switch (@backingInt(inst.low.extended)) { 0x1C...0x3F => return error.UnimplementedUserOpcode, else => return error.InvalidOpcode, }, diff --git a/lib/std/debug/ElfFile.zig b/lib/std/debug/ElfFile.zig index 0ea4207c3521830ca4a1b9b1a1a0567cb97b5201..4f598e403e92d0ef482e340ef781bb4c03b50122 100644 --- a/lib/std/debug/ElfFile.zig +++ b/lib/std/debug/ElfFile.zig @@ -504,7 +504,7 @@ fn loadInner( @typeInfo(Section.Id).@"enum".field_values, ) |s_name, s_value| { if (std.mem.eql(u8, "." ++ s_name, name)) { - break @enumFromInt(s_value); + break @fromBackingInt(@intCast(s_value)); } } else continue; diff --git a/lib/std/debug/MachOFile.zig b/lib/std/debug/MachOFile.zig index 369ee8c4bc41bf87ac8f9c3356a7ab1c532bfdad..158e908183715fd06876b1191d4cad0cf2cd5301 100644 --- a/lib/std/debug/MachOFile.zig +++ b/lib/std/debug/MachOFile.zig @@ -516,10 +516,10 @@ fn loadOFile(gpa: Allocator, io: Io, o_file_name: []const u8) !OFile { }; } - if (sections[@intFromEnum(Dwarf.Section.Id.debug_info)] == null or - sections[@intFromEnum(Dwarf.Section.Id.debug_abbrev)] == null or - sections[@intFromEnum(Dwarf.Section.Id.debug_str)] == null or - sections[@intFromEnum(Dwarf.Section.Id.debug_line)] == null) + if (sections[@backingInt(Dwarf.Section.Id.debug_info)] == null or + sections[@backingInt(Dwarf.Section.Id.debug_abbrev)] == null or + sections[@backingInt(Dwarf.Section.Id.debug_str)] == null or + sections[@backingInt(Dwarf.Section.Id.debug_line)] == null) { return error.MissingDebugInfo; } diff --git a/lib/std/debug/Pdb.zig b/lib/std/debug/Pdb.zig index 5cd24287972d79904986d376de15a89ca23530b0..2fa0478e353cd1c86694a247baae7b689ce47bdf 100644 --- a/lib/std/debug/Pdb.zig +++ b/lib/std/debug/Pdb.zig @@ -935,7 +935,7 @@ pub fn getStreamById(self: *Pdb, id: u32) ?*MsfStream { } pub fn getStream(self: *Pdb, stream: pdb.StreamType) ?*MsfStream { - const id = @intFromEnum(stream); + const id = @backingInt(stream); return self.getStreamById(id); } @@ -1078,7 +1078,7 @@ const MsfStream = struct { return error.ReadFailed; }; - var remaining = @intFromEnum(limit); + var remaining = @backingInt(limit); while (remaining != 0) { const stream_len: usize = @min(remaining, ms.block_size - offset); const n = try ms.file_reader.interface.stream(w, .limited(stream_len)); @@ -1098,7 +1098,7 @@ const MsfStream = struct { } } - const total = @intFromEnum(limit) - remaining; + const total = @backingInt(limit) - remaining; ms.next_read_pos += total; return total; } diff --git a/lib/std/dynamic_library.zig b/lib/std/dynamic_library.zig index 3f39089510ee6ccf85f90625dfcf542cfb11bf70..0161644439803e7fc6dd4fbb1c1610235d97b5e0 100644 --- a/lib/std/dynamic_library.zig +++ b/lib/std/dynamic_library.zig @@ -530,7 +530,7 @@ fn checkver(def_arg: *elf.Verdef, vsym_arg: elf.Versym, vername: []const u8, str var def = def_arg; const vsym_index = vsym_arg.VERSION; while (true) { - if (0 == (def.flags & elf.VER_FLG_BASE) and @intFromEnum(def.ndx) == vsym_index) break; + if (0 == (def.flags & elf.VER_FLG_BASE) and @backingInt(def.ndx) == vsym_index) break; if (def.next == 0) return false; def = @ptrFromInt(@intFromPtr(def) + def.next); } diff --git a/lib/std/elf.zig b/lib/std/elf.zig index e965519255b1c8d4f2b96755204744bbc2bc46d9..294bde804cae719605bd9af7e65299a5b7185a05 100644 --- a/lib/std/elf.zig +++ b/lib/std/elf.zig @@ -268,8 +268,8 @@ pub const Versym = packed struct(u16) { VERSION: u15, HIDDEN: bool, - pub const LOCAL: Versym = @bitCast(@intFromEnum(VER_NDX.LOCAL)); - pub const GLOBAL: Versym = @bitCast(@intFromEnum(VER_NDX.GLOBAL)); + pub const LOCAL: Versym = @bitCast(@backingInt(VER_NDX.LOCAL)); + pub const GLOBAL: Versym = @bitCast(@backingInt(VER_NDX.GLOBAL)); }; pub const VER_NDX = enum(u16) { @@ -291,178 +291,178 @@ pub const VER_FLG_BASE = 1; pub const VER_FLG_WEAK = 2; /// Deprecated, use `@intFromEnum(std.elf.PT.NULL)` -pub const PT_NULL = @intFromEnum(std.elf.PT.NULL); +pub const PT_NULL = @backingInt(std.elf.PT.NULL); /// Deprecated, use `@intFromEnum(std.elf.PT.LOAD)` -pub const PT_LOAD = @intFromEnum(std.elf.PT.LOAD); +pub const PT_LOAD = @backingInt(std.elf.PT.LOAD); /// Deprecated, use `@intFromEnum(std.elf.PT.DYNAMIC)` -pub const PT_DYNAMIC = @intFromEnum(std.elf.PT.DYNAMIC); +pub const PT_DYNAMIC = @backingInt(std.elf.PT.DYNAMIC); /// Deprecated, use `@intFromEnum(std.elf.PT.INTERP)` -pub const PT_INTERP = @intFromEnum(std.elf.PT.INTERP); +pub const PT_INTERP = @backingInt(std.elf.PT.INTERP); /// Deprecated, use `@intFromEnum(std.elf.PT.NOTE)` -pub const PT_NOTE = @intFromEnum(std.elf.PT.NOTE); +pub const PT_NOTE = @backingInt(std.elf.PT.NOTE); /// Deprecated, use `@intFromEnum(std.elf.PT.SHLIB)` -pub const PT_SHLIB = @intFromEnum(std.elf.PT.SHLIB); +pub const PT_SHLIB = @backingInt(std.elf.PT.SHLIB); /// Deprecated, use `@intFromEnum(std.elf.PT.PHDR)` -pub const PT_PHDR = @intFromEnum(std.elf.PT.PHDR); +pub const PT_PHDR = @backingInt(std.elf.PT.PHDR); /// Deprecated, use `@intFromEnum(std.elf.PT.TLS)` -pub const PT_TLS = @intFromEnum(std.elf.PT.TLS); +pub const PT_TLS = @backingInt(std.elf.PT.TLS); /// Deprecated, use `std.elf.PT.NUM`. pub const PT_NUM = PT.NUM; /// Deprecated, use `@intFromEnum(std.elf.PT.LOOS)` -pub const PT_LOOS = @intFromEnum(std.elf.PT.LOOS); +pub const PT_LOOS = @backingInt(std.elf.PT.LOOS); /// Deprecated, use `@intFromEnum(std.elf.PT.GNU_EH_FRAME)` -pub const PT_GNU_EH_FRAME = @intFromEnum(std.elf.PT.GNU_EH_FRAME); +pub const PT_GNU_EH_FRAME = @backingInt(std.elf.PT.GNU_EH_FRAME); /// Deprecated, use `@intFromEnum(std.elf.PT.GNU_STACK)` -pub const PT_GNU_STACK = @intFromEnum(std.elf.PT.GNU_STACK); +pub const PT_GNU_STACK = @backingInt(std.elf.PT.GNU_STACK); /// Deprecated, use `@intFromEnum(std.elf.PT.GNU_RELRO)` -pub const PT_GNU_RELRO = @intFromEnum(std.elf.PT.GNU_RELRO); +pub const PT_GNU_RELRO = @backingInt(std.elf.PT.GNU_RELRO); /// Deprecated, use `@intFromEnum(std.elf.PT.LOSUNW)` -pub const PT_LOSUNW = @intFromEnum(std.elf.PT.LOSUNW); +pub const PT_LOSUNW = @backingInt(std.elf.PT.LOSUNW); /// Deprecated, use `@intFromEnum(std.elf.PT.SUNWBSS)` -pub const PT_SUNWBSS = @intFromEnum(std.elf.PT.SUNWBSS); +pub const PT_SUNWBSS = @backingInt(std.elf.PT.SUNWBSS); /// Deprecated, use `@intFromEnum(std.elf.PT.SUNWSTACK)` -pub const PT_SUNWSTACK = @intFromEnum(std.elf.PT.SUNWSTACK); +pub const PT_SUNWSTACK = @backingInt(std.elf.PT.SUNWSTACK); /// Deprecated, use `@intFromEnum(std.elf.PT.HISUNW)` -pub const PT_HISUNW = @intFromEnum(std.elf.PT.HISUNW); +pub const PT_HISUNW = @backingInt(std.elf.PT.HISUNW); /// Deprecated, use `@intFromEnum(std.elf.PT.HIOS)` -pub const PT_HIOS = @intFromEnum(std.elf.PT.HIOS); +pub const PT_HIOS = @backingInt(std.elf.PT.HIOS); /// Deprecated, use `@intFromEnum(std.elf.PT.LOPROC)` -pub const PT_LOPROC = @intFromEnum(std.elf.PT.LOPROC); +pub const PT_LOPROC = @backingInt(std.elf.PT.LOPROC); /// Deprecated, use `@intFromEnum(std.elf.PT.HIPROC)` -pub const PT_HIPROC = @intFromEnum(std.elf.PT.HIPROC); +pub const PT_HIPROC = @backingInt(std.elf.PT.HIPROC); pub const PN_XNUM = 0xffff; /// Deprecated, use `@intFromEnum(std.elf.SHT.NULL)` -pub const SHT_NULL = @intFromEnum(std.elf.SHT.NULL); +pub const SHT_NULL = @backingInt(std.elf.SHT.NULL); /// Deprecated, use `@intFromEnum(std.elf.SHT.PROGBITS)` -pub const SHT_PROGBITS = @intFromEnum(std.elf.SHT.PROGBITS); +pub const SHT_PROGBITS = @backingInt(std.elf.SHT.PROGBITS); /// Deprecated, use `@intFromEnum(std.elf.SHT.SYMTAB)` -pub const SHT_SYMTAB = @intFromEnum(std.elf.SHT.SYMTAB); +pub const SHT_SYMTAB = @backingInt(std.elf.SHT.SYMTAB); /// Deprecated, use `@intFromEnum(std.elf.SHT.STRTAB)` -pub const SHT_STRTAB = @intFromEnum(std.elf.SHT.STRTAB); +pub const SHT_STRTAB = @backingInt(std.elf.SHT.STRTAB); /// Deprecated, use `@intFromEnum(std.elf.SHT.RELA)` -pub const SHT_RELA = @intFromEnum(std.elf.SHT.RELA); +pub const SHT_RELA = @backingInt(std.elf.SHT.RELA); /// Deprecated, use `@intFromEnum(std.elf.SHT.HASH)` -pub const SHT_HASH = @intFromEnum(std.elf.SHT.HASH); +pub const SHT_HASH = @backingInt(std.elf.SHT.HASH); /// Deprecated, use `@intFromEnum(std.elf.SHT.DYNAMIC)` -pub const SHT_DYNAMIC = @intFromEnum(std.elf.SHT.DYNAMIC); +pub const SHT_DYNAMIC = @backingInt(std.elf.SHT.DYNAMIC); /// Deprecated, use `@intFromEnum(std.elf.SHT.NOTE)` -pub const SHT_NOTE = @intFromEnum(std.elf.SHT.NOTE); +pub const SHT_NOTE = @backingInt(std.elf.SHT.NOTE); /// Deprecated, use `@intFromEnum(std.elf.SHT.NOBITS)` -pub const SHT_NOBITS = @intFromEnum(std.elf.SHT.NOBITS); +pub const SHT_NOBITS = @backingInt(std.elf.SHT.NOBITS); /// Deprecated, use `@intFromEnum(std.elf.SHT.REL)` -pub const SHT_REL = @intFromEnum(std.elf.SHT.REL); +pub const SHT_REL = @backingInt(std.elf.SHT.REL); /// Deprecated, use `@intFromEnum(std.elf.SHT.SHLIB)` -pub const SHT_SHLIB = @intFromEnum(std.elf.SHT.SHLIB); +pub const SHT_SHLIB = @backingInt(std.elf.SHT.SHLIB); /// Deprecated, use `@intFromEnum(std.elf.SHT.DYNSYM)` -pub const SHT_DYNSYM = @intFromEnum(std.elf.SHT.DYNSYM); +pub const SHT_DYNSYM = @backingInt(std.elf.SHT.DYNSYM); /// Deprecated, use `@intFromEnum(std.elf.SHT.INIT_ARRAY)` -pub const SHT_INIT_ARRAY = @intFromEnum(std.elf.SHT.INIT_ARRAY); +pub const SHT_INIT_ARRAY = @backingInt(std.elf.SHT.INIT_ARRAY); /// Deprecated, use `@intFromEnum(std.elf.SHT.FINI_ARRAY)` -pub const SHT_FINI_ARRAY = @intFromEnum(std.elf.SHT.FINI_ARRAY); +pub const SHT_FINI_ARRAY = @backingInt(std.elf.SHT.FINI_ARRAY); /// Deprecated, use `@intFromEnum(std.elf.SHT.PREINIT_ARRAY)` -pub const SHT_PREINIT_ARRAY = @intFromEnum(std.elf.SHT.PREINIT_ARRAY); +pub const SHT_PREINIT_ARRAY = @backingInt(std.elf.SHT.PREINIT_ARRAY); /// Deprecated, use `@intFromEnum(std.elf.SHT.GROUP)` -pub const SHT_GROUP = @intFromEnum(std.elf.SHT.GROUP); +pub const SHT_GROUP = @backingInt(std.elf.SHT.GROUP); /// Deprecated, use `@intFromEnum(std.elf.SHT.SYMTAB_SHNDX)` -pub const SHT_SYMTAB_SHNDX = @intFromEnum(std.elf.SHT.SYMTAB_SHNDX); +pub const SHT_SYMTAB_SHNDX = @backingInt(std.elf.SHT.SYMTAB_SHNDX); /// Deprecated, use `@intFromEnum(std.elf.SHT.RELR)` -pub const SHT_RELR = @intFromEnum(std.elf.SHT.RELR); +pub const SHT_RELR = @backingInt(std.elf.SHT.RELR); /// Deprecated, use `std.elf.SHT.NUM`. pub const SHT_NUM = SHT.NUM; /// Deprecated, use `@intFromEnum(std.elf.SHT.LOOS)` -pub const SHT_LOOS = @intFromEnum(std.elf.SHT.LOOS); +pub const SHT_LOOS = @backingInt(std.elf.SHT.LOOS); /// Deprecated, use `@intFromEnum(std.elf.SHT.LLVM_ADDRSIG)` -pub const SHT_LLVM_ADDRSIG = @intFromEnum(std.elf.SHT.LLVM_ADDRSIG); +pub const SHT_LLVM_ADDRSIG = @backingInt(std.elf.SHT.LLVM_ADDRSIG); /// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_HASH)` -pub const SHT_GNU_HASH = @intFromEnum(std.elf.SHT.GNU_HASH); +pub const SHT_GNU_HASH = @backingInt(std.elf.SHT.GNU_HASH); /// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_VERDEF)` -pub const SHT_GNU_VERDEF = @intFromEnum(std.elf.SHT.GNU_VERDEF); +pub const SHT_GNU_VERDEF = @backingInt(std.elf.SHT.GNU_VERDEF); /// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_VERNEED)` -pub const SHT_GNU_VERNEED = @intFromEnum(std.elf.SHT.GNU_VERNEED); +pub const SHT_GNU_VERNEED = @backingInt(std.elf.SHT.GNU_VERNEED); /// Deprecated, use `@intFromEnum(std.elf.SHT.GNU_VERSYM)` -pub const SHT_GNU_VERSYM = @intFromEnum(std.elf.SHT.GNU_VERSYM); +pub const SHT_GNU_VERSYM = @backingInt(std.elf.SHT.GNU_VERSYM); /// Deprecated, use `@intFromEnum(std.elf.SHT.HIOS)` -pub const SHT_HIOS = @intFromEnum(std.elf.SHT.HIOS); +pub const SHT_HIOS = @backingInt(std.elf.SHT.HIOS); /// Deprecated, use `@intFromEnum(std.elf.SHT.LOPROC)` -pub const SHT_LOPROC = @intFromEnum(std.elf.SHT.LOPROC); +pub const SHT_LOPROC = @backingInt(std.elf.SHT.LOPROC); /// Deprecated, use `@intFromEnum(std.elf.SHT.X86_64_UNWIND)` -pub const SHT_X86_64_UNWIND = @intFromEnum(std.elf.SHT.X86_64_UNWIND); +pub const SHT_X86_64_UNWIND = @backingInt(std.elf.SHT.X86_64_UNWIND); /// Deprecated, use `@intFromEnum(std.elf.SHT.HIPROC)` -pub const SHT_HIPROC = @intFromEnum(std.elf.SHT.HIPROC); +pub const SHT_HIPROC = @backingInt(std.elf.SHT.HIPROC); /// Deprecated, use `@intFromEnum(std.elf.SHT.LOUSER)` -pub const SHT_LOUSER = @intFromEnum(std.elf.SHT.LOUSER); +pub const SHT_LOUSER = @backingInt(std.elf.SHT.LOUSER); /// Deprecated, use `@intFromEnum(std.elf.SHT.HIUSER)` -pub const SHT_HIUSER = @intFromEnum(std.elf.SHT.HIUSER); +pub const SHT_HIUSER = @backingInt(std.elf.SHT.HIUSER); // Note type for .note.gnu.build_id pub const NT_GNU_BUILD_ID = 3; /// Deprecated, use `@intFromEnum(std.elf.STB.LOCAL)` -pub const STB_LOCAL = @intFromEnum(STB.LOCAL); +pub const STB_LOCAL = @backingInt(STB.LOCAL); /// Deprecated, use `@intFromEnum(std.elf.STB.GLOBAL)` -pub const STB_GLOBAL = @intFromEnum(STB.GLOBAL); +pub const STB_GLOBAL = @backingInt(STB.GLOBAL); /// Deprecated, use `@intFromEnum(std.elf.STB.WEAK)` -pub const STB_WEAK = @intFromEnum(STB.WEAK); +pub const STB_WEAK = @backingInt(STB.WEAK); /// Deprecated, use `std.elf.STB.NUM` pub const STB_NUM = STB.NUM; /// Deprecated, use `@intFromEnum(std.elf.STB.LOOS)` -pub const STB_LOOS = @intFromEnum(STB.LOOS); +pub const STB_LOOS = @backingInt(STB.LOOS); /// Deprecated, use `@intFromEnum(std.elf.STB.GNU_UNIQUE)` -pub const STB_GNU_UNIQUE = @intFromEnum(STB.GNU_UNIQUE); +pub const STB_GNU_UNIQUE = @backingInt(STB.GNU_UNIQUE); /// Deprecated, use `@intFromEnum(std.elf.STB.HIOS)` -pub const STB_HIOS = @intFromEnum(STB.HIOS); +pub const STB_HIOS = @backingInt(STB.HIOS); /// Deprecated, use `@intFromEnum(std.elf.STB.LOPROC)` -pub const STB_LOPROC = @intFromEnum(STB.LOPROC); +pub const STB_LOPROC = @backingInt(STB.LOPROC); /// Deprecated, use `@intFromEnum(std.elf.STB.HIPROC)` -pub const STB_HIPROC = @intFromEnum(STB.HIPROC); +pub const STB_HIPROC = @backingInt(STB.HIPROC); /// Deprecated, use `@intFromEnum(std.elf.STB.MIPS_SPLIT_COMMON)` -pub const STB_MIPS_SPLIT_COMMON = @intFromEnum(STB.MIBS_SPLIT_COMMON); +pub const STB_MIPS_SPLIT_COMMON = @backingInt(STB.MIBS_SPLIT_COMMON); /// Deprecated, use `@intFromEnum(std.elf.STT.NOTYPE)` -pub const STT_NOTYPE = @intFromEnum(STT.NOTYPE); +pub const STT_NOTYPE = @backingInt(STT.NOTYPE); /// Deprecated, use `@intFromEnum(std.elf.STT.OBJECT)` -pub const STT_OBJECT = @intFromEnum(STT.OBJECT); +pub const STT_OBJECT = @backingInt(STT.OBJECT); /// Deprecated, use `@intFromEnum(std.elf.STT.FUNC)` -pub const STT_FUNC = @intFromEnum(STT.FUNC); +pub const STT_FUNC = @backingInt(STT.FUNC); /// Deprecated, use `@intFromEnum(std.elf.STT.SECTION)` -pub const STT_SECTION = @intFromEnum(STT.SECTION); +pub const STT_SECTION = @backingInt(STT.SECTION); /// Deprecated, use `@intFromEnum(std.elf.STT.FILE)` -pub const STT_FILE = @intFromEnum(STT.FILE); +pub const STT_FILE = @backingInt(STT.FILE); /// Deprecated, use `@intFromEnum(std.elf.STT.COMMON)` -pub const STT_COMMON = @intFromEnum(STT.COMMON); +pub const STT_COMMON = @backingInt(STT.COMMON); /// Deprecated, use `@intFromEnum(std.elf.STT.TLS)` -pub const STT_TLS = @intFromEnum(STT.TLS); +pub const STT_TLS = @backingInt(STT.TLS); /// Deprecated, use `std.elf.STT.NUM` pub const STT_NUM = STT.NUM; /// Deprecated, use `@intFromEnum(std.elf.STT.LOOS)` -pub const STT_LOOS = @intFromEnum(STT.LOOS); +pub const STT_LOOS = @backingInt(STT.LOOS); /// Deprecated, use `@intFromEnum(std.elf.STT.GNU_IFUNC)` -pub const STT_GNU_IFUNC = @intFromEnum(STT.GNU_IFUNC); +pub const STT_GNU_IFUNC = @backingInt(STT.GNU_IFUNC); /// Deprecated, use `@intFromEnum(std.elf.STT.HIOS)` -pub const STT_HIOS = @intFromEnum(STT.HIOS); +pub const STT_HIOS = @backingInt(STT.HIOS); /// Deprecated, use `@intFromEnum(std.elf.STT.LOPROC)` -pub const STT_LOPROC = @intFromEnum(STT.LOPROC); +pub const STT_LOPROC = @backingInt(STT.LOPROC); /// Deprecated, use `@intFromEnum(std.elf.STT.HIPROC)` -pub const STT_HIPROC = @intFromEnum(STT.HIPROC); +pub const STT_HIPROC = @backingInt(STT.HIPROC); /// Deprecated, use `@intFromEnum(std.elf.STT.SPARC_REGISTER)` -pub const STT_SPARC_REGISTER = @intFromEnum(STT.SPARC_REGISTER); +pub const STT_SPARC_REGISTER = @backingInt(STT.SPARC_REGISTER); /// Deprecated, use `@intFromEnum(std.elf.STT.PARISC_MILLICODE)` -pub const STT_PARISC_MILLICODE = @intFromEnum(STT.PARISC_MILLICODE); +pub const STT_PARISC_MILLICODE = @backingInt(STT.PARISC_MILLICODE); /// Deprecated, use `@intFromEnum(std.elf.STT.HP_OPAQUE)` -pub const STT_HP_OPAQUE = @intFromEnum(STT.HP_OPAQUE); +pub const STT_HP_OPAQUE = @backingInt(STT.HP_OPAQUE); /// Deprecated, use `@intFromEnum(std.elf.STT.HP_STUB)` -pub const STT_HP_STUB = @intFromEnum(STT.HP_STUB); +pub const STT_HP_STUB = @backingInt(STT.HP_STUB); /// Deprecated, use `@intFromEnum(std.elf.STT.ARM_TFUNC)` -pub const STT_ARM_TFUNC = @intFromEnum(STT.ARM_TFUNC); +pub const STT_ARM_TFUNC = @backingInt(STT.ARM_TFUNC); /// Deprecated, use `@intFromEnum(std.elf.STT.ARM_16BIT)` -pub const STT_ARM_16BIT = @intFromEnum(STT.ARM_16BIT); +pub const STT_ARM_16BIT = @backingInt(STT.ARM_16BIT); pub const PT = enum(Word) { /// Program header table entry unused @@ -487,29 +487,29 @@ pub const PT = enum(Word) { pub const NUM = @typeInfo(PT).@"enum".field_names.len; /// Start of OS-specific - pub const LOOS: PT = @enumFromInt(0x60000000); + pub const LOOS: PT = @fromBackingInt(@intCast(0x60000000)); /// End of OS-specific - pub const HIOS: PT = @enumFromInt(0x6fffffff); + pub const HIOS: PT = @fromBackingInt(@intCast(0x6fffffff)); /// GCC .eh_frame_hdr segment - pub const GNU_EH_FRAME: PT = @enumFromInt(0x6474e550); + pub const GNU_EH_FRAME: PT = @fromBackingInt(@intCast(0x6474e550)); /// Indicates stack executability - pub const GNU_STACK: PT = @enumFromInt(0x6474e551); + pub const GNU_STACK: PT = @fromBackingInt(@intCast(0x6474e551)); /// Read-only after relocation - pub const GNU_RELRO: PT = @enumFromInt(0x6474e552); + pub const GNU_RELRO: PT = @fromBackingInt(@intCast(0x6474e552)); - pub const LOSUNW: PT = @enumFromInt(0x6ffffffa); - pub const HISUNW: PT = @enumFromInt(0x6fffffff); + pub const LOSUNW: PT = @fromBackingInt(@intCast(0x6ffffffa)); + pub const HISUNW: PT = @fromBackingInt(@intCast(0x6fffffff)); /// Sun specific segment - pub const SUNWBSS: PT = @enumFromInt(0x6ffffffa); + pub const SUNWBSS: PT = @fromBackingInt(@intCast(0x6ffffffa)); /// Stack segment - pub const SUNWSTACK: PT = @enumFromInt(0x6ffffffb); + pub const SUNWSTACK: PT = @fromBackingInt(@intCast(0x6ffffffb)); /// Start of processor-specific - pub const LOPROC: PT = @enumFromInt(0x70000000); + pub const LOPROC: PT = @fromBackingInt(@intCast(0x70000000)); /// End of processor-specific - pub const HIPROC: PT = @enumFromInt(0x7fffffff); + pub const HIPROC: PT = @fromBackingInt(@intCast(0x7fffffff)); }; pub const SHT = enum(Word) { @@ -555,34 +555,34 @@ pub const SHT = enum(Word) { pub const NUM = @typeInfo(SHT).@"enum".field_names.len; /// Start of OS-specific - pub const LOOS: SHT = @enumFromInt(0x60000000); + pub const LOOS: SHT = @fromBackingInt(@intCast(0x60000000)); /// End of OS-specific - pub const HIOS: SHT = @enumFromInt(0x6fffffff); + pub const HIOS: SHT = @fromBackingInt(@intCast(0x6fffffff)); /// LLVM address-significance table - pub const LLVM_ADDRSIG: SHT = @enumFromInt(0x6fff4c03); + pub const LLVM_ADDRSIG: SHT = @fromBackingInt(@intCast(0x6fff4c03)); /// GNU hash table - pub const GNU_HASH: SHT = @enumFromInt(0x6ffffff6); + pub const GNU_HASH: SHT = @fromBackingInt(@intCast(0x6ffffff6)); /// GNU version definition table - pub const GNU_VERDEF: SHT = @enumFromInt(0x6ffffffd); + pub const GNU_VERDEF: SHT = @fromBackingInt(@intCast(0x6ffffffd)); /// GNU needed versions table - pub const GNU_VERNEED: SHT = @enumFromInt(0x6ffffffe); + pub const GNU_VERNEED: SHT = @fromBackingInt(@intCast(0x6ffffffe)); /// GNU symbol version table - pub const GNU_VERSYM: SHT = @enumFromInt(0x6fffffff); + pub const GNU_VERSYM: SHT = @fromBackingInt(@intCast(0x6fffffff)); /// Start of processor-specific - pub const LOPROC: SHT = @enumFromInt(0x70000000); + pub const LOPROC: SHT = @fromBackingInt(@intCast(0x70000000)); /// End of processor-specific - pub const HIPROC: SHT = @enumFromInt(0x7fffffff); + pub const HIPROC: SHT = @fromBackingInt(@intCast(0x7fffffff)); /// Unwind information - pub const X86_64_UNWIND: SHT = @enumFromInt(0x70000001); + pub const X86_64_UNWIND: SHT = @fromBackingInt(@intCast(0x70000001)); /// Start of application-specific - pub const LOUSER: SHT = @enumFromInt(0x80000000); + pub const LOUSER: SHT = @fromBackingInt(@intCast(0x80000000)); /// End of application-specific - pub const HIUSER: SHT = @enumFromInt(0xffffffff); + pub const HIUSER: SHT = @fromBackingInt(@intCast(0xffffffff)); }; pub const STB = enum(u4) { @@ -598,19 +598,19 @@ pub const STB = enum(u4) { pub const NUM = @typeInfo(STB).@"enum".field_names.len; /// Start of OS-specific - pub const LOOS: STB = @enumFromInt(10); + pub const LOOS: STB = @fromBackingInt(@intCast(10)); /// End of OS-specific - pub const HIOS: STB = @enumFromInt(12); + pub const HIOS: STB = @fromBackingInt(@intCast(12)); /// Unique symbol - pub const GNU_UNIQUE: STB = @enumFromInt(@intFromEnum(LOOS) + 0); + pub const GNU_UNIQUE: STB = @fromBackingInt(@intCast(@backingInt(LOOS) + 0)); /// Start of processor-specific - pub const LOPROC: STB = @enumFromInt(13); + pub const LOPROC: STB = @fromBackingInt(@intCast(13)); /// End of processor-specific - pub const HIPROC: STB = @enumFromInt(15); + pub const HIPROC: STB = @fromBackingInt(@intCast(15)); - pub const MIPS_SPLIT_COMMON: STB = @enumFromInt(@intFromEnum(LOPROC) + 0); + pub const MIPS_SPLIT_COMMON: STB = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0)); }; pub const STT = enum(u4) { @@ -634,27 +634,27 @@ pub const STT = enum(u4) { pub const NUM = @typeInfo(STT).@"enum".field_names.len; /// Start of OS-specific - pub const LOOS: STT = @enumFromInt(10); + pub const LOOS: STT = @fromBackingInt(@intCast(10)); /// End of OS-specific - pub const HIOS: STT = @enumFromInt(12); + pub const HIOS: STT = @fromBackingInt(@intCast(12)); /// Symbol is indirect code object - pub const GNU_IFUNC: STT = @enumFromInt(@intFromEnum(LOOS) + 0); + pub const GNU_IFUNC: STT = @fromBackingInt(@intCast(@backingInt(LOOS) + 0)); - pub const HP_OPAQUE: STT = @enumFromInt(@intFromEnum(LOOS) + 1); - pub const HP_STUB: STT = @enumFromInt(@intFromEnum(LOOS) + 2); + pub const HP_OPAQUE: STT = @fromBackingInt(@intCast(@backingInt(LOOS) + 1)); + pub const HP_STUB: STT = @fromBackingInt(@intCast(@backingInt(LOOS) + 2)); /// Start of processor-specific - pub const LOPROC: STT = @enumFromInt(13); + pub const LOPROC: STT = @fromBackingInt(@intCast(13)); /// End of processor-specific - pub const HIPROC: STT = @enumFromInt(15); + pub const HIPROC: STT = @fromBackingInt(@intCast(15)); - pub const SPARC_REGISTER: STT = @enumFromInt(@intFromEnum(LOPROC) + 0); + pub const SPARC_REGISTER: STT = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0)); - pub const PARISC_MILLICODE: STT = @enumFromInt(@intFromEnum(LOPROC) + 0); + pub const PARISC_MILLICODE: STT = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0)); - pub const ARM_TFUNC: STT = @enumFromInt(@intFromEnum(LOPROC) + 0); - pub const ARM_16BIT: STT = @enumFromInt(@intFromEnum(HIPROC) + 2); + pub const ARM_TFUNC: STT = @fromBackingInt(@intCast(@backingInt(LOPROC) + 0)); + pub const ARM_16BIT: STT = @fromBackingInt(@intCast(@backingInt(HIPROC) + 2)); }; pub const STV = enum(u3) { @@ -823,7 +823,7 @@ pub const Header = struct { else => @compileError("bad type"), }, .endian = endian, - .os_abi = @enumFromInt(hdr.e_ident[EI.OSABI]), + .os_abi = @fromBackingInt(@intCast(hdr.e_ident[EI.OSABI])), .abi_version = hdr.e_ident[EI.ABIVERSION], .type = hdr.e_type, .machine = hdr.e_machine, @@ -1629,11 +1629,11 @@ pub const Ident = extern struct { }; /// Deprecated, use `@intFromEnum(std.elf.CLASS.NONE)` -pub const ELFCLASSNONE = @intFromEnum(CLASS.NONE); +pub const ELFCLASSNONE = @backingInt(CLASS.NONE); /// Deprecated, use `@intFromEnum(std.elf.CLASS.@"32")` -pub const ELFCLASS32 = @intFromEnum(CLASS.@"32"); +pub const ELFCLASS32 = @backingInt(CLASS.@"32"); /// Deprecated, use `@intFromEnum(std.elf.CLASS.@"64")` -pub const ELFCLASS64 = @intFromEnum(CLASS.@"64"); +pub const ELFCLASS64 = @backingInt(CLASS.@"64"); /// Deprecated, use `@intFromEnum(std.elf.CLASS.NUM)` pub const ELFCLASSNUM = CLASS.NUM; pub const CLASS = enum(u8) { @@ -1662,11 +1662,11 @@ pub const CLASS = enum(u8) { }; /// Deprecated, use `@intFromEnum(std.elf.DATA.NONE)` -pub const ELFDATANONE = @intFromEnum(DATA.NONE); +pub const ELFDATANONE = @backingInt(DATA.NONE); /// Deprecated, use `@intFromEnum(std.elf.DATA.@"2LSB")` -pub const ELFDATA2LSB = @intFromEnum(DATA.@"2LSB"); +pub const ELFDATA2LSB = @backingInt(DATA.@"2LSB"); /// Deprecated, use `@intFromEnum(std.elf.DATA.@"2MSB")` -pub const ELFDATA2MSB = @intFromEnum(DATA.@"2MSB"); +pub const ELFDATA2MSB = @backingInt(DATA.@"2MSB"); /// Deprecated, use `@intFromEnum(std.elf.DATA.NUM)` pub const ELFDATANUM = DATA.NUM; pub const DATA = enum(u8) { diff --git a/lib/std/enums.zig b/lib/std/enums.zig index 47e0e4d0bb9266e5cd3d6a5ce5409b276e28527a..551cf71fcdd1c757b0e8a7db34fa11a93692a835 100644 --- a/lib/std/enums.zig +++ b/lib/std/enums.zig @@ -11,7 +11,7 @@ pub fn fromInt(comptime E: type, integer: anytype) ?E { const enum_info = @typeInfo(E).@"enum"; if (enum_info.mode == .nonexhaustive) { if (std.math.cast(enum_info.tag_type, integer)) |tag| { - return @enumFromInt(tag); + return @fromBackingInt(@intCast(tag)); } return null; } @@ -21,7 +21,7 @@ pub fn fromInt(comptime E: type, integer: anytype) ?E { // without requiring an inline loop. // This generates better machine code. for (values(E)) |value| { - if (@intFromEnum(value) == integer) return value; + if (@backingInt(value) == integer) return value; } return null; } @@ -43,7 +43,7 @@ pub inline fn valuesFromFields(comptime E: type, comptime field_values: []const @setEvalBranchQuota(@typeInfo(E).@"enum".field_names.len + eval_branch_quota_cushion); var result: [field_values.len]E = undefined; for (&result, field_values) |*r, f_value| { - r.* = @enumFromInt(f_value); + r.* = @fromBackingInt(@intCast(f_value)); } const final = result; return &final; @@ -64,7 +64,7 @@ pub fn tagName(comptime E: type, e: E) ?[:0]const u8 { const field_values = @typeInfo(E).@"enum".field_values; @setEvalBranchQuota(field_names.len); return inline for (field_names, field_values) |f_name, f_value| { - if (@intFromEnum(e) == f_value) break f_name; + if (@backingInt(e) == f_value) break f_name; } else null; } @@ -72,7 +72,7 @@ test tagName { const E = enum(u8) { a, b, _ }; try testing.expect(tagName(E, .a) != null); try testing.expectEqualStrings("a", tagName(E, .a).?); - try testing.expect(tagName(E, @as(E, @enumFromInt(42))) == null); + try testing.expect(tagName(E, @as(E, @fromBackingInt(@intCast(42)))) == null); } /// Determines the length of a direct-mapped enum array, indexed by @@ -168,7 +168,7 @@ pub fn directEnumArrayDefault( var result: [len]Data = @splat(default orelse undefined); inline for (@typeInfo(@TypeOf(init_values)).@"struct".field_names) |f_name| { const enum_value = @field(E, f_name); - const index = @as(usize, @intCast(@intFromEnum(enum_value))); + const index = @as(usize, @intCast(@backingInt(enum_value))); result[index] = @field(init_values, f_name); } return result; @@ -222,8 +222,8 @@ test fromInt { try testing.expect(fromInt(E1, zero).? == E1.A); try testing.expect(fromInt(E2, one).? == E2.B); try testing.expect(fromInt(E3, zero).? == E3.A); - try testing.expect(fromInt(E3, 127).? == @as(E3, @enumFromInt(127))); - try testing.expect(fromInt(E3, -128).? == @as(E3, @enumFromInt(-128))); + try testing.expect(fromInt(E3, 127).? == @as(E3, @fromBackingInt(@intCast(127)))); + try testing.expect(fromInt(E3, -128).? == @as(E3, @fromBackingInt(@intCast(-128)))); try testing.expectEqual(null, fromInt(E1, one)); try testing.expectEqual(null, fromInt(E3, 128)); try testing.expectEqual(null, fromInt(E3, -129)); @@ -677,7 +677,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type { const info = @typeInfo(E).@"enum"; inline for (info.field_names, info.field_values) |field_name, field_value| { const c = @field(init_counts, field_name); - const key: E = @enumFromInt(field_value); + const key: E = @fromBackingInt(@intCast(field_value)); self.counts.set(key, c); } return self; @@ -746,7 +746,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type { /// asserts operation will not overflow any key. pub fn addSetAssertSafe(self: *Self, other: Self) void { inline for (@typeInfo(E).@"enum".field_values) |field_value| { - const key = @as(E, @enumFromInt(field_value)); + const key = @as(E, @fromBackingInt(@intCast(field_value))); self.addAssertSafe(key, other.getCount(key)); } } @@ -754,7 +754,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type { /// Increases the all key counts by given multiset. pub fn addSet(self: *Self, other: Self) error{Overflow}!void { inline for (@typeInfo(E).@"enum".field_values) |field_value| { - const key = @as(E, @enumFromInt(field_value)); + const key = @as(E, @fromBackingInt(@intCast(field_value))); try self.add(key, other.getCount(key)); } } @@ -764,7 +764,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type { /// then that key will have a key count of zero. pub fn removeSet(self: *Self, other: Self) void { inline for (@typeInfo(E).@"enum".field_values) |field_value| { - const key = @as(E, @enumFromInt(field_value)); + const key = @as(E, @fromBackingInt(@intCast(field_value))); self.remove(key, other.getCount(key)); } } @@ -773,7 +773,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type { /// given multiset. pub fn eql(self: Self, other: Self) bool { inline for (@typeInfo(E).@"enum".field_values) |field_value| { - const key = @as(E, @enumFromInt(field_value)); + const key = @as(E, @fromBackingInt(@intCast(field_value))); if (self.getCount(key) != other.getCount(key)) { return false; } @@ -785,7 +785,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type { /// equal to the given multiset. pub fn subsetOf(self: Self, other: Self) bool { inline for (@typeInfo(E).@"enum".field_values) |field_value| { - const key = @as(E, @enumFromInt(field_value)); + const key = @as(E, @fromBackingInt(@intCast(field_value))); if (self.getCount(key) > other.getCount(key)) { return false; } @@ -797,7 +797,7 @@ pub fn BoundedEnumMultiset(comptime E: type, comptime CountSize: type) type { /// equal to the given multiset. pub fn supersetOf(self: Self, other: Self) bool { inline for (@typeInfo(E).@"enum".field_values) |field_value| { - const key = @as(E, @enumFromInt(field_value)); + const key = @as(E, @fromBackingInt(@intCast(field_value))); if (self.getCount(key) < other.getCount(key)) { return false; } @@ -1284,18 +1284,18 @@ pub fn EnumIndexer(comptime E: type) type { pub fn indexOf(e: E) usize { if (backing_int_sign == .unsigned) - return @intFromEnum(e); + return @backingInt(e); - return if (@intFromEnum(e) < 0) - @intCast(@intFromEnum(e) - min_value) + return if (@backingInt(e) < 0) + @intCast(@backingInt(e) - min_value) else - @as(RangeType, -min_value) + @as(RangeType, @intCast(@intFromEnum(e))); + @as(RangeType, -min_value) + @as(RangeType, @intCast(@backingInt(e))); } pub fn keyForIndex(i: usize) E { if (backing_int_sign == .unsigned) - return @enumFromInt(i); + return @fromBackingInt(@intCast(i)); - return @enumFromInt(@as(@Int(.signed, @bitSizeOf(RangeType) + 1), @intCast(i)) + min_value); + return @fromBackingInt(@intCast(@as(@Int(.signed, @bitSizeOf(RangeType) + 1), @intCast(i)) + min_value)); } }; } @@ -1330,14 +1330,14 @@ pub fn EnumIndexer(comptime E: type) type { pub const Key = E; pub const count: comptime_int = fields_len; pub fn indexOf(e: E) usize { - return @as(usize, @intCast(@intFromEnum(e) - min)); + return @as(usize, @intCast(@backingInt(e) - min)); } pub fn keyForIndex(i: usize) E { // TODO fix addition semantics. This calculation // gives up some safety to avoid artificially limiting // the range of signed enum values to max_isize. const enum_value = if (min < 0) @as(isize, @bitCast(i)) +% min else i + min; - return @as(E, @enumFromInt(@as(@typeInfo(E).@"enum".tag_type, @intCast(enum_value)))); + return @as(E, @fromBackingInt(@intCast(@as(@typeInfo(E).@"enum".tag_type, @intCast(enum_value))))); } }; } @@ -1384,8 +1384,8 @@ test "EnumIndexer non-exhaustive" { }; const Indexer = EnumIndexer(E); - const min_tag: E = @enumFromInt(std.math.minInt(BackingInt)); - const max_tag: E = @enumFromInt(std.math.maxInt(BackingInt)); + const min_tag: E = @fromBackingInt(@intCast(std.math.minInt(BackingInt))); + const max_tag: E = @fromBackingInt(@intCast(std.math.maxInt(BackingInt))); const RangedType = @Int(.unsigned, @bitSizeOf(BackingInt)); const max_index: comptime_int = std.math.maxInt(RangedType); diff --git a/lib/std/fmt.zig b/lib/std/fmt.zig index edb1de18fc27228353d8fccea3227893c3eeeac3..92e04955ed48a2628f78ae040326c3a853f88b11 100644 --- a/lib/std/fmt.zig +++ b/lib/std/fmt.zig @@ -947,15 +947,15 @@ test "non-exhaustive enum" { }; try expectFmt("enum: .One\n", "enum: {}\n", .{Enum.One}); try expectFmt("enum: .Two\n", "enum: {}\n", .{Enum.Two}); - try expectFmt("enum: @enumFromInt(4660)\n", "enum: {}\n", .{@as(Enum, @enumFromInt(0x1234))}); + try expectFmt("enum: @enumFromInt(4660)\n", "enum: {}\n", .{@as(Enum, @fromBackingInt(@intCast(0x1234)))}); try expectFmt("enum: f\n", "enum: {x}\n", .{Enum.One}); try expectFmt("enum: beef\n", "enum: {x}\n", .{Enum.Two}); try expectFmt("enum: BEEF\n", "enum: {X}\n", .{Enum.Two}); - try expectFmt("enum: 1234\n", "enum: {x}\n", .{@as(Enum, @enumFromInt(0x1234))}); + try expectFmt("enum: 1234\n", "enum: {x}\n", .{@as(Enum, @fromBackingInt(@intCast(0x1234)))}); try expectFmt("enum: 15\n", "enum: {d}\n", .{Enum.One}); try expectFmt("enum: 48879\n", "enum: {d}\n", .{Enum.Two}); - try expectFmt("enum: 4660\n", "enum: {d}\n", .{@as(Enum, @enumFromInt(0x1234))}); + try expectFmt("enum: 4660\n", "enum: {d}\n", .{@as(Enum, @fromBackingInt(@intCast(0x1234)))}); } test "float.scientific" { diff --git a/lib/std/hash/auto_hash.zig b/lib/std/hash/auto_hash.zig index 31f565ea93f9440316e11f2656a3d38e0f14475d..3964ad5f946f899a51cbfdefb38cb42d2973b74d 100644 --- a/lib/std/hash/auto_hash.zig +++ b/lib/std/hash/auto_hash.zig @@ -106,7 +106,7 @@ pub fn hash(hasher: anytype, key: anytype, comptime strat: HashStrategy) void { }, .bool => hash(hasher, @intFromBool(key), strat), - .@"enum" => hash(hasher, @intFromEnum(key), strat), + .@"enum" => hash(hasher, @backingInt(key), strat), .error_set => hash(hasher, @intFromError(key), strat), .@"anyframe", .@"fn" => hash(hasher, @intFromPtr(key), strat), diff --git a/lib/std/heap.zig b/lib/std/heap.zig index 401026a6fdb3e0f56b12305b2ef3104b9da54377..45c509e09bb74bcb834543461b9ad99dc54ce5fd 100644 --- a/lib/std/heap.zig +++ b/lib/std/heap.zig @@ -78,7 +78,7 @@ pub fn defaultQueryPageSize() usize { if (size > 0) return size; size = size: switch (builtin.os.tag) { .linux => if (builtin.link_libc) - @max(std.c.sysconf(@intFromEnum(std.c._SC.PAGESIZE)), 0) + @max(std.c.sysconf(@backingInt(std.c._SC.PAGESIZE)), 0) else std.os.linux.getauxval(std.elf.AT_PAGESZ), .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => { @@ -109,7 +109,7 @@ pub fn defaultQueryPageSize() usize { } }, else => if (builtin.link_libc) - @max(std.c.sysconf(@intFromEnum(std.c._SC.PAGESIZE)), 0) + @max(std.c.sysconf(@backingInt(std.c._SC.PAGESIZE)), 0) else if (builtin.os.tag == .freestanding or builtin.os.tag == .other) @compileError("unsupported target: freestanding/other") else diff --git a/lib/std/heap/ArenaAllocator.zig b/lib/std/heap/ArenaAllocator.zig index bca6bd2fc081e0839a2f5d4ed8f7e645bc59fb34..398c17d071b7b38a813b34dea634919163894652 100644 --- a/lib/std/heap/ArenaAllocator.zig +++ b/lib/std/heap/ArenaAllocator.zig @@ -765,7 +765,7 @@ fn fuzzMultiThreaded(fuzz_init: FuzzContext.Init, smith: *std.testing.Smith) any .@"1", .fromByteUnits(2 * std.heap.page_size_max), ), - @enumFromInt(alloc_index), + @fromBackingInt(@intCast(alloc_index)), }) catch unreachable; }, .resize => group.concurrent(io, FuzzContext.doOneResize, .{ &ctx, nextLen(smith) }) catch unreachable, @@ -877,7 +877,7 @@ const FuzzContext = struct { for (ctx.allocs[0..n_allocs]) |allocation| { const len: usize = switch (allocation.common.len) { .free => continue, - _ => |len| @intFromEnum(len), + _ => |len| @backingInt(len), }; const control = allocation.control_ptr[0..len]; const sample = allocation.sample_ptr[0..len]; @@ -887,7 +887,7 @@ const FuzzContext = struct { fn doOneAlloc(ctx: *FuzzContext, len: usize, alignment: Alignment, index: Alloc.Index) void { @disableInstrumentation(); - assert(ctx.allocs[@intFromEnum(index)].common.len == .free); + assert(ctx.allocs[@backingInt(index)].common.len == .free); const control_ptr = ctx.control_allocator.rawAlloc(len, alignment, @returnAddress()) orelse return; @@ -896,11 +896,11 @@ const FuzzContext = struct { return; }; - ctx.allocs[@intFromEnum(index)] = .{ + ctx.allocs[@backingInt(index)] = .{ .control_ptr = control_ptr, .sample_ptr = sample_ptr, .common = .{ - .len = @enumFromInt(len), + .len = @fromBackingInt(@intCast(len)), .alignment = alignment, }, }; @@ -918,9 +918,9 @@ const FuzzContext = struct { const index = @atomicRmw(Alloc.Index, &ctx.last_alloc_index, .Xchg, .none, .acquire); if (index == .none) return; - const allocation = &ctx.allocs[@intFromEnum(index)]; + const allocation = &ctx.allocs[@backingInt(index)]; assert(allocation.common.len != .free); - const memory = allocation.sample_ptr[0..@intFromEnum(allocation.common.len)]; + const memory = allocation.sample_ptr[0..@backingInt(allocation.common.len)]; const alignment = allocation.common.alignment; assert(alignment.check(@intFromPtr(allocation.control_ptr))); @@ -940,11 +940,11 @@ const FuzzContext = struct { return; } - ctx.allocs[@intFromEnum(index)] = .{ + ctx.allocs[@backingInt(index)] = .{ .control_ptr = new_control_ptr, .sample_ptr = memory.ptr, .common = .{ - .len = @enumFromInt(new_len), + .len = @fromBackingInt(@intCast(new_len)), .alignment = alignment, }, }; @@ -972,9 +972,9 @@ const FuzzContext = struct { const index = @atomicRmw(Alloc.Index, &ctx.last_alloc_index, .Xchg, .none, .acquire); if (index == .none) return; - const allocation = &ctx.allocs[@intFromEnum(index)]; + const allocation = &ctx.allocs[@backingInt(index)]; assert(allocation.common.len != .free); - const len: usize = @intFromEnum(allocation.common.len); + const len: usize = @backingInt(allocation.common.len); const alignment = allocation.common.alignment; assert(alignment.check(@intFromPtr(allocation.control_ptr))); @@ -983,7 +983,7 @@ const FuzzContext = struct { ctx.control_allocator.rawFree(allocation.control_ptr[0..len], alignment, @returnAddress()); ctx.sample_allocator.rawFree(allocation.sample_ptr[0..len], alignment, @returnAddress()); - ctx.allocs[@intFromEnum(index)] = .{ + ctx.allocs[@backingInt(index)] = .{ .control_ptr = undefined, .sample_ptr = undefined, .common = .{ diff --git a/lib/std/heap/SafeAllocator.zig b/lib/std/heap/SafeAllocator.zig index fa566a21f9a229ef65dff1db525282ef45c4399c..cfe24f4c0b1f0dabeaedaff76cc33d6ae32669c3 100644 --- a/lib/std/heap/SafeAllocator.zig +++ b/lib/std/heap/SafeAllocator.zig @@ -359,12 +359,12 @@ const AllocFooter = struct { fn storedXor(m: Modify, ptr: *Modify) Modify { const addr_hash: u16 = @truncate(std.hash.int(@intFromPtr(ptr))); - return @enumFromInt(@intFromEnum(m) ^ addr_hash); + return @fromBackingInt(@intCast(@backingInt(m) ^ addr_hash)); } }; fn isExtended(f: *AllocFooter) bool { - return @intFromEnum(f.data.len) >= Data.Len.extended_start; + return @backingInt(f.data.len) >= Data.Len.extended_start; } fn extended(f: *AllocFooter) *Extended { @@ -380,13 +380,13 @@ const AllocFooter = struct { } fn userLen(f: *AllocFooter) usize { - const len_int = @intFromEnum(f.data.len); + const len_int = @backingInt(f.data.len); return if (len_int < Data.Len.extended_start) len_int else f.extended().len; } fn userAlign(f: *AllocFooter) Alignment { - const high = (@intFromEnum(f.data.len) -| Data.Len.extended_start) << 2; - return @enumFromInt(high | f.data.alignment); + const high = (@backingInt(f.data.len) -| Data.Len.extended_start) << 2; + return @fromBackingInt(@intCast(high | f.data.alignment)); } fn bucketPrev(f: *AllocFooter, b: *Bucket, s: *SafeAllocator) ?*AllocFooter { @@ -439,7 +439,7 @@ const AllocFooter = struct { /// Assumes the footer is in a bucket allocation; all /// large allocations require an extended header. fn requiresExtended(len: usize, alignment: Alignment) bool { - return len >= Data.Len.extended_start or @intFromEnum(alignment) > math.maxInt(u2); + return len >= Data.Len.extended_start or @backingInt(alignment) > math.maxInt(u2); } fn lenBucket(s: *SafeAllocator, is_extended: bool) usize { @@ -592,15 +592,15 @@ const AllocFooter = struct { if (!is_extended) { footer.data = .{ - .len = @enumFromInt(len), - .alignment = @intCast(@intFromEnum(alignment)), + .len = @fromBackingInt(@intCast(len)), + .alignment = @intCast(@backingInt(alignment)), .prev_extended = prev_extended, }; assert(!footer.isExtended()); } else { footer.data = .{ - .len = @enumFromInt(Data.Len.extended_start + (@intFromEnum(alignment) >> 2)), - .alignment = @truncate(@intFromEnum(alignment)), + .len = @fromBackingInt(@intCast(Data.Len.extended_start + (@backingInt(alignment) >> 2))), + .alignment = @truncate(@backingInt(alignment)), .prev_extended = prev_extended, }; assert(footer.isExtended()); @@ -720,7 +720,7 @@ fn deinitLeakedBucket(s: *SafeAllocator, b: *Bucket, log: bool) usize { footer = footer.bucketPrev(b, s) orelse break; } - s.backing.rawFree(b.bytes(s), @enumFromInt(s.bucket_size_log2), 0); + s.backing.rawFree(b.bytes(s), @fromBackingInt(@intCast(s.bucket_size_log2)), 0); assert(leaks == expected.n); return leaks; @@ -875,7 +875,7 @@ fn captureStackTrace(trace_buf: []usize, ra: usize) void { } const t = std.debug.captureCurrentStackTrace(.{ .first_address = ra }, trace_buf[1..]); - const skipped = @intFromEnum(t.skipped) * + const skipped = @backingInt(t.skipped) * @intFromBool(t.return_addresses.len == trace_buf[1..].len); trace_buf[0] = t.return_addresses.len +| skipped; } @@ -888,7 +888,7 @@ fn formatStackTrace(trace_buf: []usize) std.debug.FormatStackTrace { break :trace .{ .return_addresses = addrs[0..@min(frames, addrs.len)], .skipped = switch (frames) { - else => @enumFromInt(frames -| addrs.len), + else => @fromBackingInt(@intCast(frames -| addrs.len)), 0, math.maxInt(usize) => .unknown, }, }; @@ -937,7 +937,7 @@ fn allocBucket( @branchHint(.unlikely); freeAllocEntry(t, b.entry); b.check(s); - s.backing.rawFree(b.bytes(s), @enumFromInt(s.bucket_size_log2), ra); + s.backing.rawFree(b.bytes(s), @fromBackingInt(@intCast(s.bucket_size_log2)), ra); } return null; @@ -1096,7 +1096,7 @@ fn alloc(ctx: *anyopaque, len: usize, alignment: Alignment, ra: usize) ?[*]u8 { const entry = s.newAllocEntry(t, ra) catch return null; const bucket: *Bucket = @ptrCast(@alignCast(s.backing.rawAlloc( s.bucketSize(), - @enumFromInt(s.bucket_size_log2), + @fromBackingInt(@intCast(s.bucket_size_log2)), ra, ) orelse { freeAllocEntry(t, entry); @@ -1171,7 +1171,7 @@ fn free(ctx: *anyopaque, memory: []u8, alignment: Alignment, ra: usize) void { freeAllocEntry(t, b.entry); t.mutex.unlock(); b.check(s); - s.backing.rawFree(b.bytes(s), @enumFromInt(s.bucket_size_log2), ra); + s.backing.rawFree(b.bytes(s), @fromBackingInt(@intCast(s.bucket_size_log2)), ra); } } @@ -1346,8 +1346,8 @@ const Smith = std.testing.Smith; const fuzz_probs = struct { const alignment: []const Smith.Weight = &.{ .rangeAtMost(Alignment, .@"1", .@"16", 32), // ~75% - .rangeAtMost(Alignment, .@"16", @enumFromInt(@bitSizeOf(usize) - 1), 1), - .value(Alignment, @enumFromInt(@bitSizeOf(usize) - 1), 32), // More likely overflow cases + .rangeAtMost(Alignment, .@"16", @fromBackingInt(@intCast(@bitSizeOf(usize) - 1)), 1), + .value(Alignment, @fromBackingInt(@intCast(@bitSizeOf(usize) - 1)), 32), // More likely overflow cases }; const eos: []const Smith.Weight = &.{ diff --git a/lib/std/heap/SmpAllocator.zig b/lib/std/heap/SmpAllocator.zig index 5982026cbca00834fe7d7be5e099a9a964c17ecc..b12d2bebc7c0c65b01a9cf70bf80e2cdcc2ce22e 100644 --- a/lib/std/heap/SmpAllocator.zig +++ b/lib/std/heap/SmpAllocator.zig @@ -216,7 +216,7 @@ fn free(context: *anyopaque, memory: []u8, alignment: Alignment, ra: usize) void } fn sizeClassIndex(len: usize, alignment: Alignment) usize { - return @max(@bitSizeOf(usize) - @clz(len - 1), @intFromEnum(alignment), min_class) - min_class; + return @max(@bitSizeOf(usize) - @clz(len - 1), @backingInt(alignment), min_class) - min_class; } fn slotSize(class: usize) usize { diff --git a/lib/std/heap/debug_allocator.zig b/lib/std/heap/debug_allocator.zig index 5c4ac1b44c083a1e5784d022e30726f9b8720485..057e63e47ec47ec2e8ada83d2fb65a1bbeeaa524 100644 --- a/lib/std/heap/debug_allocator.zig +++ b/lib/std/heap/debug_allocator.zig @@ -230,8 +230,8 @@ pub fn DebugAllocator(comptime config: Config) type { } fn getStackTrace(self: *LargeAlloc, trace_kind: TraceKind) std.debug.StackTrace { - assert(@intFromEnum(trace_kind) < trace_n); - const stack_addresses = &self.stack_addresses[@intFromEnum(trace_kind)]; + assert(@backingInt(trace_kind) < trace_n); + const stack_addresses = &self.stack_addresses[@backingInt(trace_kind)]; var len: usize = 0; while (len < stack_n and stack_addresses[len] != 0) { len += 1; @@ -243,8 +243,8 @@ pub fn DebugAllocator(comptime config: Config) type { } fn captureStackTrace(self: *LargeAlloc, ret_addr: usize, trace_kind: TraceKind) void { - assert(@intFromEnum(trace_kind) < trace_n); - const stack_addresses = &self.stack_addresses[@intFromEnum(trace_kind)]; + assert(@backingInt(trace_kind) < trace_n); + const stack_addresses = &self.stack_addresses[@backingInt(trace_kind)]; collectStackTrace(ret_addr, stack_addresses); } }; @@ -297,7 +297,7 @@ pub fn DebugAllocator(comptime config: Config) type { ) *[stack_n]usize { const start_ptr = @as([*]u8, @ptrCast(bucket)) + bucketStackFramesStart(slot_count); const addr = start_ptr + one_trace_size * traces_per_slot * slot_index + - @intFromEnum(trace_kind) * @as(usize, one_trace_size); + @backingInt(trace_kind) * @as(usize, one_trace_size); return @ptrCast(@alignCast(addr)); } @@ -586,7 +586,7 @@ pub fn DebugAllocator(comptime config: Config) type { // If this would move the allocation into a small size class, // refuse the request, because it would require creating small // allocation metadata. - const new_size_class_index: usize = @max(@bitSizeOf(usize) - @clz(new_size - 1), @intFromEnum(alignment)); + const new_size_class_index: usize = @max(@bitSizeOf(usize) - @clz(new_size - 1), @backingInt(alignment)); if (new_size_class_index < self.buckets.len) return null; // Do memory limit accounting with requested sizes rather than what @@ -727,7 +727,7 @@ pub fn DebugAllocator(comptime config: Config) type { self.total_requested_bytes = new_req_bytes; } - const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(len - 1), @intFromEnum(alignment)); + const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(len - 1), @backingInt(alignment)); if (size_class_index >= self.buckets.len) { @branchHint(.unlikely); self.large_allocations.ensureUnusedCapacity(self.backing_allocator, 1) catch return null; @@ -834,7 +834,7 @@ pub fn DebugAllocator(comptime config: Config) type { if (have_mutex) std.Io.Threaded.mutexLock(&self.mutex); defer if (have_mutex) std.Io.Threaded.mutexUnlock(&self.mutex); - const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(memory.len - 1), @intFromEnum(alignment)); + const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(memory.len - 1), @backingInt(alignment)); if (size_class_index >= self.buckets.len) { return self.resizeLarge(memory, alignment, new_len, return_address, false) != null; } else { @@ -853,7 +853,7 @@ pub fn DebugAllocator(comptime config: Config) type { if (have_mutex) std.Io.Threaded.mutexLock(&self.mutex); defer if (have_mutex) std.Io.Threaded.mutexUnlock(&self.mutex); - const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(memory.len - 1), @intFromEnum(alignment)); + const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(memory.len - 1), @backingInt(alignment)); if (size_class_index >= self.buckets.len) { return self.resizeLarge(memory, alignment, new_len, return_address, true); } else { @@ -871,7 +871,7 @@ pub fn DebugAllocator(comptime config: Config) type { if (have_mutex) std.Io.Threaded.mutexLock(&self.mutex); defer if (have_mutex) std.Io.Threaded.mutexUnlock(&self.mutex); - const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(old_memory.len - 1), @intFromEnum(alignment)); + const size_class_index: usize = @max(@bitSizeOf(usize) - @clz(old_memory.len - 1), @backingInt(alignment)); if (size_class_index >= self.buckets.len) { @branchHint(.unlikely); self.freeLarge(old_memory, alignment, return_address); @@ -990,7 +990,7 @@ pub fn DebugAllocator(comptime config: Config) type { return_address: usize, size_class_index: usize, ) bool { - const new_size_class_index: usize = @max(@bitSizeOf(usize) - @clz(new_len - 1), @intFromEnum(alignment)); + const new_size_class_index: usize = @max(@bitSizeOf(usize) - @clz(new_len - 1), @backingInt(alignment)); if (!config.safety) { if (new_size_class_index != size_class_index) return false; // Still account for total even if safety is off diff --git a/lib/std/http.zig b/lib/std/http.zig index f7d855002047c8b76e66408f9b31ecb2fd99ffa0..3a255580576b23e49bcecdfa88503259d458e1f5 100644 --- a/lib/std/http.zig +++ b/lib/std/http.zig @@ -247,7 +247,7 @@ pub const Status = enum(u10) { }; pub fn class(self: Status) Class { - return switch (@intFromEnum(self)) { + return switch (@backingInt(self)) { 100...199 => .informational, 200...299 => .success, 300...399 => .redirect, @@ -338,11 +338,11 @@ pub const Reader = struct { _, pub fn init(integer: u64) RemainingChunkLen { - return @enumFromInt(integer); + return @fromBackingInt(@intCast(integer)); } pub fn int(rcl: RemainingChunkLen) u64 { - return @intFromEnum(rcl); + return @backingInt(rcl); } }; @@ -597,8 +597,8 @@ pub const Reader = struct { continue :len .head; }, else => |remaining_chunk_len| { - const n = try in.stream(w, limit.min(.limited64(@intFromEnum(remaining_chunk_len) - 2))); - chunk_len_ptr.* = .init(@intFromEnum(remaining_chunk_len) - n); + const n = try in.stream(w, limit.min(.limited64(@backingInt(remaining_chunk_len) - 2))); + chunk_len_ptr.* = .init(@backingInt(remaining_chunk_len) - n); return n; }, } diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig index 5eca8d78a8f582c773589d9f01f4ff85027e7500..b0f94616719156dc94bedd7aa5bdde4283ee82d0 100644 --- a/lib/std/http/Client.zig +++ b/lib/std/http/Client.zig @@ -531,7 +531,7 @@ pub const Response = struct { else => return error.HttpHeadersInvalid, }; if (first_line[8] != ' ') return error.HttpHeadersInvalid; - const status: http.Status = @enumFromInt(parseInt3(first_line[9..12])); + const status: http.Status = @fromBackingInt(@intCast(parseInt3(first_line[9..12]))); const reason = mem.trimStart(u8, first_line[12..], " "); res.version = version; @@ -825,9 +825,9 @@ pub const Request = struct { pub const default_accept_encoding: [@typeInfo(http.ContentEncoding).@"enum".field_names.len]bool = b: { var result: [@typeInfo(http.ContentEncoding).@"enum".field_names.len]bool = @splat(false); - result[@intFromEnum(http.ContentEncoding.gzip)] = true; - result[@intFromEnum(http.ContentEncoding.deflate)] = true; - result[@intFromEnum(http.ContentEncoding.identity)] = true; + result[@backingInt(http.ContentEncoding.gzip)] = true; + result[@backingInt(http.ContentEncoding.deflate)] = true; + result[@backingInt(http.ContentEncoding.identity)] = true; break :b result; }; @@ -864,20 +864,20 @@ pub const Request = struct { pub fn init(n: u16) RedirectBehavior { assert(n != std.math.maxInt(u16)); - return @enumFromInt(n); + return @fromBackingInt(@intCast(n)); } pub fn subtractOne(rb: *RedirectBehavior) void { switch (rb.*) { .not_allowed => unreachable, .unhandled => unreachable, - _ => rb.* = @enumFromInt(@intFromEnum(rb.*) - 1), + _ => rb.* = @fromBackingInt(@intCast(@backingInt(rb.*) - 1)), } } pub fn remaining(rb: RedirectBehavior) u16 { assert(rb != .unhandled); - return @intFromEnum(rb); + return @backingInt(rb); } }; @@ -1037,7 +1037,7 @@ pub const Request = struct { try w.writeAll("accept-encoding: "); for (r.accept_encoding, 0..) |enabled, i| { if (!enabled) continue; - const tag: http.ContentEncoding = @enumFromInt(i); + const tag: http.ContentEncoding = @fromBackingInt(@intCast(i)); if (tag == .identity) continue; const tag_name = @tagName(tag); try w.ensureUnusedCapacity(tag_name.len + 2); @@ -1188,7 +1188,7 @@ pub const Request = struct { continue; } - if (!r.accept_encoding[@intFromEnum(head.content_encoding)]) + if (!r.accept_encoding[@backingInt(head.content_encoding)]) return error.HttpContentEncodingUnsupported; r.response_transfer_encoding = head.transfer_encoding; @@ -1654,7 +1654,7 @@ pub const RequestOptions = struct { /// /// This will only follow redirects for repeatable requests (ie. with no /// payload or the server has acknowledged the payload). - redirect_behavior: Request.RedirectBehavior = @enumFromInt(3), + redirect_behavior: Request.RedirectBehavior = @fromBackingInt(@intCast(3)), /// Must be an already acquired connection. connection: ?*Connection = null, @@ -1813,7 +1813,7 @@ pub fn fetch(client: *Client, options: FetchOptions) FetchError!FetchResult { if (options.payload != null) .POST else .GET; const redirect_behavior: Request.RedirectBehavior = options.redirect_behavior orelse - if (options.payload == null) @enumFromInt(3) else .unhandled; + if (options.payload == null) @fromBackingInt(@intCast(3)) else .unhandled; var req = try request(client, method, uri, .{ .redirect_behavior = redirect_behavior, diff --git a/lib/std/http/Server.zig b/lib/std/http/Server.zig index 3d56f59da31ce69377e8886a62245cc8f6612c7c..6523fa672f005664296726a858d40b3935b5561f 100644 --- a/lib/std/http/Server.zig +++ b/lib/std/http/Server.zig @@ -353,7 +353,7 @@ pub const Request = struct { const out = request.server.out; try out.print("{s} {d} {s}\r\n", .{ - @tagName(options.version), @intFromEnum(options.status), phrase, + @tagName(options.version), @backingInt(options.status), phrase, }); switch (options.version) { @@ -424,7 +424,7 @@ pub const Request = struct { const out = request.server.out; try out.print("{s} {d} {s}\r\n", .{ - @tagName(o.version), @intFromEnum(o.status), phrase, + @tagName(o.version), @backingInt(o.status), phrase, }); switch (o.version) { @@ -544,7 +544,7 @@ pub const Request = struct { sha1.update("258EAFA5-E914-47DA-95CA-C5AB0DC85B11"); var digest: [std.crypto.hash.Sha1.digest_length]u8 = undefined; sha1.final(&digest); - try out.print("{s} {d} {s}\r\n", .{ @tagName(version), @intFromEnum(status), phrase }); + try out.print("{s} {d} {s}\r\n", .{ @tagName(version), @backingInt(status), phrase }); try out.writeAll("connection: upgrade\r\nupgrade: websocket\r\nsec-websocket-accept: "); const base64_digest = try out.writableArray(28); assert(std.base64.standard.Encoder.encode(base64_digest, &digest).len == base64_digest.len); @@ -723,7 +723,7 @@ pub const WebSocket = struct { const len: usize = switch (h1.payload_len) { .len16 => try in.takeInt(u16, .big), .len64 => std.math.cast(usize, try in.takeInt(u64, .big)) orelse return error.MessageOversize, - else => @intFromEnum(h1.payload_len), + else => @backingInt(h1.payload_len), }; if (len > in.buffer.len) return error.MessageOversize; const mask: [4]u8 = (try in.takeArray(4)).*; @@ -781,7 +781,7 @@ pub const WebSocket = struct { }))); switch (total_len) { 0...125 => try out.writeByte(@bitCast(@as(Header1, .{ - .payload_len = @enumFromInt(total_len), + .payload_len = @fromBackingInt(@intCast(total_len)), .mask = false, }))), 126...0xffff => { diff --git a/lib/std/json/Stringify.zig b/lib/std/json/Stringify.zig index 2030024375174dec0f30556d00d37543e8f0524d..565c41b5e8e96c5bc3d3726df0171554fc8ed4d9 100644 --- a/lib/std/json/Stringify.zig +++ b/lib/std/json/Stringify.zig @@ -127,7 +127,7 @@ pub fn endObject(self: *Stringify) Error!void { fn pushIndentation(self: *Stringify, mode: IndentationMode) !void { switch (safety_checks) { .checked_to_fixed_depth => { - BitStack.pushWithStateAssumeCapacity(&self.nesting_stack, &self.indent_level, @intFromEnum(mode)); + BitStack.pushWithStateAssumeCapacity(&self.nesting_stack, &self.indent_level, @backingInt(mode)); }, .assumed_correct => { self.indent_level += 1; @@ -137,7 +137,7 @@ fn pushIndentation(self: *Stringify, mode: IndentationMode) !void { fn popIndentation(self: *Stringify, expected_mode: IndentationMode) void { switch (safety_checks) { .checked_to_fixed_depth => { - assert(BitStack.popWithState(&self.nesting_stack, &self.indent_level) == @intFromEnum(expected_mode)); + assert(BitStack.popWithState(&self.nesting_stack, &self.indent_level) == @backingInt(expected_mode)); }, .assumed_correct => { self.indent_level -= 1; @@ -202,7 +202,7 @@ fn valueDone(self: *Stringify) void { fn isObjectKeyExpected(self: *const Stringify) ?bool { switch (safety_checks) { .checked_to_fixed_depth => return self.indent_level > 0 and - BitStack.peekWithState(&self.nesting_stack, self.indent_level) == @intFromEnum(IndentationMode.object) and + BitStack.peekWithState(&self.nesting_stack, self.indent_level) == @backingInt(IndentationMode.object) and self.next_punctuation != .colon, .assumed_correct => return null, } @@ -407,7 +407,7 @@ pub fn write(self: *Stringify, v: anytype) Error!void { break; } } else { - return self.write(@intFromEnum(v)); + return self.write(@backingInt(v)); } } @@ -858,7 +858,7 @@ test "stringify non-exhaustive enum" { _, }; try testStringify("\"foo\"", E.foo, .{}); - try testStringify("1", @as(E, @enumFromInt(1)), .{}); + try testStringify("1", @as(E, @fromBackingInt(@intCast(1))), .{}); } test "stringify enum literals" { diff --git a/lib/std/lang.zig b/lib/std/lang.zig index 21a4fdae87a59afb4a63cbfe106558a0d1a0281d..02a1c90e5a915a26a7186d3733a2893a99c765dd 100644 --- a/lib/std/lang.zig +++ b/lib/std/lang.zig @@ -911,7 +911,7 @@ pub const Endian = enum { little, pub const native = builtin.target.cpu.arch.endian(); - pub const foreign: Endian = @enumFromInt(1 - @intFromEnum(native)); + pub const foreign: Endian = @fromBackingInt(@intCast(1 - @backingInt(native))); }; /// This data structure is used by the Zig language code generation and diff --git a/lib/std/log.zig b/lib/std/log.zig index f66cb4e04d1550a7f6825cfcbc03f61ee2438cb3..5a219a005a6d4274c0d7df0aa16a5cf8ce10f653 100644 --- a/lib/std/log.zig +++ b/lib/std/log.zig @@ -75,9 +75,9 @@ fn log( /// Determine if a specific log message level and scope combination are enabled for logging. pub fn logEnabled(comptime level: Level, comptime scope: @EnumLiteral()) bool { inline for (std.options.log_scope_levels) |scope_level| { - if (scope_level.scope == scope) return @intFromEnum(level) <= @intFromEnum(scope_level.level); + if (scope_level.scope == scope) return @backingInt(level) <= @backingInt(scope_level.level); } - return @intFromEnum(level) <= @intFromEnum(std.options.log_level); + return @backingInt(level) <= @backingInt(std.options.log_level); } pub const terminalMode = std.Options.logTerminalMode; diff --git a/lib/std/math.zig b/lib/std/math.zig index 90ff8a4abdede9f325b77ca143996840f14a3060..b43bc8f5981ec9083596a17ac90df631fc31d33f 100644 --- a/lib/std/math.zig +++ b/lib/std/math.zig @@ -1643,7 +1643,7 @@ pub const CompareOperator = enum { test reverse { inline for (@typeInfo(CompareOperator).@"enum".field_values) |op_field_value| { - const op = @as(CompareOperator, @enumFromInt(op_field_value)); + const op = @as(CompareOperator, @fromBackingInt(@intCast(op_field_value))); try testing.expect(compare(2, op, 3) == compare(3, op.reverse(), 2)); try testing.expect(compare(3, op, 3) == compare(3, op.reverse(), 3)); try testing.expect(compare(4, op, 3) == compare(3, op.reverse(), 4)); diff --git a/lib/std/math/float.zig b/lib/std/math/float.zig index 535f0b3ba64eb5f6a31477a5275f89d694cad20c..4bc67d494abac15c21e791f15fc56802e0fb87b8 100644 --- a/lib/std/math/float.zig +++ b/lib/std/math/float.zig @@ -92,13 +92,13 @@ pub fn FloatRepr(comptime Float: type) type { pub fn unbias(biased: BiasedExponent) Exponent { switch (biased) { .denormal => unreachable, - else => return @bitCast(@intFromEnum(biased) -% @intFromEnum(BiasedExponent.zero)), + else => return @bitCast(@backingInt(biased) -% @backingInt(BiasedExponent.zero)), .infinite => unreachable, } } pub fn bias(unbiased: Exponent) BiasedExponent { - return @enumFromInt(@intFromEnum(BiasedExponent.zero) +% @as(Int, @bitCast(unbiased))); + return @fromBackingInt(@intCast(@backingInt(BiasedExponent.zero) +% @as(Int, @bitCast(unbiased)))); } }; diff --git a/lib/std/mem.zig b/lib/std/mem.zig index d2c98e4c58e11a803db66a3da86d46dfb7e40bee..8353c0ca8e209dd1516371926e0fbfd00f874ded 100644 --- a/lib/std/mem.zig +++ b/lib/std/mem.zig @@ -32,12 +32,12 @@ pub const Alignment = enum(math.Log2Int(usize)) { _, pub fn toByteUnits(a: Alignment) usize { - return @as(usize, 1) << @intFromEnum(a); + return @as(usize, 1) << @backingInt(a); } pub fn fromByteUnits(n: usize) Alignment { assert(std.math.isPowerOfTwo(n)); - return @enumFromInt(@ctz(n)); + return @fromBackingInt(@intCast(@ctz(n))); } pub fn fromByteUnitsOptional(maybe_n: ?usize) ?Alignment { @@ -49,36 +49,36 @@ pub const Alignment = enum(math.Log2Int(usize)) { } pub fn order(lhs: Alignment, rhs: Alignment) std.math.Order { - return std.math.order(@intFromEnum(lhs), @intFromEnum(rhs)); + return std.math.order(@backingInt(lhs), @backingInt(rhs)); } pub fn compare(lhs: Alignment, op: std.math.CompareOperator, rhs: Alignment) bool { - return std.math.compare(@intFromEnum(lhs), op, @intFromEnum(rhs)); + return std.math.compare(@backingInt(lhs), op, @backingInt(rhs)); } pub fn max(lhs: Alignment, rhs: Alignment) Alignment { - return @enumFromInt(@max(@intFromEnum(lhs), @intFromEnum(rhs))); + return @fromBackingInt(@intCast(@max(@backingInt(lhs), @backingInt(rhs)))); } pub fn min(lhs: Alignment, rhs: Alignment) Alignment { - return @enumFromInt(@min(@intFromEnum(lhs), @intFromEnum(rhs))); + return @fromBackingInt(@intCast(@min(@backingInt(lhs), @backingInt(rhs)))); } /// Return next address with this alignment. pub fn forward(a: Alignment, address: usize) usize { - const x = (@as(usize, 1) << @intFromEnum(a)) - 1; + const x = (@as(usize, 1) << @backingInt(a)) - 1; return (address + x) & ~x; } /// Return previous address with this alignment. pub fn backward(a: Alignment, address: usize) usize { - const x = (@as(usize, 1) << @intFromEnum(a)) - 1; + const x = (@as(usize, 1) << @backingInt(a)) - 1; return address & ~x; } /// Return whether address is aligned to this amount. pub fn check(a: Alignment, address: usize) bool { - return @ctz(address) >= @intFromEnum(a); + return @ctz(address) >= @backingInt(a); } }; @@ -280,7 +280,7 @@ pub fn zeroes(comptime T: type) T { return @as(T, 0); }, .@"enum" => { - return @as(T, @enumFromInt(0)); + return @as(T, @fromBackingInt(@intCast(0))); }, .void => { return {}; @@ -2233,7 +2233,7 @@ pub fn byteSwapAllFieldsAligned(comptime S: type, comptime a: Alignment, ptr: *a .@"struct" => byteSwapAllFieldsAligned(f_type, .fromByteUnits(f_attr.@"align" orelse @alignOf(f_type)), &@field(ptr, f_name)), .@"union", .array => byteSwapAllFieldsAligned(f_type, .fromByteUnits(f_attr.@"align" orelse @alignOf(f_type)), &@field(ptr, f_name)), .@"enum" => { - @field(ptr, f_name) = @enumFromInt(@byteSwap(@intFromEnum(@field(ptr, f_name)))); + @field(ptr, f_name) = @fromBackingInt(@intCast(@byteSwap(@backingInt(@field(ptr, f_name))))); }, .bool => {}, .float => |float| { @@ -2364,7 +2364,7 @@ pub fn byteSwapAllElements(comptime Elem: type, slice: []Elem) void { switch (@typeInfo(@TypeOf(elem.*))) { .@"struct", .@"union", .array => byteSwapAllFields(@TypeOf(elem.*), elem), .@"enum" => { - elem.* = @enumFromInt(@byteSwap(@intFromEnum(elem.*))); + elem.* = @fromBackingInt(@intCast(@byteSwap(@backingInt(elem.*)))); }, .bool => {}, .float => |float| { @@ -4784,7 +4784,7 @@ pub fn doNotOptimizeAway(val: anytype) void { const t = @typeInfo(@TypeOf(val)); switch (t) { .void, .null, .comptime_int, .comptime_float => return, - .@"enum" => doNotOptimizeAway(@intFromEnum(val)), + .@"enum" => doNotOptimizeAway(@backingInt(val)), .bool => doNotOptimizeAway(@intFromBool(val)), .int => { const bits = t.int.bits; diff --git a/lib/std/meta.zig b/lib/std/meta.zig index e891e4320d5bdc9faa01be96cd8fd1ba1d8b2165..cfeb6a758524a4e0e5a3f9e6dcac57fd029123c6 100644 --- a/lib/std/meta.zig +++ b/lib/std/meta.zig @@ -253,7 +253,7 @@ pub fn fieldInfo(comptime T: type, comptime field: FieldEnum(T)) switch (@typeIn .error_set => struct { name: [:0]const u8 }, else => @compileError("Expected struct, union, error set or enum type, found '" ++ @typeName(T) ++ "'"), } { - const idx = @intFromEnum(field); + const idx = @backingInt(field); return switch (@typeInfo(T)) { .@"struct" => |info| .{ .name = info.field_names[idx], @@ -399,7 +399,7 @@ pub fn FieldEnum(comptime T: type) type { switch (@typeInfo(T)) { .@"union" => |@"union"| if (@"union".tag_type) |EnumTag| { for (std.enums.values(EnumTag), 0..) |v, i| { - if (@intFromEnum(v) != i) break; // enum values not consecutive + if (@backingInt(v) != i) break; // enum values not consecutive if (!std.mem.eql(u8, @tagName(v), field_names[i])) break; // fields out of order } else { return EnumTag; diff --git a/lib/std/meta/trailer_flags.zig b/lib/std/meta/trailer_flags.zig index c312825a2b9e3e60c19d5b04cb9486fe997bf07d..3918f954143a73cc524c0aad7ac13835fb85fce3 100644 --- a/lib/std/meta/trailer_flags.zig +++ b/lib/std/meta/trailer_flags.zig @@ -42,7 +42,7 @@ pub fn TrailerFlags(comptime Fields: type) type { pub const Self = @This(); pub fn has(self: Self, comptime field: FieldEnum) bool { - const field_index = @intFromEnum(field); + const field_index = @backingInt(field); return (self.bits & (1 << field_index)) != 0; } @@ -53,7 +53,7 @@ pub fn TrailerFlags(comptime Fields: type) type { } pub fn setFlag(self: *Self, comptime field: FieldEnum) void { - const field_index = @intFromEnum(field); + const field_index = @backingInt(field); self.bits |= 1 << field_index; } @@ -71,7 +71,7 @@ pub fn TrailerFlags(comptime Fields: type) type { pub fn setMany(self: Self, p: [*]align(@alignOf(Fields)) u8, fields: FieldValues) void { inline for (@typeInfo(Fields).@"struct".field_names, 0..) |field_name, i| { if (@field(fields, field_name)) |value| - self.set(p, @as(FieldEnum, @enumFromInt(i)), value); + self.set(p, @as(FieldEnum, @fromBackingInt(@intCast(i))), value); } } @@ -102,7 +102,7 @@ pub fn TrailerFlags(comptime Fields: type) type { var off: usize = 0; inline for (@typeInfo(Fields).@"struct".field_types, 0..) |field_type, i| { const active = (self.bits & (1 << i)) != 0; - if (i == @intFromEnum(field)) { + if (i == @backingInt(field)) { assert(active); return mem.alignForward(usize, off, @alignOf(field_type)); } else if (active) { @@ -113,7 +113,7 @@ pub fn TrailerFlags(comptime Fields: type) type { } pub fn Field(comptime field: FieldEnum) type { - return @typeInfo(Fields).@"struct".field_types[@intFromEnum(field)]; + return @typeInfo(Fields).@"struct".field_types[@backingInt(field)]; } pub fn sizeInBytes(self: Self) usize { diff --git a/lib/std/multi_array_list.zig b/lib/std/multi_array_list.zig index 95404a3288e8459ff334c6e0c0558c71d3d563f6..a10f261e31ef8d4f47a976eebb3f637c199f835f 100644 --- a/lib/std/multi_array_list.zig +++ b/lib/std/multi_array_list.zig @@ -92,7 +92,7 @@ pub fn MultiArrayList(comptime T: type) type { if (self.capacity == 0) { return &[_]F{}; } - const byte_ptr = self.ptrs[@intFromEnum(field)]; + const byte_ptr = self.ptrs[@backingInt(field)]; const casted_ptr: [*]F = if (@sizeOf(F) == 0) undefined else @@ -107,14 +107,14 @@ pub fn MultiArrayList(comptime T: type) type { else => unreachable, }; inline for (field_names, 0..) |field_name, i| { - self.items(@as(Field, @enumFromInt(i)))[index] = @field(e, field_name); + self.items(@as(Field, @fromBackingInt(@intCast(i))))[index] = @field(e, field_name); } } pub fn get(self: Slice, index: usize) T { var result: Elem = undefined; inline for (field_names, 0..) |field_name, i| { - @field(result, field_name) = self.items(@as(Field, @enumFromInt(i)))[index]; + @field(result, field_name) = self.items(@as(Field, @fromBackingInt(@intCast(i))))[index]; } return switch (@typeInfo(T)) { .@"struct" => result, @@ -361,7 +361,7 @@ pub fn MultiArrayList(comptime T: type) type { }; const slices = self.slice(); inline for (field_names, 0..) |field_name, field_index| { - const field_slice = slices.items(@as(Field, @enumFromInt(field_index))); + const field_slice = slices.items(@as(Field, @fromBackingInt(@intCast(field_index)))); var i: usize = self.len - 1; while (i > index) : (i -= 1) { field_slice[i] = field_slice[i - 1]; @@ -387,7 +387,7 @@ pub fn MultiArrayList(comptime T: type) type { pub fn swapRemove(self: *Self, index: usize) void { const slices = self.slice(); inline for (field_names, 0..) |_, i| { - const field_slice = slices.items(@as(Field, @enumFromInt(i))); + const field_slice = slices.items(@as(Field, @fromBackingInt(@intCast(i)))); field_slice[index] = field_slice[self.len - 1]; field_slice[self.len - 1] = undefined; } @@ -399,7 +399,7 @@ pub fn MultiArrayList(comptime T: type) type { pub fn orderedRemove(self: *Self, index: usize) void { const slices = self.slice(); inline for (field_names, 0..) |_, field_index| { - const field_slice = slices.items(@as(Field, @enumFromInt(field_index))); + const field_slice = slices.items(@as(Field, @fromBackingInt(@intCast(field_index)))); var i = index; while (i < self.len - 1) : (i += 1) { field_slice[i] = field_slice[i + 1]; @@ -430,7 +430,7 @@ pub fn MultiArrayList(comptime T: type) type { const start = removed + 1; const len = end - start; // safety checks `sorted_indexes` are sorted inline for (field_names, 0..) |_, field_index| { - const field_slice = slices.items(@enumFromInt(field_index)); + const field_slice = slices.items(@fromBackingInt(@intCast(field_index))); @memmove(field_slice[start - shift ..][0..len], field_slice[start..][0..len]); // safety checks initial `sorted_indexes` are in range } shift += 1; @@ -439,7 +439,7 @@ pub fn MultiArrayList(comptime T: type) type { const end = self.len; const len = end - start; // safety checks final `sorted_indexes` are in range inline for (field_names, 0..) |_, field_index| { - const field_slice = slices.items(@enumFromInt(field_index)); + const field_slice = slices.items(@fromBackingInt(@intCast(field_index))); @memmove(field_slice[start - shift ..][0..len], field_slice[start..][0..len]); } self.len = end - shift; @@ -465,7 +465,7 @@ pub fn MultiArrayList(comptime T: type) type { const self_slice = self.slice(); inline for (field_types, 0..) |field_type, i| { if (@sizeOf(field_type) != 0) { - const field = @as(Field, @enumFromInt(i)); + const field = @as(Field, @fromBackingInt(@intCast(i))); const dest_slice = self_slice.items(field)[new_len..]; // We use memset here for more efficient codegen in safety-checked, // valgrind-enabled builds. Otherwise the valgrind client request @@ -486,7 +486,7 @@ pub fn MultiArrayList(comptime T: type) type { const other_slice = other.slice(); inline for (field_types, 0..) |field_type, i| { if (@sizeOf(field_type) != 0) { - const field = @as(Field, @enumFromInt(i)); + const field = @as(Field, @fromBackingInt(@intCast(i))); @memcpy(other_slice.items(field), self_slice.items(field)); } } @@ -558,7 +558,7 @@ pub fn MultiArrayList(comptime T: type) type { const other_slice = other.slice(); inline for (field_types, 0..) |field_type, i| { if (@sizeOf(field_type) != 0) { - const field = @as(Field, @enumFromInt(i)); + const field = @as(Field, @fromBackingInt(@intCast(i))); @memcpy(other_slice.items(field), self_slice.items(field)); } } @@ -577,7 +577,7 @@ pub fn MultiArrayList(comptime T: type) type { const result_slice = result.slice(); inline for (field_types, 0..) |field_type, i| { if (@sizeOf(field_type) != 0) { - const field = @as(Field, @enumFromInt(i)); + const field = @as(Field, @fromBackingInt(@intCast(i))); @memcpy(result_slice.items(field), self_slice.items(field)); } } @@ -594,7 +594,7 @@ pub fn MultiArrayList(comptime T: type) type { pub fn swap(sc: @This(), a_index: usize, b_index: usize) void { inline for (field_types, 0..) |field_type, i| { if (@sizeOf(field_type) != 0) { - const field: Field = @enumFromInt(i); + const field: Field = @fromBackingInt(@intCast(i)); const ptr = sc.slice.items(field); mem.swap(field_type, &ptr[a_index], &ptr[b_index]); } diff --git a/lib/std/os/emscripten.zig b/lib/std/os/emscripten.zig index 8907c6ad5f063ed41858faff53cb586f9923bf66..5df52dd9b87fada9ccc2d5286d864902b3894e3d 100644 --- a/lib/std/os/emscripten.zig +++ b/lib/std/os/emscripten.zig @@ -28,85 +28,85 @@ pub fn CPU_COUNT(set: cpu_set_t) cpu_count_t { } pub const E = enum(u16) { - SUCCESS = @intFromEnum(wasi.errno_t.SUCCESS), - @"2BIG" = @intFromEnum(wasi.errno_t.@"2BIG"), - ACCES = @intFromEnum(wasi.errno_t.ACCES), - ADDRINUSE = @intFromEnum(wasi.errno_t.ADDRINUSE), - ADDRNOTAVAIL = @intFromEnum(wasi.errno_t.ADDRNOTAVAIL), - AFNOSUPPORT = @intFromEnum(wasi.errno_t.AFNOSUPPORT), + SUCCESS = @backingInt(wasi.errno_t.SUCCESS), + @"2BIG" = @backingInt(wasi.errno_t.@"2BIG"), + ACCES = @backingInt(wasi.errno_t.ACCES), + ADDRINUSE = @backingInt(wasi.errno_t.ADDRINUSE), + ADDRNOTAVAIL = @backingInt(wasi.errno_t.ADDRNOTAVAIL), + AFNOSUPPORT = @backingInt(wasi.errno_t.AFNOSUPPORT), /// This is also the error code used for `WOULDBLOCK`. - AGAIN = @intFromEnum(wasi.errno_t.AGAIN), - ALREADY = @intFromEnum(wasi.errno_t.ALREADY), - BADF = @intFromEnum(wasi.errno_t.BADF), - BADMSG = @intFromEnum(wasi.errno_t.BADMSG), - BUSY = @intFromEnum(wasi.errno_t.BUSY), - CANCELED = @intFromEnum(wasi.errno_t.CANCELED), - CHILD = @intFromEnum(wasi.errno_t.CHILD), - CONNABORTED = @intFromEnum(wasi.errno_t.CONNABORTED), - CONNREFUSED = @intFromEnum(wasi.errno_t.CONNREFUSED), - CONNRESET = @intFromEnum(wasi.errno_t.CONNRESET), - DEADLK = @intFromEnum(wasi.errno_t.DEADLK), - DESTADDRREQ = @intFromEnum(wasi.errno_t.DESTADDRREQ), - DOM = @intFromEnum(wasi.errno_t.DOM), - DQUOT = @intFromEnum(wasi.errno_t.DQUOT), - EXIST = @intFromEnum(wasi.errno_t.EXIST), - FAULT = @intFromEnum(wasi.errno_t.FAULT), - FBIG = @intFromEnum(wasi.errno_t.FBIG), - HOSTUNREACH = @intFromEnum(wasi.errno_t.HOSTUNREACH), - IDRM = @intFromEnum(wasi.errno_t.IDRM), - ILSEQ = @intFromEnum(wasi.errno_t.ILSEQ), - INPROGRESS = @intFromEnum(wasi.errno_t.INPROGRESS), - INTR = @intFromEnum(wasi.errno_t.INTR), - INVAL = @intFromEnum(wasi.errno_t.INVAL), - IO = @intFromEnum(wasi.errno_t.IO), - ISCONN = @intFromEnum(wasi.errno_t.ISCONN), - ISDIR = @intFromEnum(wasi.errno_t.ISDIR), - LOOP = @intFromEnum(wasi.errno_t.LOOP), - MFILE = @intFromEnum(wasi.errno_t.MFILE), - MLINK = @intFromEnum(wasi.errno_t.MLINK), - MSGSIZE = @intFromEnum(wasi.errno_t.MSGSIZE), - MULTIHOP = @intFromEnum(wasi.errno_t.MULTIHOP), - NAMETOOLONG = @intFromEnum(wasi.errno_t.NAMETOOLONG), - NETDOWN = @intFromEnum(wasi.errno_t.NETDOWN), - NETRESET = @intFromEnum(wasi.errno_t.NETRESET), - NETUNREACH = @intFromEnum(wasi.errno_t.NETUNREACH), - NFILE = @intFromEnum(wasi.errno_t.NFILE), - NOBUFS = @intFromEnum(wasi.errno_t.NOBUFS), - NODEV = @intFromEnum(wasi.errno_t.NODEV), - NOENT = @intFromEnum(wasi.errno_t.NOENT), - NOEXEC = @intFromEnum(wasi.errno_t.NOEXEC), - NOLCK = @intFromEnum(wasi.errno_t.NOLCK), - NOLINK = @intFromEnum(wasi.errno_t.NOLINK), - NOMEM = @intFromEnum(wasi.errno_t.NOMEM), - NOMSG = @intFromEnum(wasi.errno_t.NOMSG), - NOPROTOOPT = @intFromEnum(wasi.errno_t.NOPROTOOPT), - NOSPC = @intFromEnum(wasi.errno_t.NOSPC), - NOSYS = @intFromEnum(wasi.errno_t.NOSYS), - NOTCONN = @intFromEnum(wasi.errno_t.NOTCONN), - NOTDIR = @intFromEnum(wasi.errno_t.NOTDIR), - NOTEMPTY = @intFromEnum(wasi.errno_t.NOTEMPTY), - NOTRECOVERABLE = @intFromEnum(wasi.errno_t.NOTRECOVERABLE), - NOTSOCK = @intFromEnum(wasi.errno_t.NOTSOCK), + AGAIN = @backingInt(wasi.errno_t.AGAIN), + ALREADY = @backingInt(wasi.errno_t.ALREADY), + BADF = @backingInt(wasi.errno_t.BADF), + BADMSG = @backingInt(wasi.errno_t.BADMSG), + BUSY = @backingInt(wasi.errno_t.BUSY), + CANCELED = @backingInt(wasi.errno_t.CANCELED), + CHILD = @backingInt(wasi.errno_t.CHILD), + CONNABORTED = @backingInt(wasi.errno_t.CONNABORTED), + CONNREFUSED = @backingInt(wasi.errno_t.CONNREFUSED), + CONNRESET = @backingInt(wasi.errno_t.CONNRESET), + DEADLK = @backingInt(wasi.errno_t.DEADLK), + DESTADDRREQ = @backingInt(wasi.errno_t.DESTADDRREQ), + DOM = @backingInt(wasi.errno_t.DOM), + DQUOT = @backingInt(wasi.errno_t.DQUOT), + EXIST = @backingInt(wasi.errno_t.EXIST), + FAULT = @backingInt(wasi.errno_t.FAULT), + FBIG = @backingInt(wasi.errno_t.FBIG), + HOSTUNREACH = @backingInt(wasi.errno_t.HOSTUNREACH), + IDRM = @backingInt(wasi.errno_t.IDRM), + ILSEQ = @backingInt(wasi.errno_t.ILSEQ), + INPROGRESS = @backingInt(wasi.errno_t.INPROGRESS), + INTR = @backingInt(wasi.errno_t.INTR), + INVAL = @backingInt(wasi.errno_t.INVAL), + IO = @backingInt(wasi.errno_t.IO), + ISCONN = @backingInt(wasi.errno_t.ISCONN), + ISDIR = @backingInt(wasi.errno_t.ISDIR), + LOOP = @backingInt(wasi.errno_t.LOOP), + MFILE = @backingInt(wasi.errno_t.MFILE), + MLINK = @backingInt(wasi.errno_t.MLINK), + MSGSIZE = @backingInt(wasi.errno_t.MSGSIZE), + MULTIHOP = @backingInt(wasi.errno_t.MULTIHOP), + NAMETOOLONG = @backingInt(wasi.errno_t.NAMETOOLONG), + NETDOWN = @backingInt(wasi.errno_t.NETDOWN), + NETRESET = @backingInt(wasi.errno_t.NETRESET), + NETUNREACH = @backingInt(wasi.errno_t.NETUNREACH), + NFILE = @backingInt(wasi.errno_t.NFILE), + NOBUFS = @backingInt(wasi.errno_t.NOBUFS), + NODEV = @backingInt(wasi.errno_t.NODEV), + NOENT = @backingInt(wasi.errno_t.NOENT), + NOEXEC = @backingInt(wasi.errno_t.NOEXEC), + NOLCK = @backingInt(wasi.errno_t.NOLCK), + NOLINK = @backingInt(wasi.errno_t.NOLINK), + NOMEM = @backingInt(wasi.errno_t.NOMEM), + NOMSG = @backingInt(wasi.errno_t.NOMSG), + NOPROTOOPT = @backingInt(wasi.errno_t.NOPROTOOPT), + NOSPC = @backingInt(wasi.errno_t.NOSPC), + NOSYS = @backingInt(wasi.errno_t.NOSYS), + NOTCONN = @backingInt(wasi.errno_t.NOTCONN), + NOTDIR = @backingInt(wasi.errno_t.NOTDIR), + NOTEMPTY = @backingInt(wasi.errno_t.NOTEMPTY), + NOTRECOVERABLE = @backingInt(wasi.errno_t.NOTRECOVERABLE), + NOTSOCK = @backingInt(wasi.errno_t.NOTSOCK), /// This is also the code used for `NOTSUP`. - OPNOTSUPP = @intFromEnum(wasi.errno_t.OPNOTSUPP), - NOTTY = @intFromEnum(wasi.errno_t.NOTTY), - NXIO = @intFromEnum(wasi.errno_t.NXIO), - OVERFLOW = @intFromEnum(wasi.errno_t.OVERFLOW), - OWNERDEAD = @intFromEnum(wasi.errno_t.OWNERDEAD), - PERM = @intFromEnum(wasi.errno_t.PERM), - PIPE = @intFromEnum(wasi.errno_t.PIPE), - PROTO = @intFromEnum(wasi.errno_t.PROTO), - PROTONOSUPPORT = @intFromEnum(wasi.errno_t.PROTONOSUPPORT), - PROTOTYPE = @intFromEnum(wasi.errno_t.PROTOTYPE), - RANGE = @intFromEnum(wasi.errno_t.RANGE), - ROFS = @intFromEnum(wasi.errno_t.ROFS), - SPIPE = @intFromEnum(wasi.errno_t.SPIPE), - SRCH = @intFromEnum(wasi.errno_t.SRCH), - STALE = @intFromEnum(wasi.errno_t.STALE), - TIMEDOUT = @intFromEnum(wasi.errno_t.TIMEDOUT), - TXTBSY = @intFromEnum(wasi.errno_t.TXTBSY), - XDEV = @intFromEnum(wasi.errno_t.XDEV), - NOTCAPABLE = @intFromEnum(wasi.errno_t.NOTCAPABLE), + OPNOTSUPP = @backingInt(wasi.errno_t.OPNOTSUPP), + NOTTY = @backingInt(wasi.errno_t.NOTTY), + NXIO = @backingInt(wasi.errno_t.NXIO), + OVERFLOW = @backingInt(wasi.errno_t.OVERFLOW), + OWNERDEAD = @backingInt(wasi.errno_t.OWNERDEAD), + PERM = @backingInt(wasi.errno_t.PERM), + PIPE = @backingInt(wasi.errno_t.PIPE), + PROTO = @backingInt(wasi.errno_t.PROTO), + PROTONOSUPPORT = @backingInt(wasi.errno_t.PROTONOSUPPORT), + PROTOTYPE = @backingInt(wasi.errno_t.PROTOTYPE), + RANGE = @backingInt(wasi.errno_t.RANGE), + ROFS = @backingInt(wasi.errno_t.ROFS), + SPIPE = @backingInt(wasi.errno_t.SPIPE), + SRCH = @backingInt(wasi.errno_t.SRCH), + STALE = @backingInt(wasi.errno_t.STALE), + TIMEDOUT = @backingInt(wasi.errno_t.TIMEDOUT), + TXTBSY = @backingInt(wasi.errno_t.TXTBSY), + XDEV = @backingInt(wasi.errno_t.XDEV), + NOTCAPABLE = @backingInt(wasi.errno_t.NOTCAPABLE), ENOSTR = 100, EBFONT = 101, @@ -209,10 +209,10 @@ pub const W = struct { return @as(u8, @intCast((s & 0xff00) >> 8)); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn IFEXITED(s: u32) bool { return (s & 0x7f) == 0; diff --git a/lib/std/os/linux.zig b/lib/std/os/linux.zig index dc22fc6db21bdcf83d929ace73f37594fc0d5982..5a3a0ff263ea99affa6c102f15699ca7eb079898 100644 --- a/lib/std/os/linux.zig +++ b/lib/std/os/linux.zig @@ -755,7 +755,7 @@ fn splitValue64(val: i64) [2]u32 { pub fn errno(r: u64) E { const signed_r: i32 = @bitCast(@as(u32, @truncate(r))); const int = if (signed_r > -4096 and signed_r < 0) -signed_r else 0; - return @enumFromInt(int); + return @fromBackingInt(@intCast(int)); } pub fn brk(addr: usize) usize { @@ -822,7 +822,7 @@ pub fn fork() usize { } else if (@hasField(SYS, "fork")) { return syscall0(.fork); } else { - return syscall2(.clone, @intFromEnum(SIG.CHLD), 0); + return syscall2(.clone, @backingInt(SIG.CHLD), 0); } } @@ -945,7 +945,7 @@ pub fn futex2_waitv( nr_futexes, @as(u32, @bitCast(flags)), @intFromPtr(timeout), - @intFromEnum(clockid), + @backingInt(clockid), ); } @@ -974,7 +974,7 @@ pub fn futex2_wait( mask, @as(u32, @bitCast(flags)), @intFromPtr(timeout), - @intFromEnum(clockid), + @backingInt(clockid), ); } @@ -1250,7 +1250,7 @@ pub const FSCONFIG_CMD = enum(u32) { }; pub fn fsconfig(fd: fd_t, cmd: FSCONFIG_CMD, key: ?[*:0]const u8, value: ?[*:0]const u8, aux: u32) usize { - return syscall5(.fsconfig, @as(u32, @bitCast(fd)), @intFromEnum(cmd), @intFromPtr(key), @intFromPtr(value), aux); + return syscall5(.fsconfig, @as(u32, @bitCast(fd)), @backingInt(cmd), @intFromPtr(key), @intFromPtr(value), aux); } pub const FSMOUNT = packed struct(u32) { @@ -1897,9 +1897,9 @@ pub const LINUX_REBOOT = struct { pub fn reboot(magic: LINUX_REBOOT.MAGIC1, magic2: LINUX_REBOOT.MAGIC2, cmd: LINUX_REBOOT.CMD, arg: ?*const anyopaque) usize { return std.os.linux.syscall4( .reboot, - @intFromEnum(magic), - @intFromEnum(magic2), - @intFromEnum(cmd), + @backingInt(magic), + @backingInt(magic2), + @backingInt(cmd), @intFromPtr(arg), ); } @@ -1909,15 +1909,15 @@ pub fn getrandom(buf: [*]u8, count: usize, flags: u32) usize { } pub fn kill(pid: pid_t, sig: SIG) usize { - return syscall2(.kill, @as(u32, @bitCast(pid)), @intFromEnum(sig)); + return syscall2(.kill, @as(u32, @bitCast(pid)), @backingInt(sig)); } pub fn tkill(tid: pid_t, sig: SIG) usize { - return syscall2(.tkill, @as(u32, @bitCast(tid)), @intFromEnum(sig)); + return syscall2(.tkill, @as(u32, @bitCast(tid)), @backingInt(sig)); } pub fn tgkill(tgid: pid_t, tid: pid_t, sig: SIG) usize { - return syscall3(.tgkill, @as(u32, @bitCast(tgid)), @as(u32, @bitCast(tid)), @intFromEnum(sig)); + return syscall3(.tgkill, @as(u32, @bitCast(tgid)), @as(u32, @bitCast(tid)), @backingInt(sig)); } pub fn link(oldpath: [*:0]const u8, newpath: [*:0]const u8) usize { @@ -1979,7 +1979,7 @@ pub fn wait4(pid: pid_t, status: *i32, flags: u32, usage: ?*rusage) usize { pub fn waitid(id_type: P, id: pid_t, infop: *siginfo_t, flags: u32, usage: ?*rusage) usize { return syscall5( .waitid, - @intFromEnum(id_type), + @backingInt(id_type), @as(u32, @bitCast(id)), @intFromPtr(infop), flags, @@ -2146,14 +2146,14 @@ pub fn clock_gettime(clk_id: clockid_t, tp: *timespec) usize { if (ptr) |f| { const rc = f(clk_id, tp); switch (rc) { - 0, @as(usize, @bitCast(-@as(isize, @intFromEnum(E.INVAL)))) => return rc, + 0, @as(usize, @bitCast(-@as(isize, @backingInt(E.INVAL)))) => return rc, else => {}, } } } return syscall2( if (@hasField(SYS, "clock_gettime") and native_arch != .hexagon) .clock_gettime else .clock_gettime64, - @intFromEnum(clk_id), + @backingInt(clk_id), @intFromPtr(tp), ); } @@ -2165,13 +2165,13 @@ fn init_vdso_clock_gettime(clk: clockid_t, ts: *timespec) callconv(.c) usize { @atomicStore(?VdsoClockGettime, &vdso_clock_gettime, ptr, .monotonic); // Call into the VDSO if available if (ptr) |f| return f(clk, ts); - return @bitCast(-@as(isize, @intFromEnum(E.NOSYS))); + return @bitCast(-@as(isize, @backingInt(E.NOSYS))); } pub fn clock_getres(clk_id: clockid_t, tp: *timespec) usize { return syscall2( if (@hasField(SYS, "clock_getres") and native_arch != .hexagon) .clock_getres else .clock_getres_time64, - @intFromEnum(clk_id), + @backingInt(clk_id), @intFromPtr(tp), ); } @@ -2179,7 +2179,7 @@ pub fn clock_getres(clk_id: clockid_t, tp: *timespec) usize { pub fn clock_settime(clk_id: clockid_t, tp: *const timespec) usize { return syscall2( if (@hasField(SYS, "clock_settime") and native_arch != .hexagon) .clock_settime else .clock_settime64, - @intFromEnum(clk_id), + @backingInt(clk_id), @intFromPtr(tp), ); } @@ -2187,7 +2187,7 @@ pub fn clock_settime(clk_id: clockid_t, tp: *const timespec) usize { pub fn clock_nanosleep(clockid: clockid_t, flags: TIMER, request: *const timespec, remain: ?*timespec) usize { return syscall4( if (@hasField(SYS, "clock_nanosleep") and native_arch != .hexagon) .clock_nanosleep else .clock_nanosleep_time64, - @intFromEnum(clockid), + @backingInt(clockid), @as(u32, @bitCast(flags)), @intFromPtr(request), @intFromPtr(remain), @@ -2384,8 +2384,8 @@ pub fn sigprocmask(flags: u32, noalias set: ?*const sigset_t, noalias oldset: ?* } pub fn sigaction(sig: SIG, noalias act: ?*const Sigaction, noalias oact: ?*Sigaction) usize { - assert(@intFromEnum(sig) > 0); - assert(@intFromEnum(sig) < NSIG); + assert(@backingInt(sig) > 0); + assert(@backingInt(sig) < NSIG); assert(sig != .KILL); assert(sig != .STOP); @@ -2418,8 +2418,8 @@ pub fn sigaction(sig: SIG, noalias act: ?*const Sigaction, noalias oact: ?*Sigac const result = switch (native_arch) { // The sparc version of rt_sigaction needs the restorer function to be passed as an argument too. - .sparc, .sparc64 => syscall5(.rt_sigaction, @intFromEnum(sig), ksa_arg, oldksa_arg, @intFromPtr(ksa.restorer), mask_size), - else => syscall4(.rt_sigaction, @intFromEnum(sig), ksa_arg, oldksa_arg, mask_size), + .sparc, .sparc64 => syscall5(.rt_sigaction, @backingInt(sig), ksa_arg, oldksa_arg, @intFromPtr(ksa.restorer), mask_size), + else => syscall4(.rt_sigaction, @backingInt(sig), ksa_arg, oldksa_arg, mask_size), }; if (errno(result) != .SUCCESS) return result; @@ -2468,9 +2468,9 @@ pub fn sigfillset() sigset_t { } fn sigset_bit_index(sig: SIG) struct { word: usize, mask: SigsetElement } { - assert(@intFromEnum(sig) > 0); - assert(@intFromEnum(sig) < NSIG); - const bit = @intFromEnum(sig) - 1; + assert(@backingInt(sig) > 0); + assert(@backingInt(sig) < NSIG); + const bit = @backingInt(sig) - 1; return .{ .word = bit / @bitSizeOf(SigsetElement), .mask = @as(SigsetElement, 1) << @truncate(bit % @bitSizeOf(SigsetElement)), @@ -2833,7 +2833,7 @@ pub fn eventfd(count: u32, flags: u32) usize { pub fn timerfd_create(clockid: timerfd_clockid_t, flags: TFD) usize { return syscall2( .timerfd_create, - @intFromEnum(clockid), + @backingInt(clockid), @as(u32, @bitCast(flags)), ); } @@ -2909,7 +2909,7 @@ pub fn io_uring_enter(fd: fd_t, to_submit: u32, min_complete: u32, flags: u32, s } pub fn io_uring_register(fd: fd_t, opcode: IORING_REGISTER, arg: ?*const anyopaque, nr_args: u32) usize { - return syscall4(.io_uring_register, @as(u32, @bitCast(fd)), @intFromEnum(opcode), @intFromPtr(arg), nr_args); + return syscall4(.io_uring_register, @as(u32, @bitCast(fd)), @backingInt(opcode), @intFromPtr(arg), nr_args); } pub fn memfd_create(name: [*:0]const u8, flags: u32) usize { @@ -2925,7 +2925,7 @@ pub fn tcgetattr(fd: fd_t, termios_p: *termios) usize { } pub fn tcsetattr(fd: fd_t, optional_action: TCSA, termios_p: *const termios) usize { - return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CSETS + @intFromEnum(optional_action), @intFromPtr(termios_p)); + return syscall3(.ioctl, @as(u32, @bitCast(fd)), T.CSETS + @backingInt(optional_action), @intFromPtr(termios_p)); } pub fn tcgetpgrp(fd: fd_t, pgrp: *pid_t) usize { @@ -2961,7 +2961,7 @@ pub fn copy_file_range(fd_in: fd_t, off_in: ?*off_t, fd_out: fd_t, off_out: ?*of } pub fn bpf(cmd: BPF.Cmd, attr: *BPF.Attr, size: u32) usize { - return syscall3(.bpf, @intFromEnum(cmd), @intFromPtr(attr), size); + return syscall3(.bpf, @backingInt(cmd), @intFromPtr(attr), size); } pub fn sync() void { @@ -2998,7 +2998,7 @@ pub fn prlimit(pid: pid_t, resource: rlimit_resource, new_limit: ?*const rlimit, return syscall4( .prlimit64, @as(u32, @bitCast(pid)), - @as(u32, @bitCast(@as(i32, @intFromEnum(resource)))), + @as(u32, @bitCast(@as(i32, @backingInt(resource)))), @intFromPtr(new_limit), @intFromPtr(old_limit), ); @@ -3029,7 +3029,7 @@ pub fn pidfd_send_signal(pidfd: fd_t, sig: SIG, info: ?*siginfo_t, flags: u32) u return syscall4( .pidfd_send_signal, @as(u32, @bitCast(pidfd)), - @intFromEnum(sig), + @backingInt(sig), @intFromPtr(info), flags, ); @@ -4346,10 +4346,10 @@ pub const W = struct { return @as(u8, @intCast((s & 0xff00) >> 8)); } pub fn TERMSIG(s: u32) SIG { - return @enumFromInt(s & 0x7f); + return @fromBackingInt(@intCast(s & 0x7f)); } pub fn STOPSIG(s: u32) SIG { - return @enumFromInt(EXITSTATUS(s)); + return @fromBackingInt(@intCast(EXITSTATUS(s))); } pub fn IFEXITED(s: u32) bool { return (s & 0x7f) == 0; @@ -7258,26 +7258,26 @@ pub const IOSQE_BIT = enum(u8) { // io_uring_sqe.flags /// use fixed fileset -pub const IOSQE_FIXED_FILE = 1 << @intFromEnum(IOSQE_BIT.FIXED_FILE); +pub const IOSQE_FIXED_FILE = 1 << @backingInt(IOSQE_BIT.FIXED_FILE); /// issue after inflight IO -pub const IOSQE_IO_DRAIN = 1 << @intFromEnum(IOSQE_BIT.IO_DRAIN); +pub const IOSQE_IO_DRAIN = 1 << @backingInt(IOSQE_BIT.IO_DRAIN); /// links next sqe -pub const IOSQE_IO_LINK = 1 << @intFromEnum(IOSQE_BIT.IO_LINK); +pub const IOSQE_IO_LINK = 1 << @backingInt(IOSQE_BIT.IO_LINK); /// like LINK, but stronger -pub const IOSQE_IO_HARDLINK = 1 << @intFromEnum(IOSQE_BIT.IO_HARDLINK); +pub const IOSQE_IO_HARDLINK = 1 << @backingInt(IOSQE_BIT.IO_HARDLINK); /// always go async -pub const IOSQE_ASYNC = 1 << @intFromEnum(IOSQE_BIT.ASYNC); +pub const IOSQE_ASYNC = 1 << @backingInt(IOSQE_BIT.ASYNC); /// select buffer from buf_group -pub const IOSQE_BUFFER_SELECT = 1 << @intFromEnum(IOSQE_BIT.BUFFER_SELECT); +pub const IOSQE_BUFFER_SELECT = 1 << @backingInt(IOSQE_BIT.BUFFER_SELECT); /// don't post CQE if request succeeded /// Available since Linux 5.17 -pub const IOSQE_CQE_SKIP_SUCCESS = 1 << @intFromEnum(IOSQE_BIT.CQE_SKIP_SUCCESS); +pub const IOSQE_CQE_SKIP_SUCCESS = 1 << @backingInt(IOSQE_BIT.CQE_SKIP_SUCCESS); pub const IORING_OP = enum(u8) { NOP, @@ -7437,7 +7437,7 @@ pub const io_uring_cqe = extern struct { pub fn err(self: io_uring_cqe) E { if (self.res > -4096 and self.res < 0) { - return @as(E, @enumFromInt(-self.res)); + return @as(E, @fromBackingInt(@intCast(-self.res))); } return .SUCCESS; } @@ -7724,8 +7724,8 @@ pub const io_uring_probe = extern struct { /// Is the operation supported on the running kernel. pub fn is_supported(self: @This(), op: IORING_OP) bool { - const i = @intFromEnum(op); - if (i > @intFromEnum(self.last_op) or i >= self.ops_len) + const i = @backingInt(op); + if (i > @backingInt(self.last_op) or i >= self.ops_len) return false; return self.ops[i].is_supported(); } @@ -10741,7 +10741,7 @@ pub const AUDIT = struct { LOONGARCH64 = toAudit(.LOONGARCH, @"64BIT" | LE), fn toAudit(em: elf.EM, flags: u32) u32 { - return @intFromEnum(em) | flags; + return @backingInt(em) | flags; } pub const current: AUDIT.ARCH = switch (native_arch) { diff --git a/lib/std/os/linux/IoUring/test.zig b/lib/std/os/linux/IoUring/test.zig index 27925c81fb138ec20efbb6bc05acfff5a4a09879..40429fbaab1cb7fb35a90427c69c2640ad907ed6 100644 --- a/lib/std/os/linux/IoUring/test.zig +++ b/lib/std/os/linux/IoUring/test.zig @@ -589,7 +589,7 @@ test "sendmsg/recvmsg" { try testing.expectEqual(@as(u32, 2), ring.cq_ready()); const cqe_sendmsg = try ring.copy_cqe(); - if (cqe_sendmsg.res == -@as(i32, @intFromEnum(linux.E.INVAL))) return error.SkipZigTest; + if (cqe_sendmsg.res == -@as(i32, @backingInt(linux.E.INVAL))) return error.SkipZigTest; try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x11111111, .res = buffer_send.len, @@ -597,7 +597,7 @@ test "sendmsg/recvmsg" { }, cqe_sendmsg); const cqe_recvmsg = try ring.copy_cqe(); - if (cqe_recvmsg.res == -@as(i32, @intFromEnum(linux.E.INVAL))) return error.SkipZigTest; + if (cqe_recvmsg.res == -@as(i32, @backingInt(linux.E.INVAL))) return error.SkipZigTest; try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x22222222, .res = buffer_recv.len, @@ -631,7 +631,7 @@ test "timeout (after a relative time)" { try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x55555555, - .res = -@as(i32, @intFromEnum(linux.E.TIME)), + .res = -@as(i32, @backingInt(linux.E.TIME)), .flags = 0, }, cqe); @@ -716,7 +716,7 @@ test "timeout_remove" { if (cqe.user_data == 0x88888888) { try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0x88888888, - .res = -@as(i32, @intFromEnum(linux.E.CANCELED)), + .res = -@as(i32, @backingInt(linux.E.CANCELED)), .flags = 0, }, cqe); } else if (cqe.user_data == 0x99999999) { @@ -759,16 +759,16 @@ test "accept/connect/recv/link_timeout" { const cqe = try ring.copy_cqe(); switch (cqe.user_data) { 0xffffffff => { - if (cqe.res != -@as(i32, @intFromEnum(linux.E.INTR)) and - cqe.res != -@as(i32, @intFromEnum(linux.E.CANCELED))) + if (cqe.res != -@as(i32, @backingInt(linux.E.INTR)) and + cqe.res != -@as(i32, @backingInt(linux.E.CANCELED))) { std.debug.print("Req 0x{x} got {d}\n", .{ cqe.user_data, cqe.res }); try testing.expect(false); } }, 0x22222222 => { - if (cqe.res != -@as(i32, @intFromEnum(linux.E.ALREADY)) and - cqe.res != -@as(i32, @intFromEnum(linux.E.TIME))) + if (cqe.res != -@as(i32, @backingInt(linux.E.ALREADY)) and + cqe.res != -@as(i32, @backingInt(linux.E.TIME))) { std.debug.print("Req 0x{x} got {d}\n", .{ cqe.user_data, cqe.res }); try testing.expect(false); @@ -922,7 +922,7 @@ test "accept/connect/recv/cancel" { try testing.expectEqual(linux.io_uring_cqe{ .user_data = 0xffffffff, - .res = -@as(i32, @intFromEnum(linux.E.CANCELED)), + .res = -@as(i32, @backingInt(linux.E.CANCELED)), .flags = 0, }, cqe_recv); diff --git a/lib/std/os/linux/aarch64.zig b/lib/std/os/linux/aarch64.zig index 6242ed9ff0789cf4876d5f14b3cd278cc84afe0d..a49c1d48bedd05331da4a7a25c6f1006797aa251 100644 --- a/lib/std/os/linux/aarch64.zig +++ b/lib/std/os/linux/aarch64.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u64 { return asm volatile ("svc #0" : [ret] "={x0}" (-> u64), - : [number] "{x8}" (@intFromEnum(number)), + : [number] "{x8}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u64 { return asm volatile ("svc #0" : [ret] "={x0}" (-> u64), - : [number] "{x8}" (@intFromEnum(number)), + : [number] "{x8}" (@backingInt(number)), [arg1] "{x0}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u64 { return asm volatile ("svc #0" : [ret] "={x0}" (-> u64), - : [number] "{x8}" (@intFromEnum(number)), + : [number] "{x8}" (@backingInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u64 { return asm volatile ("svc #0" : [ret] "={x0}" (-> u64), - : [number] "{x8}" (@intFromEnum(number)), + : [number] "{x8}" (@backingInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u64 { return asm volatile ("svc #0" : [ret] "={x0}" (-> u64), - : [number] "{x8}" (@intFromEnum(number)), + : [number] "{x8}" (@backingInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u64 { return asm volatile ("svc #0" : [ret] "={x0}" (-> u64), - : [number] "{x8}" (@intFromEnum(number)), + : [number] "{x8}" (@backingInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u64 { return asm volatile ("svc #0" : [ret] "={x0}" (-> u64), - : [number] "{x8}" (@intFromEnum(number)), + : [number] "{x8}" (@backingInt(number)), [arg1] "{x0}" (arg1), [arg2] "{x1}" (arg2), [arg3] "{x2}" (arg3), @@ -157,12 +157,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ mov x8, %[number] \\ svc #0 : - : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "i" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ svc #0 : - : [number] "{x8}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{x8}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/arc.zig b/lib/std/os/linux/arc.zig index 9176546859000310359df1012b988cb633bc2352..8721de28f9922068d405cda98f4b64da474b69ab 100644 --- a/lib/std/os/linux/arc.zig +++ b/lib/std/os/linux/arc.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("trap_s 0" : [ret] "={r0}" (-> u32), - : [number] "{r8}" (@intFromEnum(number)), + : [number] "{r8}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("trap_s 0" : [ret] "={r0}" (-> u32), - : [number] "{r8}" (@intFromEnum(number)), + : [number] "{r8}" (@backingInt(number)), [arg1] "{r0}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("trap_s 0" : [ret] "={r0}" (-> u32), - : [number] "{r8}" (@intFromEnum(number)), + : [number] "{r8}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("trap_s 0" : [ret] "={r0}" (-> u32), - : [number] "{r8}" (@intFromEnum(number)), + : [number] "{r8}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("trap_s 0" : [ret] "={r0}" (-> u32), - : [number] "{r8}" (@intFromEnum(number)), + : [number] "{r8}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("trap_s 0" : [ret] "={r0}" (-> u32), - : [number] "{r8}" (@intFromEnum(number)), + : [number] "{r8}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("trap_s 0" : [ret] "={r0}" (-> u32), - : [number] "{r8}" (@intFromEnum(number)), + : [number] "{r8}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -158,12 +158,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ mov r8, %[number] \\ trap_s 0 : - : [number] "I" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "I" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ trap_s 0 : - : [number] "{r8}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{r8}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/arm.zig b/lib/std/os/linux/arm.zig index c40f2f4031393630d9b8d42213c3ddcf55673f6a..d198c03748a9ad119a477b0de580770d441396ea 100644 --- a/lib/std/os/linux/arm.zig +++ b/lib/std/os/linux/arm.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("svc #0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("svc #0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("svc #0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("svc #0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("svc #0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("svc #0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("svc #0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -151,12 +151,12 @@ pub fn restore() callconv(.naked) noreturn { \\ mov r7, %[number] \\ svc #0 : - : [number] "I" (@intFromEnum(SYS.sigreturn)), + : [number] "I" (@backingInt(SYS.sigreturn)), ), else => asm volatile ( \\ svc #0 : - : [number] "{r7}" (@intFromEnum(SYS.sigreturn)), + : [number] "{r7}" (@backingInt(SYS.sigreturn)), ), } } @@ -167,12 +167,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ mov r7, %[number] \\ svc #0 : - : [number] "I" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "I" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ svc #0 : - : [number] "{r7}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{r7}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/bpf.zig b/lib/std/os/linux/bpf.zig index 6bad724ba6d204568e93f51512e451e11a57cdca..5c672899ca8745d802cef621ccda9049c8c7f159 100644 --- a/lib/std/os/linux/bpf.zig +++ b/lib/std/os/linux/bpf.zig @@ -547,10 +547,10 @@ pub const Insn = packed struct { return Insn{ .code = code | src_type, - .dst = @intFromEnum(dst), + .dst = @backingInt(dst), .src = switch (imm_or_reg) { .imm => 0, - .reg => |r| @intFromEnum(r), + .reg => |r| @backingInt(r), }, .off = off, .imm = switch (imm_or_reg) { @@ -567,7 +567,7 @@ pub const Insn = packed struct { else => @compileError("width must be 32 or 64"), }; - return imm_reg(width_bitfield | @intFromEnum(op), dst, src, 0); + return imm_reg(width_bitfield | @backingInt(op), dst, src, 0); } pub fn mov(dst: Reg, src: anytype) Insn { @@ -623,7 +623,7 @@ pub const Insn = packed struct { } pub fn jmp(op: JmpOp, dst: Reg, src: anytype, off: i16) Insn { - return imm_reg(JMP | @intFromEnum(op), dst, src, off); + return imm_reg(JMP | @backingInt(op), dst, src, off); } pub fn ja(off: i16) Insn { @@ -677,8 +677,8 @@ pub const Insn = packed struct { pub fn xadd(dst: Reg, src: Reg) Insn { return Insn{ .code = STX | XADD | DW, - .dst = @intFromEnum(dst), - .src = @intFromEnum(src), + .dst = @backingInt(dst), + .src = @backingInt(src), .off = 0, .imm = 0, }; @@ -686,9 +686,9 @@ pub const Insn = packed struct { fn ld(mode: Mode, size: Size, dst: Reg, src: Reg, imm: i32) Insn { return Insn{ - .code = @intFromEnum(mode) | @intFromEnum(size) | LD, - .dst = @intFromEnum(dst), - .src = @intFromEnum(src), + .code = @backingInt(mode) | @backingInt(size) | LD, + .dst = @backingInt(dst), + .src = @backingInt(src), .off = 0, .imm = imm, }; @@ -704,9 +704,9 @@ pub const Insn = packed struct { pub fn ldx(size: Size, dst: Reg, src: Reg, off: i16) Insn { return Insn{ - .code = MEM | @intFromEnum(size) | LDX, - .dst = @intFromEnum(dst), - .src = @intFromEnum(src), + .code = MEM | @backingInt(size) | LDX, + .dst = @backingInt(dst), + .src = @backingInt(src), .off = off, .imm = 0, }; @@ -715,8 +715,8 @@ pub const Insn = packed struct { fn ld_imm_impl1(dst: Reg, src: Reg, imm: u64) Insn { return Insn{ .code = LD | DW | IMM, - .dst = @intFromEnum(dst), - .src = @intFromEnum(src), + .dst = @backingInt(dst), + .src = @backingInt(src), .off = 0, .imm = @as(i32, @bitCast(@as(u32, @truncate(imm)))), }; @@ -741,7 +741,7 @@ pub const Insn = packed struct { } pub fn ld_map_fd1(dst: Reg, map_fd: fd_t) Insn { - return ld_imm_impl1(dst, @as(Reg, @enumFromInt(PSEUDO_MAP_FD)), @as(u64, @intCast(map_fd))); + return ld_imm_impl1(dst, @as(Reg, @fromBackingInt(@intCast(PSEUDO_MAP_FD))), @as(u64, @intCast(map_fd))); } pub fn ld_map_fd2(map_fd: fd_t) Insn { @@ -750,8 +750,8 @@ pub const Insn = packed struct { pub fn st(size: Size, dst: Reg, off: i16, imm: i32) Insn { return Insn{ - .code = MEM | @intFromEnum(size) | ST, - .dst = @intFromEnum(dst), + .code = MEM | @backingInt(size) | ST, + .dst = @backingInt(dst), .src = 0, .off = off, .imm = imm, @@ -760,9 +760,9 @@ pub const Insn = packed struct { pub fn stx(size: Size, dst: Reg, off: i16, src: Reg) Insn { return Insn{ - .code = MEM | @intFromEnum(size) | STX, - .dst = @intFromEnum(dst), - .src = @intFromEnum(src), + .code = MEM | @backingInt(size) | STX, + .dst = @backingInt(dst), + .src = @backingInt(src), .off = off, .imm = 0, }; @@ -774,7 +774,7 @@ pub const Insn = packed struct { .big => 0xdc, .little => 0xd4, }, - .dst = @intFromEnum(dst), + .dst = @backingInt(dst), .src = 0, .off = 0, .imm = switch (size) { @@ -800,7 +800,7 @@ pub const Insn = packed struct { .dst = 0, .src = 0, .off = 0, - .imm = @intFromEnum(helper), + .imm = @backingInt(helper), }; } @@ -1614,7 +1614,7 @@ pub fn map_create(map_type: MapType, key_size: u32, value_size: u32, max_entries .map_create = std.mem.zeroes(MapCreateAttr), }; - attr.map_create.map_type = @intFromEnum(map_type); + attr.map_create.map_type = @backingInt(map_type); attr.map_create.key_size = key_size; attr.map_create.value_size = value_size; attr.map_create.max_entries = max_entries; @@ -1769,7 +1769,7 @@ pub fn prog_load( .prog_load = std.mem.zeroes(ProgLoadAttr), }; - attr.prog_load.prog_type = @intFromEnum(prog_type); + attr.prog_load.prog_type = @backingInt(prog_type); attr.prog_load.insns = @intFromPtr(insns.ptr); attr.prog_load.insn_cnt = @as(u32, @intCast(insns.len)); attr.prog_load.license = @intFromPtr(license.ptr); diff --git a/lib/std/os/linux/csky.zig b/lib/std/os/linux/csky.zig index 415be706cc9b223051ff9aae126a14ac2716f0f9..9a0e854979d79614c8b40235d39e5e03f873bb04 100644 --- a/lib/std/os/linux/csky.zig +++ b/lib/std/os/linux/csky.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("trap 0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("trap 0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("trap 0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("trap 0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("trap 0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("trap 0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("trap 0" : [ret] "={r0}" (-> u32), - : [number] "{r7}" (@intFromEnum(number)), + : [number] "{r7}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), diff --git a/lib/std/os/linux/hexagon.zig b/lib/std/os/linux/hexagon.zig index ef410e0a454abc888777d8ae70d9571238f81ac4..3777c1510449d0e937b1e392b21e33e9c524c00d 100644 --- a/lib/std/os/linux/hexagon.zig +++ b/lib/std/os/linux/hexagon.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("trap0(#1)" : [ret] "={r0}" (-> u32), - : [number] "{r6}" (@intFromEnum(number)), + : [number] "{r6}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("trap0(#1)" : [ret] "={r0}" (-> u32), - : [number] "{r6}" (@intFromEnum(number)), + : [number] "{r6}" (@backingInt(number)), [arg1] "{r0}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("trap0(#1)" : [ret] "={r0}" (-> u32), - : [number] "{r6}" (@intFromEnum(number)), + : [number] "{r6}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("trap0(#1)" : [ret] "={r0}" (-> u32), - : [number] "{r6}" (@intFromEnum(number)), + : [number] "{r6}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("trap0(#1)" : [ret] "={r0}" (-> u32), - : [number] "{r6}" (@intFromEnum(number)), + : [number] "{r6}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -72,7 +72,7 @@ pub fn syscall4( pub fn syscall5(number: SYS, arg1: u32, arg2: u32, arg3: u32, arg4: u32, arg5: u32) u32 { return asm volatile ("trap0(#1)" : [ret] "={r0}" (-> u32), - : [number] "{r6}" (@intFromEnum(number)), + : [number] "{r6}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), @@ -92,7 +92,7 @@ pub fn syscall6( ) u32 { return asm volatile ("trap0(#1)" : [ret] "={r0}" (-> u32), - : [number] "{r6}" (@intFromEnum(number)), + : [number] "{r6}" (@backingInt(number)), [arg1] "{r0}" (arg1), [arg2] "{r1}" (arg2), [arg3] "{r2}" (arg3), diff --git a/lib/std/os/linux/io_uring_sqe.zig b/lib/std/os/linux/io_uring_sqe.zig index 808276170a227278936a01ba636dd127e78e35e8..cdd3a86c5a9e20c257c7089f6dc552e61d254172 100644 --- a/lib/std/os/linux/io_uring_sqe.zig +++ b/lib/std/os/linux/io_uring_sqe.zig @@ -615,7 +615,7 @@ pub const io_uring_sqe = extern struct { options: u32, flags: u32, ) void { - sqe.prep_rw(.WAITID, id, 0, @intFromEnum(id_type), @intFromPtr(infop)); + sqe.prep_rw(.WAITID, id, 0, @backingInt(id_type), @intFromPtr(infop)); sqe.rw_flags = flags; sqe.splice_fd_in = @bitCast(options); } @@ -652,7 +652,7 @@ pub const io_uring_sqe = extern struct { ) void { sqe.prep_rw(.URING_CMD, fd, 0, 0, 0); // off is overloaded with cmd_op, https://github.com/axboe/liburing/blob/e1003e496e66f9b0ae06674869795edf772d5500/src/include/liburing/io_uring.h#L39 - sqe.off = @intFromEnum(cmd_op); + sqe.off = @backingInt(cmd_op); // addr is overloaded, https://github.com/axboe/liburing/blob/e1003e496e66f9b0ae06674869795edf772d5500/src/include/liburing/io_uring.h#L46 sqe.addr = @bitCast(packed struct { level: u32, diff --git a/lib/std/os/linux/loongarch32.zig b/lib/std/os/linux/loongarch32.zig index c5d1589aa3df476dbb638ae7dce6bb28a3e3bd39..b5f0e52eef6a3a13bc21ec6d2f5be54cf7c0d74d 100644 --- a/lib/std/os/linux/loongarch32.zig +++ b/lib/std/os/linux/loongarch32.zig @@ -10,7 +10,7 @@ pub fn syscall0( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u32), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); } @@ -21,7 +21,7 @@ pub fn syscall1( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u32), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); } @@ -34,7 +34,7 @@ pub fn syscall2( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u32), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); @@ -49,7 +49,7 @@ pub fn syscall3( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u32), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), @@ -66,7 +66,7 @@ pub fn syscall4( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u32), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), @@ -85,7 +85,7 @@ pub fn syscall5( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u32), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), @@ -106,7 +106,7 @@ pub fn syscall6( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u32), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), diff --git a/lib/std/os/linux/loongarch64.zig b/lib/std/os/linux/loongarch64.zig index 283a4de13484c7489bca7a48d3714ae5136291f4..cf841ee05a66ab74bf73a71ff88c4bdbe072e983 100644 --- a/lib/std/os/linux/loongarch64.zig +++ b/lib/std/os/linux/loongarch64.zig @@ -10,7 +10,7 @@ pub fn syscall0( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); } @@ -21,7 +21,7 @@ pub fn syscall1( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); } @@ -34,7 +34,7 @@ pub fn syscall2( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), : .{ .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r16 = true, .r17 = true, .r18 = true, .r19 = true, .r20 = true, .memory = true }); @@ -49,7 +49,7 @@ pub fn syscall3( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), @@ -66,7 +66,7 @@ pub fn syscall4( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), @@ -85,7 +85,7 @@ pub fn syscall5( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), @@ -106,7 +106,7 @@ pub fn syscall6( return asm volatile ( \\ syscall 0 : [ret] "={$r4}" (-> u64), - : [number] "{$r11}" (@intFromEnum(number)), + : [number] "{$r11}" (@backingInt(number)), [arg1] "{$r4}" (arg1), [arg2] "{$r5}" (arg2), [arg3] "{$r6}" (arg3), diff --git a/lib/std/os/linux/m68k.zig b/lib/std/os/linux/m68k.zig index 8a5cabc17cab9c3bd430b9d6e50ad2910883eb4f..019521e8706357f451756dcc5d71cc6896c6bf32 100644 --- a/lib/std/os/linux/m68k.zig +++ b/lib/std/os/linux/m68k.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("trap #0" : [ret] "={d0}" (-> u32), - : [number] "{d0}" (@intFromEnum(number)), + : [number] "{d0}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("trap #0" : [ret] "={d0}" (-> u32), - : [number] "{d0}" (@intFromEnum(number)), + : [number] "{d0}" (@backingInt(number)), [arg1] "{d1}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("trap #0" : [ret] "={d0}" (-> u32), - : [number] "{d0}" (@intFromEnum(number)), + : [number] "{d0}" (@backingInt(number)), [arg1] "{d1}" (arg1), [arg2] "{d2}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("trap #0" : [ret] "={d0}" (-> u32), - : [number] "{d0}" (@intFromEnum(number)), + : [number] "{d0}" (@backingInt(number)), [arg1] "{d1}" (arg1), [arg2] "{d2}" (arg2), [arg3] "{d3}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("trap #0" : [ret] "={d0}" (-> u32), - : [number] "{d0}" (@intFromEnum(number)), + : [number] "{d0}" (@backingInt(number)), [arg1] "{d1}" (arg1), [arg2] "{d2}" (arg2), [arg3] "{d3}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("trap #0" : [ret] "={d0}" (-> u32), - : [number] "{d0}" (@intFromEnum(number)), + : [number] "{d0}" (@backingInt(number)), [arg1] "{d1}" (arg1), [arg2] "{d2}" (arg2), [arg3] "{d3}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("trap #0" : [ret] "={d0}" (-> u32), - : [number] "{d0}" (@intFromEnum(number)), + : [number] "{d0}" (@backingInt(number)), [arg1] "{d1}" (arg1), [arg2] "{d2}" (arg2), [arg3] "{d3}" (arg3), @@ -167,7 +167,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.naked) noreturn { asm volatile ("trap #0" : - : [number] "{d0}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{d0}" (@backingInt(SYS.rt_sigreturn)), ); } diff --git a/lib/std/os/linux/microblaze.zig b/lib/std/os/linux/microblaze.zig index 99455dd2a87047f329a968ad746b8c1c4f56ede6..ae450c1970eee1c5430633284a391ec0fcc41211 100644 --- a/lib/std/os/linux/microblaze.zig +++ b/lib/std/os/linux/microblaze.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("brki r14, 0x8" : [ret] "={r3}" (-> u32), - : [number] "{r12}" (@intFromEnum(number)), + : [number] "{r12}" (@backingInt(number)), : .{ .r4 = true, .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("brki r14, 0x8" : [ret] "={r3}" (-> u32), - : [number] "{r12}" (@intFromEnum(number)), + : [number] "{r12}" (@backingInt(number)), [arg1] "{r5}" (arg1), : .{ .r4 = true, .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("brki r14, 0x8" : [ret] "={r3}" (-> u32), - : [number] "{r12}" (@intFromEnum(number)), + : [number] "{r12}" (@backingInt(number)), [arg1] "{r5}" (arg1), [arg2] "{r6}" (arg2), : .{ .r4 = true, .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("brki r14, 0x8" : [ret] "={r3}" (-> u32), - : [number] "{r12}" (@intFromEnum(number)), + : [number] "{r12}" (@backingInt(number)), [arg1] "{r5}" (arg1), [arg2] "{r6}" (arg2), [arg3] "{r7}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("brki r14, 0x8" : [ret] "={r3}" (-> u32), - : [number] "{r12}" (@intFromEnum(number)), + : [number] "{r12}" (@backingInt(number)), [arg1] "{r5}" (arg1), [arg2] "{r6}" (arg2), [arg3] "{r7}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("brki r14, 0x8" : [ret] "={r3}" (-> u32), - : [number] "{r12}" (@intFromEnum(number)), + : [number] "{r12}" (@backingInt(number)), [arg1] "{r5}" (arg1), [arg2] "{r6}" (arg2), [arg3] "{r7}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("brki r14, 0x8" : [ret] "={r3}" (-> u32), - : [number] "{r12}" (@intFromEnum(number)), + : [number] "{r12}" (@backingInt(number)), [arg1] "{r5}" (arg1), [arg2] "{r6}" (arg2), [arg3] "{r7}" (arg3), @@ -153,7 +153,7 @@ pub fn restore() callconv(.naked) noreturn { asm volatile ( \\ brki r14, 0x8 : - : [number] "{r7}" (@intFromEnum(SYS.sigreturn)), + : [number] "{r7}" (@backingInt(SYS.sigreturn)), ); } @@ -161,7 +161,7 @@ pub fn restore_rt() callconv(.naked) noreturn { asm volatile ( \\ brki r14, 0x8 : - : [number] "{r7}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{r7}" (@backingInt(SYS.rt_sigreturn)), ); } diff --git a/lib/std/os/linux/mips.zig b/lib/std/os/linux/mips.zig index 262219005d7c18707475c628462f1ae394c051c2..ca1e59053dcb5636c599d018160087f1067a5db9 100644 --- a/lib/std/os/linux/mips.zig +++ b/lib/std/os/linux/mips.zig @@ -14,7 +14,7 @@ pub fn syscall0( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } @@ -29,7 +29,7 @@ pub fn syscall1( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } @@ -46,7 +46,7 @@ pub fn syscall2( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); @@ -65,7 +65,7 @@ pub fn syscall3( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -86,7 +86,7 @@ pub fn syscall4( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -115,7 +115,7 @@ pub fn syscall5( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -144,7 +144,7 @@ pub fn syscall6( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -176,7 +176,7 @@ pub fn syscall7( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -201,7 +201,7 @@ pub fn syscall_pipe( \\ sw $v1, 4($a0) \\2: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(SYS.pipe)), + : [number] "{$2}" (@backingInt(SYS.pipe)), [fd] "{$4}" (fd), : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } diff --git a/lib/std/os/linux/mips64.zig b/lib/std/os/linux/mips64.zig index 5e70cfc6dc3fdbe956794c852eece2fc54e29090..a9ed38257c8c9fb3f25e44b7792b7d8ad1c61d93 100644 --- a/lib/std/os/linux/mips64.zig +++ b/lib/std/os/linux/mips64.zig @@ -14,7 +14,7 @@ pub fn syscall0( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } @@ -29,7 +29,7 @@ pub fn syscall1( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } @@ -46,7 +46,7 @@ pub fn syscall2( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); @@ -65,7 +65,7 @@ pub fn syscall3( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -86,7 +86,7 @@ pub fn syscall4( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -109,7 +109,7 @@ pub fn syscall5( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -134,7 +134,7 @@ pub fn syscall6( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -158,7 +158,7 @@ pub fn syscall_pipe( \\ sw $v1, 4($a0) \\2: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(SYS.pipe)), + : [number] "{$2}" (@backingInt(SYS.pipe)), [fd] "{$4}" (fd), : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } diff --git a/lib/std/os/linux/mipsn32.zig b/lib/std/os/linux/mipsn32.zig index fcaebaa9189e5d005d8026febad952fe29e8ba7d..bc1744242729cc3cbce3f7b07215753e564b9461 100644 --- a/lib/std/os/linux/mipsn32.zig +++ b/lib/std/os/linux/mipsn32.zig @@ -14,7 +14,7 @@ pub fn syscall0( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), : .{ .r1 = true, .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } @@ -29,7 +29,7 @@ pub fn syscall1( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } @@ -46,7 +46,7 @@ pub fn syscall2( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), : .{ .r1 = true, .r3 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); @@ -65,7 +65,7 @@ pub fn syscall3( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -86,7 +86,7 @@ pub fn syscall4( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -109,7 +109,7 @@ pub fn syscall5( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -134,7 +134,7 @@ pub fn syscall6( \\ subu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(number)), + : [number] "{$2}" (@backingInt(number)), [arg1] "{$4}" (arg1), [arg2] "{$5}" (arg2), [arg3] "{$6}" (arg3), @@ -158,7 +158,7 @@ pub fn syscall_pipe( \\ sw $v1, 4($a0) \\2: : [ret] "={$2}" (-> u32), - : [number] "{$2}" (@intFromEnum(SYS.pipe)), + : [number] "{$2}" (@backingInt(SYS.pipe)), [fd] "{$4}" (fd), : .{ .r1 = true, .r3 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .r13 = true, .r14 = true, .r15 = true, .r24 = true, .r25 = true, .hi = true, .lo = true, .memory = true }); } @@ -175,7 +175,7 @@ pub fn syscall_lseek( \\ dsubu $v0, $zero, $v0 \\1: : [ret] "={$2}" (-> u64), - : [number] "{$2}" (@intFromEnum(SYS.lseek)), + : [number] "{$2}" (@backingInt(SYS.lseek)), [fd] "{$4}" (@as(u32, @bitCast(fd))), [offset] "{$5}" (@as(u64, @bitCast(offset))), [whence] "{$6}" (whence), diff --git a/lib/std/os/linux/or1k.zig b/lib/std/os/linux/or1k.zig index 620fd4c736c5fec1edbc8a597bd83fba78b41ed7..2d27b49a8f4f44c4a8f601df3d108c8eedfe0f17 100644 --- a/lib/std/os/linux/or1k.zig +++ b/lib/std/os/linux/or1k.zig @@ -10,7 +10,7 @@ pub fn syscall0( return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), - : [number] "{r11}" (@intFromEnum(number)), + : [number] "{r11}" (@backingInt(number)), : .{ .r3 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = true, .memory = true }); } @@ -21,7 +21,7 @@ pub fn syscall1( return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), - : [number] "{r11}" (@intFromEnum(number)), + : [number] "{r11}" (@backingInt(number)), [arg1] "{r3}" (arg1), : .{ .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = true, .memory = true }); } @@ -34,7 +34,7 @@ pub fn syscall2( return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), - : [number] "{r11}" (@intFromEnum(number)), + : [number] "{r11}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), : .{ .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r12 = true, .r13 = true, .r15 = true, .r17 = true, .r19 = true, .r21 = true, .r23 = true, .r25 = true, .r27 = true, .r29 = true, .r31 = true, .memory = true }); @@ -49,7 +49,7 @@ pub fn syscall3( return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), - : [number] "{r11}" (@intFromEnum(number)), + : [number] "{r11}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -66,7 +66,7 @@ pub fn syscall4( return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), - : [number] "{r11}" (@intFromEnum(number)), + : [number] "{r11}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -85,7 +85,7 @@ pub fn syscall5( return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), - : [number] "{r11}" (@intFromEnum(number)), + : [number] "{r11}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -106,7 +106,7 @@ pub fn syscall6( return asm volatile ( \\ l.sys 1 : [ret] "={r11}" (-> u32), - : [number] "{r11}" (@intFromEnum(number)), + : [number] "{r11}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), diff --git a/lib/std/os/linux/powerpc.zig b/lib/std/os/linux/powerpc.zig index 7d7212de934213e95d06127294c82acf26657ad2..614c981f8ff891e2e3fed978b65866da9d9a6ab3 100644 --- a/lib/std/os/linux/powerpc.zig +++ b/lib/std/os/linux/powerpc.zig @@ -19,7 +19,7 @@ pub fn syscall0( \\ 1: : [ret] "={r3}" (-> u32), [r0_out] "={r0}" (r0_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } @@ -36,7 +36,7 @@ pub fn syscall1( \\ 1: : [ret] "={r3}" (-> u32), [r0_out] "={r0}" (r0_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } @@ -57,7 +57,7 @@ pub fn syscall2( : [ret] "={r3}" (-> u32), [r0_out] "={r0}" (r0_out), [r4_out] "={r4}" (r4_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); @@ -82,7 +82,7 @@ pub fn syscall3( [r0_out] "={r0}" (r0_out), [r4_out] "={r4}" (r4_out), [r5_out] "={r5}" (r5_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -111,7 +111,7 @@ pub fn syscall4( [r4_out] "={r4}" (r4_out), [r5_out] "={r5}" (r5_out), [r6_out] "={r6}" (r6_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -144,7 +144,7 @@ pub fn syscall5( [r5_out] "={r5}" (r5_out), [r6_out] "={r6}" (r6_out), [r7_out] "={r7}" (r7_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -181,7 +181,7 @@ pub fn syscall6( [r6_out] "={r6}" (r6_out), [r7_out] "={r7}" (r7_out), [r8_out] "={r8}" (r8_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -267,12 +267,12 @@ pub fn restore() callconv(.naked) noreturn { \\ li 0, %[number] \\ sc : - : [number] "i" (@intFromEnum(SYS.sigreturn)), + : [number] "i" (@backingInt(SYS.sigreturn)), ), else => asm volatile ( \\ sc : - : [number] "{r0}" (@intFromEnum(SYS.sigreturn)), + : [number] "{r0}" (@backingInt(SYS.sigreturn)), ), } } @@ -283,12 +283,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ li 0, %[number] \\ sc : - : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "i" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ sc : - : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{r0}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/powerpc64.zig b/lib/std/os/linux/powerpc64.zig index 84a60f7c1f336aaabea8086b424171a1fd793f29..89f3dbde7b3736d7cc021d55f0b9fb753f347789 100644 --- a/lib/std/os/linux/powerpc64.zig +++ b/lib/std/os/linux/powerpc64.zig @@ -19,7 +19,7 @@ pub fn syscall0( \\ 1: : [ret] "={r3}" (-> u64), [r0_out] "={r0}" (r0_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } @@ -36,7 +36,7 @@ pub fn syscall1( \\ 1: : [ret] "={r3}" (-> u64), [r0_out] "={r0}" (r0_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), : .{ .memory = true, .cr0 = true, .r4 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); } @@ -57,7 +57,7 @@ pub fn syscall2( : [ret] "={r3}" (-> u64), [r0_out] "={r0}" (r0_out), [r4_out] "={r4}" (r4_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), : .{ .memory = true, .cr0 = true, .r5 = true, .r6 = true, .r7 = true, .r8 = true, .r9 = true, .r10 = true, .r11 = true, .r12 = true, .ctr = true, .xer = true }); @@ -82,7 +82,7 @@ pub fn syscall3( [r0_out] "={r0}" (r0_out), [r4_out] "={r4}" (r4_out), [r5_out] "={r5}" (r5_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -111,7 +111,7 @@ pub fn syscall4( [r4_out] "={r4}" (r4_out), [r5_out] "={r5}" (r5_out), [r6_out] "={r6}" (r6_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -144,7 +144,7 @@ pub fn syscall5( [r5_out] "={r5}" (r5_out), [r6_out] "={r6}" (r6_out), [r7_out] "={r7}" (r7_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -181,7 +181,7 @@ pub fn syscall6( [r6_out] "={r6}" (r6_out), [r7_out] "={r7}" (r7_out), [r8_out] "={r8}" (r8_out), - : [number] "{r0}" (@intFromEnum(number)), + : [number] "{r0}" (@backingInt(number)), [arg1] "{r3}" (arg1), [arg2] "{r4}" (arg2), [arg3] "{r5}" (arg3), @@ -252,12 +252,12 @@ pub fn restore() callconv(.naked) noreturn { \\ li 0, %[number] \\ sc : - : [number] "i" (@intFromEnum(SYS.sigreturn)), + : [number] "i" (@backingInt(SYS.sigreturn)), ), else => asm volatile ( \\ sc : - : [number] "{r0}" (@intFromEnum(SYS.sigreturn)), + : [number] "{r0}" (@backingInt(SYS.sigreturn)), ), } } @@ -268,12 +268,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ li 0, %[number] \\ sc : - : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "i" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ sc : - : [number] "{r0}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{r0}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/riscv32.zig b/lib/std/os/linux/riscv32.zig index 42b30ee9ff8eb0738ed86c112fda574a627f52b5..ceabe30a87116d5e1ae8114d6f5751c4e15139f4 100644 --- a/lib/std/os/linux/riscv32.zig +++ b/lib/std/os/linux/riscv32.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("ecall" : [ret] "={x10}" (-> u32), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("ecall" : [ret] "={x10}" (-> u32), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("ecall" : [ret] "={x10}" (-> u32), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("ecall" : [ret] "={x10}" (-> u32), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("ecall" : [ret] "={x10}" (-> u32), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("ecall" : [ret] "={x10}" (-> u32), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("ecall" : [ret] "={x10}" (-> u32), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), diff --git a/lib/std/os/linux/riscv64.zig b/lib/std/os/linux/riscv64.zig index 9aa51c2b24d1135c3ca79400d9d8407ba7417398..41dabbb47216c84af9e43ecbe8c89853aee7c584 100644 --- a/lib/std/os/linux/riscv64.zig +++ b/lib/std/os/linux/riscv64.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u64 { return asm volatile ("ecall" : [ret] "={x10}" (-> u64), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u64 { return asm volatile ("ecall" : [ret] "={x10}" (-> u64), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u64 { return asm volatile ("ecall" : [ret] "={x10}" (-> u64), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u64 { return asm volatile ("ecall" : [ret] "={x10}" (-> u64), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u64 { return asm volatile ("ecall" : [ret] "={x10}" (-> u64), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u64 { return asm volatile ("ecall" : [ret] "={x10}" (-> u64), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u64 { return asm volatile ("ecall" : [ret] "={x10}" (-> u64), - : [number] "{x17}" (@intFromEnum(number)), + : [number] "{x17}" (@backingInt(number)), [arg1] "{x10}" (arg1), [arg2] "{x11}" (arg2), [arg3] "{x12}" (arg3), diff --git a/lib/std/os/linux/s390x.zig b/lib/std/os/linux/s390x.zig index e93d39a0d8b5ac264d7f97877c2b9372b048897d..9b9ca0cd0327c93c1260128f42a497e8d96a3094 100644 --- a/lib/std/os/linux/s390x.zig +++ b/lib/std/os/linux/s390x.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u64 { return asm volatile ("svc 0" : [ret] "={r2}" (-> u64), - : [number] "{r1}" (@intFromEnum(number)), + : [number] "{r1}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u64 { return asm volatile ("svc 0" : [ret] "={r2}" (-> u64), - : [number] "{r1}" (@intFromEnum(number)), + : [number] "{r1}" (@backingInt(number)), [arg1] "{r2}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u64 { return asm volatile ("svc 0" : [ret] "={r2}" (-> u64), - : [number] "{r1}" (@intFromEnum(number)), + : [number] "{r1}" (@backingInt(number)), [arg1] "{r2}" (arg1), [arg2] "{r3}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u64 { return asm volatile ("svc 0" : [ret] "={r2}" (-> u64), - : [number] "{r1}" (@intFromEnum(number)), + : [number] "{r1}" (@backingInt(number)), [arg1] "{r2}" (arg1), [arg2] "{r3}" (arg2), [arg3] "{r4}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u64 { return asm volatile ("svc 0" : [ret] "={r2}" (-> u64), - : [number] "{r1}" (@intFromEnum(number)), + : [number] "{r1}" (@backingInt(number)), [arg1] "{r2}" (arg1), [arg2] "{r3}" (arg2), [arg3] "{r4}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u64 { return asm volatile ("svc 0" : [ret] "={r2}" (-> u64), - : [number] "{r1}" (@intFromEnum(number)), + : [number] "{r1}" (@backingInt(number)), [arg1] "{r2}" (arg1), [arg2] "{r3}" (arg2), [arg3] "{r4}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u64 { return asm volatile ("svc 0" : [ret] "={r2}" (-> u64), - : [number] "{r1}" (@intFromEnum(number)), + : [number] "{r1}" (@backingInt(number)), [arg1] "{r2}" (arg1), [arg2] "{r3}" (arg2), [arg3] "{r4}" (arg3), @@ -177,7 +177,7 @@ pub fn restore() callconv(.naked) noreturn { asm volatile ( \\svc 0 : - : [number] "{r1}" (@intFromEnum(SYS.sigreturn)), + : [number] "{r1}" (@backingInt(SYS.sigreturn)), ); } @@ -185,7 +185,7 @@ pub fn restore_rt() callconv(.naked) noreturn { asm volatile ( \\svc 0 : - : [number] "{r1}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{r1}" (@backingInt(SYS.rt_sigreturn)), ); } diff --git a/lib/std/os/linux/sh.zig b/lib/std/os/linux/sh.zig index 8cf495e6bf08aa08fb0b38eb1d339e7ee808b3c3..02581ce183ddb67c2c2eda91cd57b88402d58217 100644 --- a/lib/std/os/linux/sh.zig +++ b/lib/std/os/linux/sh.zig @@ -15,7 +15,7 @@ pub fn syscall0( \\ or r0, r0 \\ or r0, r0 : [ret] "={r0}" (-> u32), - : [number] "{r3}" (@intFromEnum(number)), + : [number] "{r3}" (@backingInt(number)), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall1( \\ or r0, r0 \\ or r0, r0 : [ret] "={r0}" (-> u32), - : [number] "{r3}" (@intFromEnum(number)), + : [number] "{r3}" (@backingInt(number)), [arg1] "{r4}" (arg1), : .{ .memory = true }); } @@ -49,7 +49,7 @@ pub fn syscall2( \\ or r0, r0 \\ or r0, r0 : [ret] "={r0}" (-> u32), - : [number] "{r3}" (@intFromEnum(number)), + : [number] "{r3}" (@backingInt(number)), [arg1] "{r4}" (arg1), [arg2] "{r5}" (arg2), : .{ .memory = true }); @@ -69,7 +69,7 @@ pub fn syscall3( \\ or r0, r0 \\ or r0, r0 : [ret] "={r0}" (-> u32), - : [number] "{r3}" (@intFromEnum(number)), + : [number] "{r3}" (@backingInt(number)), [arg1] "{r4}" (arg1), [arg2] "{r5}" (arg2), [arg3] "{r6}" (arg3), @@ -91,7 +91,7 @@ pub fn syscall4( \\ or r0, r0 \\ or r0, r0 : [ret] "={r0}" (-> u32), - : [number] "{r3}" (@intFromEnum(number)), + : [number] "{r3}" (@backingInt(number)), [arg1] "{r4}" (arg1), [arg2] "{r5}" (arg2), [arg3] "{r6}" (arg3), @@ -115,7 +115,7 @@ pub fn syscall5( \\ or r0, r0 \\ or r0, r0 : [ret] "={r0}" (-> u32), - : [number] "{r3}" (@intFromEnum(number)), + : [number] "{r3}" (@backingInt(number)), [arg1] "{r4}" (arg1), [arg2] "{r5}" (arg2), [arg3] "{r6}" (arg3), @@ -141,7 +141,7 @@ pub fn syscall6( \\ or r0, r0 \\ or r0, r0 : [ret] "={r0}" (-> u32), - : [number] "{r3}" (@intFromEnum(number)), + : [number] "{r3}" (@backingInt(number)), [arg1] "{r4}" (arg1), [arg2] "{r5}" (arg2), [arg3] "{r6}" (arg3), @@ -217,7 +217,7 @@ pub fn restore() callconv(.naked) noreturn { \\ or r0, r0 \\ or r0, r0 : - : [number] "{r3}" (@intFromEnum(SYS.sigreturn)), + : [number] "{r3}" (@backingInt(SYS.sigreturn)), ); } @@ -230,7 +230,7 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ or r0, r0 \\ or r0, r0 : - : [number] "{r3}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{r3}" (@backingInt(SYS.rt_sigreturn)), ); } diff --git a/lib/std/os/linux/sparc.zig b/lib/std/os/linux/sparc.zig index 55a3a22596261612a05b3907e11fe9d82228c3f4..4a2e7188a6b2a9cf582edddf204ce8fc61d4fb95 100644 --- a/lib/std/os/linux/sparc.zig +++ b/lib/std/os/linux/sparc.zig @@ -14,7 +14,7 @@ pub fn syscall0( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } @@ -29,7 +29,7 @@ pub fn syscall1( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } @@ -46,7 +46,7 @@ pub fn syscall2( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); @@ -65,7 +65,7 @@ pub fn syscall3( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -86,7 +86,7 @@ pub fn syscall4( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -109,7 +109,7 @@ pub fn syscall5( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -134,7 +134,7 @@ pub fn syscall6( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -161,7 +161,7 @@ pub fn syscall_pipe( \\ clr %%o0 \\2: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(SYS.pipe)), + : [number] "{g1}" (@backingInt(SYS.pipe)), [arg] "r" (fd), : .{ .memory = true, .g3 = true }); } @@ -184,7 +184,7 @@ pub fn syscall_fork() u32 { \\ and %%o1, %%o0, %%o0 \\2: : [ret] "={o0}" (-> u32), - : [number] "{g1}" (@intFromEnum(SYS.fork)), + : [number] "{g1}" (@backingInt(SYS.fork)), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } @@ -265,7 +265,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.c) void { return asm volatile ("t 0x10" : - : [number] "{g1}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{g1}" (@backingInt(SYS.rt_sigreturn)), : .{ .memory = true, .xcc = true, .o0 = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } diff --git a/lib/std/os/linux/sparc64.zig b/lib/std/os/linux/sparc64.zig index fa23ebdb76ce4484f11c0fe5d572b7ffcb9a51be..f7e859cc72abfe37dfee1f5ab5927979c2625615 100644 --- a/lib/std/os/linux/sparc64.zig +++ b/lib/std/os/linux/sparc64.zig @@ -14,7 +14,7 @@ pub fn syscall0( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } @@ -29,7 +29,7 @@ pub fn syscall1( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } @@ -46,7 +46,7 @@ pub fn syscall2( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); @@ -65,7 +65,7 @@ pub fn syscall3( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -86,7 +86,7 @@ pub fn syscall4( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -109,7 +109,7 @@ pub fn syscall5( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -134,7 +134,7 @@ pub fn syscall6( \\ neg %%o0 \\1: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(number)), + : [number] "{g1}" (@backingInt(number)), [arg1] "{o0}" (arg1), [arg2] "{o1}" (arg2), [arg3] "{o2}" (arg3), @@ -161,7 +161,7 @@ pub fn syscall_pipe( \\ clr %%o0 \\2: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(SYS.pipe)), + : [number] "{g1}" (@backingInt(SYS.pipe)), [arg] "r" (fd), : .{ .memory = true, .g3 = true }); } @@ -184,7 +184,7 @@ pub fn syscall_fork() u64 { \\ and %%o1, %%o0, %%o0 \\2: : [ret] "={o0}" (-> u64), - : [number] "{g1}" (@intFromEnum(SYS.fork)), + : [number] "{g1}" (@backingInt(SYS.fork)), : .{ .memory = true, .xcc = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } @@ -264,7 +264,7 @@ pub const restore = restore_rt; pub fn restore_rt() callconv(.c) void { return asm volatile ("t 0x6d" : - : [number] "{g1}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{g1}" (@backingInt(SYS.rt_sigreturn)), : .{ .memory = true, .xcc = true, .o0 = true, .o1 = true, .o2 = true, .o3 = true, .o4 = true, .o5 = true, .o7 = true }); } diff --git a/lib/std/os/linux/test.zig b/lib/std/os/linux/test.zig index 93d0efcce0fbbba1933d6536ee6e9454c50a2f62..76e60d108878fd94aa1795c316009d022cf51d08 100644 --- a/lib/std/os/linux/test.zig +++ b/lib/std/os/linux/test.zig @@ -186,8 +186,8 @@ test "sysinfo" { } comptime { - assert(128 == @as(u32, @bitCast(linux.FUTEX_OP{ .cmd = @enumFromInt(0), .private = true, .realtime = false }))); - assert(256 == @as(u32, @bitCast(linux.FUTEX_OP{ .cmd = @enumFromInt(0), .private = false, .realtime = true }))); + assert(128 == @as(u32, @bitCast(linux.FUTEX_OP{ .cmd = @fromBackingInt(@intCast(0)), .private = true, .realtime = false }))); + assert(256 == @as(u32, @bitCast(linux.FUTEX_OP{ .cmd = @fromBackingInt(@intCast(0)), .private = false, .realtime = true }))); // Check futex_param4 union is packed correctly const param_union = linux.futex_param4{ @@ -277,7 +277,7 @@ test "futex v1" { comptime { assert(2 == @as(u32, @bitCast(linux.FUTEX2_FLAGS{ .size = .U32, .private = false }))); - assert(128 == @as(u32, @bitCast(linux.FUTEX2_FLAGS{ .size = @enumFromInt(0), .private = true }))); + assert(128 == @as(u32, @bitCast(linux.FUTEX2_FLAGS{ .size = @fromBackingInt(@intCast(0)), .private = true }))); } test "futex2_waitv" { diff --git a/lib/std/os/linux/thumb.zig b/lib/std/os/linux/thumb.zig index ca0be8909748fa0695c1c01003acc9517d30a2a7..a0127f821ebd6658fb3766d5b1261df18e08db1d 100644 --- a/lib/std/os/linux/thumb.zig +++ b/lib/std/os/linux/thumb.zig @@ -12,7 +12,7 @@ pub const syscall_arg_t = arm.syscall_arg_t; pub fn syscall0( number: SYS, ) u32 { - var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined }; + var buf: [2]syscall_arg_t = .{ @backingInt(number), undefined }; return asm volatile ( \\ str r7, [%[tmp], #4] \\ ldr r7, [%[tmp]] @@ -27,7 +27,7 @@ pub fn syscall1( number: SYS, arg1: syscall_arg_t, ) u32 { - var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined }; + var buf: [2]syscall_arg_t = .{ @backingInt(number), undefined }; return asm volatile ( \\ str r7, [%[tmp], #4] \\ ldr r7, [%[tmp]] @@ -44,7 +44,7 @@ pub fn syscall2( arg1: syscall_arg_t, arg2: syscall_arg_t, ) u32 { - var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined }; + var buf: [2]syscall_arg_t = .{ @backingInt(number), undefined }; return asm volatile ( \\ str r7, [%[tmp], #4] \\ ldr r7, [%[tmp]] @@ -63,7 +63,7 @@ pub fn syscall3( arg2: syscall_arg_t, arg3: syscall_arg_t, ) u32 { - var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined }; + var buf: [2]syscall_arg_t = .{ @backingInt(number), undefined }; return asm volatile ( \\ str r7, [%[tmp], #4] \\ ldr r7, [%[tmp]] @@ -84,7 +84,7 @@ pub fn syscall4( arg3: syscall_arg_t, arg4: syscall_arg_t, ) u32 { - var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined }; + var buf: [2]syscall_arg_t = .{ @backingInt(number), undefined }; return asm volatile ( \\ str r7, [%[tmp], #4] \\ ldr r7, [%[tmp]] @@ -107,7 +107,7 @@ pub fn syscall5( arg4: syscall_arg_t, arg5: syscall_arg_t, ) u32 { - var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined }; + var buf: [2]syscall_arg_t = .{ @backingInt(number), undefined }; return asm volatile ( \\ str r7, [%[tmp], #4] \\ ldr r7, [%[tmp]] @@ -132,7 +132,7 @@ pub fn syscall6( arg5: syscall_arg_t, arg6: syscall_arg_t, ) u32 { - var buf: [2]syscall_arg_t = .{ @intFromEnum(number), undefined }; + var buf: [2]syscall_arg_t = .{ @backingInt(number), undefined }; return asm volatile ( \\ str r7, [%[tmp], #4] \\ ldr r7, [%[tmp]] diff --git a/lib/std/os/linux/vdso.zig b/lib/std/os/linux/vdso.zig index 3d418994a6efdf17aada0fce0aa44d6b2fd25c8f..1106ee8bf173dd6eaff0fe372e490249d91dd89f 100644 --- a/lib/std/os/linux/vdso.zig +++ b/lib/std/os/linux/vdso.zig @@ -84,7 +84,7 @@ fn checkver(def_arg: *elf.Verdef, vsym_arg: elf.Versym, vername: []const u8, str var def = def_arg; const vsym_index = vsym_arg.VERSION; while (true) { - if (0 == (def.flags & elf.VER_FLG_BASE) and @intFromEnum(def.ndx) == vsym_index) break; + if (0 == (def.flags & elf.VER_FLG_BASE) and @backingInt(def.ndx) == vsym_index) break; if (def.next == 0) return false; def = @ptrFromInt(@intFromPtr(def) + def.next); } diff --git a/lib/std/os/linux/x32.zig b/lib/std/os/linux/x32.zig index 3b10612786a6d256775c3f3dbe068b1ced5e352b..429aac82973def7599ecc441d35409d085e9b28f 100644 --- a/lib/std/os/linux/x32.zig +++ b/lib/std/os/linux/x32.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("syscall" : [ret] "={rax}" (-> u32), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), : .{ .rcx = true, .r11 = true, .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("syscall" : [ret] "={rax}" (-> u32), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), : .{ .rcx = true, .r11 = true, .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("syscall" : [ret] "={rax}" (-> u32), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), : .{ .rcx = true, .r11 = true, .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("syscall" : [ret] "={rax}" (-> u32), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("syscall" : [ret] "={rax}" (-> u32), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("syscall" : [ret] "={rax}" (-> u32), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("syscall" : [ret] "={rax}" (-> u32), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -116,7 +116,7 @@ pub fn syscall_lseek( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(SYS.lseek)), + : [number] "{rax}" (@backingInt(SYS.lseek)), [fd] "{rdi}" (@as(u32, @bitCast(fd))), [offset] "{rsi}" (@as(u64, @bitCast(offset))), [whence] "{rdx}" (whence), @@ -165,12 +165,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ movl %[number], %%eax \\ syscall : - : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "i" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ syscall : - : [number] "{rax}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{rax}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/x86.zig b/lib/std/os/linux/x86.zig index a5f1dcf2d9c9d25328dc94af2fee80e1ab902b00..8145bf2826c780bcd0e5b85de341b6dc7d6b1281 100644 --- a/lib/std/os/linux/x86.zig +++ b/lib/std/os/linux/x86.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("int $0x80" : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(number)), + : [number] "{eax}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("int $0x80" : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(number)), + : [number] "{eax}" (@backingInt(number)), [arg1] "{ebx}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("int $0x80" : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(number)), + : [number] "{eax}" (@backingInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("int $0x80" : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(number)), + : [number] "{eax}" (@backingInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), [arg3] "{edx}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("int $0x80" : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(number)), + : [number] "{eax}" (@backingInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), [arg3] "{edx}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("int $0x80" : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(number)), + : [number] "{eax}" (@backingInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), [arg3] "{edx}" (arg3), @@ -117,7 +117,7 @@ pub fn syscall6( \\ pop %%ebp \\ pop %%edi : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(number)), + : [number] "{eax}" (@backingInt(number)), [arg1] "{ebx}" (arg1), [arg2] "{ecx}" (arg2), [arg3] "{edx}" (arg3), @@ -129,7 +129,7 @@ pub fn syscall6( pub fn socketcall(call: u32, args: [*]const u32) u32 { return asm volatile ("int $0x80" : [ret] "={eax}" (-> u32), - : [number] "{eax}" (@intFromEnum(SYS.socketcall)), + : [number] "{eax}" (@backingInt(SYS.socketcall)), [arg1] "{ebx}" (call), [arg2] "{ecx}" (@intFromPtr(args)), : .{ .memory = true }); @@ -192,13 +192,13 @@ pub fn restore() callconv(.naked) noreturn { \\ movl %[number], %%eax \\ int $0x80 : - : [number] "i" (@intFromEnum(SYS.sigreturn)), + : [number] "i" (@backingInt(SYS.sigreturn)), ), else => asm volatile ( \\ addl $4, %%esp \\ int $0x80 : - : [number] "{eax}" (@intFromEnum(SYS.sigreturn)), + : [number] "{eax}" (@backingInt(SYS.sigreturn)), ), } } @@ -209,12 +209,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ movl %[number], %%eax \\ int $0x80 : - : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "i" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ int $0x80 : - : [number] "{eax}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{eax}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/x86_64.zig b/lib/std/os/linux/x86_64.zig index adda8b4d03084545a1dba453085737e0149a7dd3..ae5808921c648f93130b26009940acc9376e97f9 100644 --- a/lib/std/os/linux/x86_64.zig +++ b/lib/std/os/linux/x86_64.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), : .{ .rcx = true, .r11 = true, .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), : .{ .rcx = true, .r11 = true, .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), : .{ .rcx = true, .r11 = true, .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u64 { return asm volatile ("syscall" : [ret] "={rax}" (-> u64), - : [number] "{rax}" (@intFromEnum(number)), + : [number] "{rax}" (@backingInt(number)), [arg1] "{rdi}" (arg1), [arg2] "{rsi}" (arg2), [arg3] "{rdx}" (arg3), @@ -151,12 +151,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ movl %[number], %%eax \\ syscall : - : [number] "i" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "i" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ syscall : - : [number] "{rax}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{rax}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/linux/xtensa.zig b/lib/std/os/linux/xtensa.zig index 95b81eb4d1ba7882dacc3b29f082eb3331695a81..839df53cace5d533c35bb986bcc08bcba8b5dd0c 100644 --- a/lib/std/os/linux/xtensa.zig +++ b/lib/std/os/linux/xtensa.zig @@ -9,7 +9,7 @@ pub fn syscall0( ) u32 { return asm volatile ("syscall" : [ret] "={a2}" (-> u32), - : [number] "{a2}" (@intFromEnum(number)), + : [number] "{a2}" (@backingInt(number)), : .{ .memory = true }); } @@ -19,7 +19,7 @@ pub fn syscall1( ) u32 { return asm volatile ("syscall" : [ret] "={a2}" (-> u32), - : [number] "{a2}" (@intFromEnum(number)), + : [number] "{a2}" (@backingInt(number)), [arg1] "{a6}" (arg1), : .{ .memory = true }); } @@ -31,7 +31,7 @@ pub fn syscall2( ) u32 { return asm volatile ("syscall" : [ret] "={a2}" (-> u32), - : [number] "{a2}" (@intFromEnum(number)), + : [number] "{a2}" (@backingInt(number)), [arg1] "{a6}" (arg1), [arg2] "{a3}" (arg2), : .{ .memory = true }); @@ -45,7 +45,7 @@ pub fn syscall3( ) u32 { return asm volatile ("syscall" : [ret] "={a2}" (-> u32), - : [number] "{a2}" (@intFromEnum(number)), + : [number] "{a2}" (@backingInt(number)), [arg1] "{a6}" (arg1), [arg2] "{a3}" (arg2), [arg3] "{a4}" (arg3), @@ -61,7 +61,7 @@ pub fn syscall4( ) u32 { return asm volatile ("syscall" : [ret] "={a2}" (-> u32), - : [number] "{a2}" (@intFromEnum(number)), + : [number] "{a2}" (@backingInt(number)), [arg1] "{a6}" (arg1), [arg2] "{a3}" (arg2), [arg3] "{a4}" (arg3), @@ -79,7 +79,7 @@ pub fn syscall5( ) u32 { return asm volatile ("syscall" : [ret] "={a2}" (-> u32), - : [number] "{a2}" (@intFromEnum(number)), + : [number] "{a2}" (@backingInt(number)), [arg1] "{a6}" (arg1), [arg2] "{a3}" (arg2), [arg3] "{a4}" (arg3), @@ -99,7 +99,7 @@ pub fn syscall6( ) u32 { return asm volatile ("syscall" : [ret] "={a2}" (-> u32), - : [number] "{a2}" (@intFromEnum(number)), + : [number] "{a2}" (@backingInt(number)), [arg1] "{a6}" (arg1), [arg2] "{a3}" (arg2), [arg3] "{a4}" (arg3), @@ -178,12 +178,12 @@ pub fn restore_rt() callconv(.naked) noreturn { \\ movi a2, %[number] \\ syscall : - : [number] "I" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "I" (@backingInt(SYS.rt_sigreturn)), ), else => asm volatile ( \\ syscall : - : [number] "{a2}" (@intFromEnum(SYS.rt_sigreturn)), + : [number] "{a2}" (@backingInt(SYS.rt_sigreturn)), ), } } diff --git a/lib/std/os/plan9.zig b/lib/std/os/plan9.zig index 48e82c3e11405f5482b2b7b85a715ee7329faf08..35afc3298767b0cd3e887f1b1a725166078d9987 100644 --- a/lib/std/os/plan9.zig +++ b/lib/std/os/plan9.zig @@ -100,7 +100,7 @@ pub const E = enum(u16) { pub fn errno(r: usize) E { const signed_r: isize = @bitCast(r); const int = if (signed_r > -4096 and signed_r < 0) -signed_r else 0; - return @enumFromInt(int); + return @fromBackingInt(@intCast(int)); } // The max bytes that can be in the errstr buff diff --git a/lib/std/os/plan9/x86_64.zig b/lib/std/os/plan9/x86_64.zig index b921c079eff6e9ac1cc3b0b6430c162c0c9a70ea..a9c0654888c6f21a4d7193f732a86c45aace7f3c 100644 --- a/lib/std/os/plan9/x86_64.zig +++ b/lib/std/os/plan9/x86_64.zig @@ -10,7 +10,7 @@ pub fn syscall1(sys: plan9.SYS, arg0: usize) usize { \\pop %%r11 : [ret] "={rax}" (-> usize), : [arg0] "{r8}" (arg0), - [syscall_number] "{rbp}" (@intFromEnum(sys)), + [syscall_number] "{rbp}" (@backingInt(sys)), : .{ .rcx = true, .rax = true, .rbp = true, .r11 = true, .memory = true }); } pub fn syscall2(sys: plan9.SYS, arg0: usize, arg1: usize) usize { @@ -25,7 +25,7 @@ pub fn syscall2(sys: plan9.SYS, arg0: usize, arg1: usize) usize { : [ret] "={rax}" (-> usize), : [arg0] "{r8}" (arg0), [arg1] "{r9}" (arg1), - [syscall_number] "{rbp}" (@intFromEnum(sys)), + [syscall_number] "{rbp}" (@backingInt(sys)), : .{ .rcx = true, .rax = true, .rbp = true, .r11 = true, .memory = true }); } pub fn syscall3(sys: plan9.SYS, arg0: usize, arg1: usize, arg2: usize) usize { @@ -43,7 +43,7 @@ pub fn syscall3(sys: plan9.SYS, arg0: usize, arg1: usize, arg2: usize) usize { : [arg0] "{r8}" (arg0), [arg1] "{r9}" (arg1), [arg2] "{r10}" (arg2), - [syscall_number] "{rbp}" (@intFromEnum(sys)), + [syscall_number] "{rbp}" (@backingInt(sys)), : .{ .rcx = true, .rax = true, .rbp = true, .r11 = true, .memory = true }); } pub fn syscall4(sys: plan9.SYS, arg0: usize, arg1: usize, arg2: usize, arg3: usize) usize { @@ -64,6 +64,6 @@ pub fn syscall4(sys: plan9.SYS, arg0: usize, arg1: usize, arg2: usize, arg3: usi [arg1] "{r9}" (arg1), [arg2] "{r10}" (arg2), [arg3] "{r11}" (arg3), - [syscall_number] "{rbp}" (@intFromEnum(sys)), + [syscall_number] "{rbp}" (@backingInt(sys)), : .{ .rcx = true, .rax = true, .rbp = true, .r11 = true, .memory = true }); } diff --git a/lib/std/os/uefi.zig b/lib/std/os/uefi.zig index e48ec85fe32bc7af9c7dce101ebf5d2d6a9fbd28..18105e609e45c39957e6c51d312862acf7167421 100644 --- a/lib/std/os/uefi.zig +++ b/lib/std/os/uefi.zig @@ -181,7 +181,7 @@ pub const Time = extern struct { var days: u9 = 0; var month: u4 = 0; while (month < max_month) : (month += 1) { - days += std.time.epoch.getDaysInMonth(year, @enumFromInt(month + 1)); + days += std.time.epoch.getDaysInMonth(year, @fromBackingInt(@intCast(month + 1))); } return days; } diff --git a/lib/std/os/uefi/pool_allocator.zig b/lib/std/os/uefi/pool_allocator.zig index 5acdcf6af4fe44f95e680166874f43e8502f3208..f124e3c5d0c9a6b0b9b65715f37b69cd8822959f 100644 --- a/lib/std/os/uefi/pool_allocator.zig +++ b/lib/std/os/uefi/pool_allocator.zig @@ -117,7 +117,7 @@ fn uefi_alloc( ) ?[*]u8 { _ = ret_addr; - std.debug.assert(@intFromEnum(alignment) <= 3); + std.debug.assert(@backingInt(alignment) <= 3); const slice = uefi.system_table.boot_services.?.allocatePool( uefi.efi_pool_memory_type, @@ -136,7 +136,7 @@ fn uefi_resize( ) bool { _ = ret_addr; - std.debug.assert(@intFromEnum(alignment) <= 3); + std.debug.assert(@backingInt(alignment) <= 3); if (new_len > buf.len) return false; return true; @@ -151,7 +151,7 @@ fn uefi_remap( ) ?[*]u8 { _ = ret_addr; - std.debug.assert(@intFromEnum(alignment) <= 3); + std.debug.assert(@backingInt(alignment) <= 3); if (new_len > buf.len) return null; return buf.ptr; diff --git a/lib/std/os/uefi/protocol/device_path.zig b/lib/std/os/uefi/protocol/device_path.zig index b47212ad69c23df1f4d3800eb3cbcbb6ab9bd616..3b7f29601831ccf094e0f6e200ad60f2da255f96 100644 --- a/lib/std/os/uefi/protocol/device_path.zig +++ b/lib/std/os/uefi/protocol/device_path.zig @@ -26,7 +26,7 @@ pub const DevicePath = extern struct { /// Returns the next DevicePath node in the sequence, if any. pub fn next(self: *const DevicePath) ?*const DevicePath { - const subtype: uefi.DevicePath.End.Subtype = @enumFromInt(self.subtype); + const subtype: uefi.DevicePath.End.Subtype = @fromBackingInt(@intCast(self.subtype)); if (self.type == .end and subtype == .end_entire) return null; const bytes: [*]const u8 = @ptrCast(self); return @ptrCast(bytes + self.length); @@ -106,7 +106,7 @@ pub const DevicePath = extern struct { inline for (type_info.field_names, type_info.field_types) |subtype_name, subtype_type| { // The tag names match the union names, so just grab that off the enum - const tag_val: u8 = @intFromEnum(@field(TTag, subtype_name)); + const tag_val: u8 = @backingInt(@field(TTag, subtype_name)); if (self.subtype == tag_val) { // e.g. expr = .{ .pci = @ptrCast(...) } diff --git a/lib/std/os/uefi/tables.zig b/lib/std/os/uefi/tables.zig index 1b86446c9d6305dea8f23b61f2a5e2811d9f5190..3a26ededb20c37b712adc43a1fe489f1da109b0b 100644 --- a/lib/std/os/uefi/tables.zig +++ b/lib/std/os/uefi/tables.zig @@ -24,11 +24,11 @@ pub const TimerDelay = enum(u32) { pub const MemoryType = enum(u32) { pub const Oem = math.IntFittingRange( 0, - @intFromEnum(MemoryType.oem_end) - @intFromEnum(MemoryType.oem_start), + @backingInt(MemoryType.oem_end) - @backingInt(MemoryType.oem_start), ); pub const Vendor = math.IntFittingRange( 0, - @intFromEnum(MemoryType.vendor_end) - @intFromEnum(MemoryType.vendor_start), + @backingInt(MemoryType.vendor_end) - @backingInt(MemoryType.vendor_start), ); /// can only be allocated using .allocate_any_pages mode unless you are explicitly targeting an interface that states otherwise @@ -65,28 +65,28 @@ pub const MemoryType = enum(u32) { _, pub fn fromOem(value: Oem) MemoryType { - const oem_start = @intFromEnum(MemoryType.oem_start); - return @enumFromInt(oem_start + value); + const oem_start = @backingInt(MemoryType.oem_start); + return @fromBackingInt(@intCast(oem_start + value)); } pub fn toOem(memtype: MemoryType) ?Oem { - const as_int = @intFromEnum(memtype); - const oem_start = @intFromEnum(MemoryType.oem_start); + const as_int = @backingInt(memtype); + const oem_start = @backingInt(MemoryType.oem_start); if (as_int < oem_start) return null; - if (as_int > @intFromEnum(MemoryType.oem_end)) return null; + if (as_int > @backingInt(MemoryType.oem_end)) return null; return @truncate(as_int - oem_start); } pub fn fromVendor(value: Vendor) MemoryType { - const vendor_start = @intFromEnum(MemoryType.vendor_start); - return @enumFromInt(vendor_start + value); + const vendor_start = @backingInt(MemoryType.vendor_start); + return @fromBackingInt(@intCast(vendor_start + value)); } pub fn toVendor(memtype: MemoryType) ?Vendor { - const as_int = @intFromEnum(memtype); - const vendor_start = @intFromEnum(MemoryType.vendor_start); - if (as_int < @intFromEnum(MemoryType.vendor_end)) return null; - if (as_int > @intFromEnum(MemoryType.vendor_end)) return null; + const as_int = @backingInt(memtype); + const vendor_start = @backingInt(MemoryType.vendor_start); + if (as_int < @backingInt(MemoryType.vendor_end)) return null; + if (as_int > @backingInt(MemoryType.vendor_end)) return null; return @truncate(as_int - vendor_start); } @@ -98,7 +98,7 @@ pub const MemoryType = enum(u32) { else if (std.enums.tagName(MemoryType, self)) |name| try w.print("{s}", .{name}) else - try w.print("INVALID({X})", .{@intFromEnum(self)}); + try w.print("INVALID({X})", .{@backingInt(self)}); } }; diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig index ea96e38cee094f2dbaa6257b06f4ab547a8e3ce0..f2c3706c2738184e5fcddf0be6cb4521adb50d8a 100644 --- a/lib/std/os/windows.zig +++ b/lib/std/os/windows.zig @@ -77,7 +77,7 @@ pub const PS = struct { _, pub fn construct(num: NUM, thread: bool, input: bool, additive: bool) ULONG_PTR { - var val: ULONG_PTR = @intFromEnum(num); + var val: ULONG_PTR = @backingInt(num); if (thread) val |= 0x10000; if (input) val |= 0x20000; if (additive) val |= 0x40000; @@ -739,7 +739,7 @@ pub const FILE = struct { SYNCHRONOUS_NONALERT = 0b10, _, - pub const VALID_FLAGS: @This() = @enumFromInt(0b11); + pub const VALID_FLAGS: @This() = @fromBackingInt(@intCast(0b11)); }, /// The file being opened must not be a directory file or this call /// fails. The file object being opened can represent a data file, a @@ -1975,7 +1975,7 @@ pub const HEAP = opaque { CSR_PORT, _, - pub const MASK: CLASS = @enumFromInt(maxInt(@typeInfo(CLASS).@"enum".tag_type)); + pub const MASK: CLASS = @fromBackingInt(@intCast(maxInt(@typeInfo(CLASS).@"enum".tag_type))); }; pub const CREATE = packed struct(ULONG) { @@ -1990,7 +1990,7 @@ pub const HEAP = opaque { /// Callers are therefore responsible for synchronizing access to hardened heaps. HARDENED: bool = false, Reserved10: u2 = 0, - CLASS: CLASS = @enumFromInt(0), + CLASS: CLASS = @fromBackingInt(@intCast(0)), /// Create heap with 16 byte alignment (obsolete) ALIGN_16: bool = false, /// Create heap call tracing enabled (obsolete) @@ -2035,7 +2035,7 @@ pub const HEAP = opaque { FLAG3: bool = false, } = .{}, } = .{}, - CLASS: CLASS = @enumFromInt(0), + CLASS: CLASS = @fromBackingInt(@intCast(0)), Reserved16: u2 = 0, TAG: u12 = 0, Reserved30: u2 = 0, @@ -3945,7 +3945,7 @@ pub fn unexpectedError(err: Win32Error) UnexpectedError { pub fn unexpectedStatus(status: NTSTATUS) UnexpectedError { if (std.options.unexpected_error_tracing) { std.debug.print("error.Unexpected NTSTATUS=0x{x} ({s})\n", .{ - @intFromEnum(status), + @backingInt(status), std.enums.tagName(NTSTATUS, status) orelse "", }); std.debug.dumpCurrentStackTrace(.{ .first_address = @returnAddress() }); @@ -3956,7 +3956,7 @@ pub fn unexpectedStatus(status: NTSTATUS) UnexpectedError { pub fn statusBug(status: NTSTATUS) UnexpectedError { switch (builtin.mode) { .Debug => std.debug.panic("programmer bug caused syscall status: 0x{x} ({s})", .{ - @intFromEnum(status), + @backingInt(status), std.enums.tagName(NTSTATUS, status) orelse "", }), else => return error.Unexpected, @@ -3966,7 +3966,7 @@ pub fn statusBug(status: NTSTATUS) UnexpectedError { pub fn errorBug(err: Win32Error) UnexpectedError { switch (builtin.mode) { .Debug => std.debug.panic("programmer bug caused syscall error: 0x{x} ({s})", .{ - @intFromEnum(err), + @backingInt(err), std.enums.tagName(Win32Error, err) orelse "", }), else => return error.Unexpected, @@ -4091,7 +4091,7 @@ fn Bool(comptime BackingInteger: type) type { _, /// This is not the only truthy value, comparisons against this value are always a bug. - pub const TRUE: @This() = @enumFromInt(1); + pub const TRUE: @This() = @fromBackingInt(@intCast(1)); pub const Backing = BackingInteger; @@ -4100,7 +4100,7 @@ fn Bool(comptime BackingInteger: type) type { } pub fn fromBool(b: bool) @This() { - return @enumFromInt(@intFromBool(b)); + return @fromBackingInt(@intCast(@intFromBool(b))); } }; } @@ -5947,8 +5947,8 @@ pub const KUSER_SHARED_DATA = extern struct { pub const SharedUserData: *const KUSER_SHARED_DATA = @ptrFromInt(0x7FFE0000); pub fn IsProcessorFeaturePresent(feature: PF) bool { - if (@intFromEnum(feature) >= PROCESSOR_FEATURE_MAX) return false; - return SharedUserData.ProcessorFeatures[@intFromEnum(feature)].toBool(); + if (@backingInt(feature) >= PROCESSOR_FEATURE_MAX) return false; + return SharedUserData.ProcessorFeatures[@backingInt(feature)].toBool(); } // https://github.com/reactos/reactos/blob/master/sdk/include/ndk/pstypes.h#L977-L983 diff --git a/lib/std/os/windows/crypt32.zig b/lib/std/os/windows/crypt32.zig index 4c7814287d75ddb40f4b4bf38b1761a84ca29f90..ea818284c6ce8effe66ba82770f9bacf98c33f1b 100644 --- a/lib/std/os/windows/crypt32.zig +++ b/lib/std/os/windows/crypt32.zig @@ -73,7 +73,7 @@ pub const CERT_STORE = struct { _, pub fn fromString(str: LPCSTR) PROV { - return @enumFromInt(@intFromPtr(str)); + return @fromBackingInt(@intCast(@intFromPtr(str))); } }; @@ -159,7 +159,7 @@ pub const HCERTCHAINENGINE = enum(usize) { _, pub fn fromHandle(handle: HANDLE) HCERTCHAINENGINE { - return @enumFromInt(@intFromPtr(handle)); + return @fromBackingInt(@intCast(@intFromPtr(handle))); } }; @@ -210,7 +210,7 @@ pub const CERT_CHAIN = packed struct(DWORD) { _, pub fn fromString(str: LPCSTR) POLICY { - return @enumFromInt(@intFromPtr(str)); + return @fromBackingInt(@intCast(@intFromPtr(str))); } pub const PARA = extern struct { diff --git a/lib/std/posix.zig b/lib/std/posix.zig index 1f4288ea99651e3ccf8a22e03c1abf33c140dbeb..803fa9a9054f974ee2371011c938a96b8b72e02d 100644 --- a/lib/std/posix.zig +++ b/lib/std/posix.zig @@ -651,7 +651,7 @@ pub fn mmap( const rc = mmap_sym(ptr, length, prot, @bitCast(flags), fd, @bitCast(offset)); const err: E = if (builtin.link_libc) blk: { if (rc != std.c.MAP_FAILED) return @as([*]align(page_size_min) u8, @ptrCast(@alignCast(rc)))[0..length]; - break :blk @enumFromInt(system._errno().*); + break :blk @fromBackingInt(@intCast(system._errno().*)); } else blk: { const err = errno(rc); if (err == .SUCCESS) return @as([*]align(page_size_min) u8, @ptrFromInt(rc))[0..length]; @@ -687,7 +687,7 @@ pub fn munmap(memory: []align(page_size_min) const u8) void { .INVAL => unreachable, // Invalid parameters. .NOMEM => unreachable, // Attempted to unmap a region in the middle of an existing mapping. else => |e| if (std.options.unexpected_error_tracing) { - std.debug.panic("unexpected errno: {d} ({t})", .{ @intFromEnum(e), e }); + std.debug.panic("unexpected errno: {d} ({t})", .{ @backingInt(e), e }); } else unreachable, } } @@ -710,7 +710,7 @@ pub fn mremap( const rc = system.mremap(old_address, old_len, new_len, flags, new_address); const err: E = if (builtin.link_libc) blk: { if (rc != std.c.MAP_FAILED) return @as([*]align(page_size_min) u8, @ptrCast(@alignCast(rc)))[0..new_len]; - break :blk @enumFromInt(system._errno().*); + break :blk @fromBackingInt(@intCast(system._errno().*)); } else blk: { const err = errno(rc); if (err == .SUCCESS) return @as([*]align(page_size_min) u8, @ptrFromInt(rc))[0..new_len]; @@ -1299,7 +1299,7 @@ pub fn prctl(option: PR, args: anytype) PrctlError!u31 { inline while (i < args.len) : (i += 1) buf[i] = args[i]; } - const rc = system.prctl(@intFromEnum(option), buf[0], buf[1], buf[2], buf[3]); + const rc = system.prctl(@backingInt(option), buf[0], buf[1], buf[2], buf[3]); switch (errno(rc)) { .SUCCESS => return @intCast(rc), .ACCES => return error.AccessDenied, @@ -1545,7 +1545,7 @@ pub fn ptrace(request: u32, pid: pid_t, addr: usize, data: usize) PtraceError!vo }, .driverkit, .ios, .maccatalyst, .macos, .tvos, .visionos, .watchos => switch (errno(std.c.ptrace( - @enumFromInt(request), + @fromBackingInt(@intCast(request)), pid, @ptrFromInt(addr), @intCast(data), @@ -1668,7 +1668,7 @@ pub const UnexpectedError = std.Io.UnexpectedError; /// and you get an unexpected error. pub fn unexpectedErrno(err: E) UnexpectedError { if (std.options.unexpected_error_tracing) { - std.debug.print("unexpected errno: {d}\n", .{@intFromEnum(err)}); + std.debug.print("unexpected errno: {d}\n", .{@backingInt(err)}); std.debug.dumpCurrentStackTrace(.{}); } return error.Unexpected; diff --git a/lib/std/posix/test.zig b/lib/std/posix/test.zig index 3423ac4e4d010985b44a747bd97c540e02630275..8accb90cb7f9c79b3246fb974c838c9c28e7245d 100644 --- a/lib/std/posix/test.zig +++ b/lib/std/posix/test.zig @@ -333,7 +333,7 @@ test "getrlimit and setrlimit" { if (posix.system.rlimit_resource == void) return error.SkipZigTest; inline for (@typeInfo(posix.rlimit_resource).@"enum".field_values) |field_value| { - const resource: posix.rlimit_resource = @enumFromInt(field_value); + const resource: posix.rlimit_resource = @fromBackingInt(@intCast(field_value)); const limit = try posix.getrlimit(resource); // XNU kernel does not support RLIMIT_STACK if a custom stack is active, diff --git a/lib/std/process.zig b/lib/std/process.zig index f3ef291763d642426770883e886c8a5a50aeae41..e134ef16d9adb9abed54448861c72b12bb12a4c0 100644 --- a/lib/std/process.zig +++ b/lib/std/process.zig @@ -875,10 +875,10 @@ pub fn exit(status: u8) noreturn { // exit() is only available if exitBootServices() has not been called yet. // This call to exit should not fail, so we catch-ignore errors. if (uefi.system_table.boot_services) |bs| { - bs.exit(uefi.handle, @enumFromInt(status), null) catch {}; + bs.exit(uefi.handle, @fromBackingInt(@intCast(status)), null) catch {}; } // If we can't exit, reboot the system instead. - uefi.system_table.runtime_services.resetSystem(.cold, @enumFromInt(status), null); + uefi.system_table.runtime_services.resetSystem(.cold, @fromBackingInt(@intCast(status)), null); }, else => posix.system.exit(status), } diff --git a/lib/std/simd.zig b/lib/std/simd.zig index d2ff4032a932b103ea0946aa6c2295ee248e1b05..08674a3573d4affbf4a635cf85c056b40ebb38ed 100644 --- a/lib/std/simd.zig +++ b/lib/std/simd.zig @@ -90,7 +90,7 @@ pub fn suggestVectorLength(comptime T: type) ?comptime_int { test "suggestVectorLengthForCpu works with signed and unsigned values" { comptime var cpu = std.Target.Cpu.baseline(std.Target.Cpu.Arch.x86_64, builtin.os); - comptime cpu.features.addFeature(@intFromEnum(std.Target.x86.Feature.avx512f)); + comptime cpu.features.addFeature(@backingInt(std.Target.x86.Feature.avx512f)); comptime cpu.features.populateDependencies(&std.Target.x86.all_features); const expected_len: usize = switch (builtin.zig_backend) { .stage2_x86_64 => 8, diff --git a/lib/std/spirv.zig b/lib/std/spirv.zig index 513f73c53bf7b203ab553f4318dbd68f37e68cf0..b88c07df9b33b40ab707374336e3d18d390b8e66 100644 --- a/lib/std/spirv.zig +++ b/lib/std/spirv.zig @@ -60,8 +60,8 @@ pub fn controlBarrier( asm volatile ( \\OpControlBarrier %exec %mem %sem : - : [exec] "" (@as(u32, @intFromEnum(execution))), - [mem] "" (@as(u32, @intFromEnum(memory))), + : [exec] "" (@as(u32, @backingInt(execution))), + [mem] "" (@as(u32, @backingInt(memory))), [sem] "" (@as(u32, @bitCast(semantics))), ); } @@ -70,7 +70,7 @@ pub fn memoryBarrier(comptime memory: Scope, comptime semantics: MemorySemantics asm volatile ( \\OpMemoryBarrier %mem %sem : - : [mem] "" (@as(u32, @intFromEnum(memory))), + : [mem] "" (@as(u32, @backingInt(memory))), [sem] "" (@as(u32, @bitCast(semantics))), ); } diff --git a/lib/std/start.zig b/lib/std/start.zig index bb1ed6c3962d384fc5271b15973adf3702b3eb2a..c95e36e7778e5e6f041d7b51411d1a1e3b353601 100644 --- a/lib/std/start.zig +++ b/lib/std/start.zig @@ -141,14 +141,14 @@ fn EfiMain(handle: uefi.Handle, system_table: *uefi.tables.SystemTable) callconv return 0; }, uefi.Status => { - return @intFromEnum(root.main()); + return @backingInt(root.main()); }, uefi.Error!void => { root.main() catch |err| switch (err) { error.Unexpected => @panic("EfiMain: unexpected error"), else => { const status = uefi.Status.fromError(@errorCast(err)); - return @intFromEnum(status); + return @backingInt(status); }, }; diff --git a/lib/std/static_string_map.zig b/lib/std/static_string_map.zig index 950468fd5162d427c73811c5561e0e020d72b9e6..bc1365a32f2c825e025cb52640811836735f6668 100644 --- a/lib/std/static_string_map.zig +++ b/lib/std/static_string_map.zig @@ -117,7 +117,7 @@ pub fn StaticStringMapWithEql( var sorted_keys: [field_names.len][]const u8 = field_names[0..field_names.len].*; var sorted_vals: [field_names.len]V = undefined; - for (&sorted_vals, @typeInfo(V).@"enum".field_values) |*x, i| x.* = @enumFromInt(i); + for (&sorted_vals, @typeInfo(V).@"enum".field_values) |*x, i| x.* = @fromBackingInt(@intCast(i)); for (field_names) |field_name| { self.min_len = @min(self.min_len, field_name.len); diff --git a/lib/std/tar.zig b/lib/std/tar.zig index 4799a8318b21c4226ec523a1a98d688632d64620..1d4512570b60519963803254c989d9f4154ce404 100644 --- a/lib/std/tar.zig +++ b/lib/std/tar.zig @@ -241,7 +241,7 @@ const Header = struct { } pub fn kind(header: Header) Kind { - const result: Kind = @enumFromInt(header.bytes[156]); + const result: Kind = @fromBackingInt(@intCast(header.bytes[156])); if (result == .normal_alias) return .normal; return result; } diff --git a/lib/std/testing/Smith.zig b/lib/std/testing/Smith.zig index 4aaeee2a48711295fbc5a5fd1a49aa1414c49a34..7e3235fe0e5ffd1163a2cc7bf46f7583eb0a06ae 100644 --- a/lib/std/testing/Smith.zig +++ b/lib/std/testing/Smith.zig @@ -169,7 +169,7 @@ test baselineWeights { fn valueFromInt(T: anytype, int: Backing(T)) T { @disableInstrumentation(); return switch (@typeInfo(T)) { - .@"enum" => @enumFromInt(int), + .@"enum" => @fromBackingInt(@intCast(int)), else => @bitCast(int), }; } @@ -369,7 +369,7 @@ fn UnionTagWithoutUninitializable(T: type) type { else => {}, } field_names[n_fields] = f_name; - field_values[n_fields] = @intFromEnum(@field(Tag, f_name)); + field_values[n_fields] = @backingInt(@field(Tag, f_name)); n_fields += 1; } return @Enum(e.tag_type, .exhaustive, field_names[0..n_fields], field_values[0..n_fields]); @@ -400,8 +400,8 @@ pub fn valueWithHash(s: *Smith, T: type, hash: u32) T { break :v s.valueWeightedWithHash(T, baselineWeights(T), hash); } break :v std.enums.fromInt(T, s.valueWithHash(e.tag_type, hash)) orelse - @enumFromInt(e.field_values[0]); - } else @enumFromInt(s.valueWithHash(e.tag_type, hash)), + @fromBackingInt(@intCast(e.field_values[0])); + } else @fromBackingInt(@intCast(s.valueWithHash(e.tag_type, hash))), .optional => |o| if (s.valueWithHash(bool, hash)) null else @@ -718,7 +718,7 @@ test value { io: u128 = (1 << 80) | (1 << 23), fd: f64 = std.math.pi, ft: f80 = std.math.e, - eh: enum(u16) { a, _ } = @enumFromInt(999), + eh: enum(u16) { a, _ } = @fromBackingInt(@intCast(999)), eo: enum(u128) { a, b, _ } = .b, aw: [3]u32 = .{ 1 << 30, 1 << 20, 1 << 10 }, vw: @Vector(3, u32) = .{ 1 << 10, 1 << 20, 1 << 30 }, @@ -747,7 +747,7 @@ test value { }; const s: S = .{}; const ft_bits: u80 = @bitCast(s.ft); - const eo_bits = @intFromEnum(s.eo); + const eo_bits = @backingInt(s.eo); var smith: Smith = .{ .in = constructInput(&.{ @@ -758,7 +758,7 @@ test value { .{ .int = @truncate(s.io) }, .{ .int = @intCast(s.io >> 64) }, // io .{ .int = @bitCast(s.fd) }, // fd .{ .int = @truncate(ft_bits) }, .{ .int = @intCast(ft_bits >> 64) }, // ft - .{ .int = @intFromEnum(s.eh) }, // eh + .{ .int = @backingInt(s.eh) }, // eh .{ .int = @truncate(eo_bits) }, .{ .int = @intCast(eo_bits >> 64) }, // eo .{ .int = s.aw[0] }, .{ .int = s.aw[1] }, .{ .int = s.aw[2] }, // aw .{ .int = s.vw[0] }, .{ .int = s.vw[1] }, .{ .int = s.vw[2] }, // vw @@ -767,8 +767,8 @@ test value { .{ .int = s.s.q }, // s.q //sz .{ .int = @as(u8, @bitCast(s.sp)) }, // sp - .{ .int = s.si.a }, .{ .int = @intFromEnum(s.si.b) }, // si - .{ .int = @intFromEnum(s.u) }, .{ .int = s.u.b }, // u + .{ .int = s.si.a }, .{ .int = @backingInt(s.si.b) }, // si + .{ .int = @backingInt(s.u) }, .{ .int = s.u.b }, // u .{ .int = @as(u16, @bitCast(s.up)) }, // up // invalid values .{ .int = 555 }, // invalid.ib diff --git a/lib/std/time/epoch.zig b/lib/std/time/epoch.zig index 4139e82429e5ede0e9afb3f2fb6c488e475cda5c..6c178940e8a8b55e592c3989d16a5ff2657b827e 100644 --- a/lib/std/time/epoch.zig +++ b/lib/std/time/epoch.zig @@ -81,7 +81,7 @@ pub const Month = enum(u4) { /// return the numeric calendar value for the given month /// i.e. jan=1, feb=2, etc pub fn numeric(self: Month) u4 { - return @intFromEnum(self); + return @backingInt(self); } }; @@ -119,7 +119,7 @@ pub const YearAndDay = struct { if (days_left < days_in_month) break; days_left -= days_in_month; - month = @as(Month, @enumFromInt(@intFromEnum(month) + 1)); + month = @as(Month, @fromBackingInt(@intCast(@backingInt(month) + 1))); } return .{ .month = month, .day_index = @as(u5, @intCast(days_left)) }; } diff --git a/lib/std/valgrind.zig b/lib/std/valgrind.zig index f12e0a9a7f0b69947d77c572ab3c736b77d028ad..78192b59b2239997a9e320e3360bf8641e578978 100644 --- a/lib/std/valgrind.zig +++ b/lib/std/valgrind.zig @@ -144,7 +144,7 @@ pub fn IsTool(base: [2]u8, code: usize) bool { } fn doClientRequestExpr(default: usize, request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize { - return doClientRequest(default, @as(usize, @intCast(@intFromEnum(request))), a1, a2, a3, a4, a5); + return doClientRequest(default, @as(usize, @intCast(@backingInt(request))), a1, a2, a3, a4, a5); } fn doClientRequestStmt(request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void { diff --git a/lib/std/valgrind/cachegrind.zig b/lib/std/valgrind/cachegrind.zig index b6aef5391b664b2a06a5ed6503a70cf6418f6b41..a92ad1d9b4c7d82bfdb7b5dd575031eb6213c5d3 100644 --- a/lib/std/valgrind/cachegrind.zig +++ b/lib/std/valgrind/cachegrind.zig @@ -7,7 +7,7 @@ pub const ClientRequest = enum(usize) { }; fn doClientRequestExpr(default: usize, request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize { - return valgrind.doClientRequest(default, @as(usize, @intCast(@intFromEnum(request))), a1, a2, a3, a4, a5); + return valgrind.doClientRequest(default, @as(usize, @intCast(@backingInt(request))), a1, a2, a3, a4, a5); } fn doClientRequestStmt(request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void { diff --git a/lib/std/valgrind/callgrind.zig b/lib/std/valgrind/callgrind.zig index 6ae8cc5f20f1ef37cf511699108cec5a35f2d505..8b9f24046d16322708da91da68bfe0976122df6b 100644 --- a/lib/std/valgrind/callgrind.zig +++ b/lib/std/valgrind/callgrind.zig @@ -11,7 +11,7 @@ pub const ClientRequest = enum(usize) { }; fn doClientRequestExpr(default: usize, request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize { - return valgrind.doClientRequest(default, @as(usize, @intCast(@intFromEnum(request))), a1, a2, a3, a4, a5); + return valgrind.doClientRequest(default, @as(usize, @intCast(@backingInt(request))), a1, a2, a3, a4, a5); } fn doClientRequestStmt(request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void { diff --git a/lib/std/valgrind/memcheck.zig b/lib/std/valgrind/memcheck.zig index aeeae896f09f54529df3f02f42645243559c1e6e..0cbdc0e7df106985bde8e770d0586c148b0bfc8a 100644 --- a/lib/std/valgrind/memcheck.zig +++ b/lib/std/valgrind/memcheck.zig @@ -21,7 +21,7 @@ pub const ClientRequest = enum(usize) { }; fn doClientRequestExpr(default: usize, request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) usize { - return valgrind.doClientRequest(default, @as(usize, @intCast(@intFromEnum(request))), a1, a2, a3, a4, a5); + return valgrind.doClientRequest(default, @as(usize, @intCast(@backingInt(request))), a1, a2, a3, a4, a5); } fn doClientRequestStmt(request: ClientRequest, a1: usize, a2: usize, a3: usize, a4: usize, a5: usize) void { diff --git a/lib/std/wasm.zig b/lib/std/wasm.zig index 403cc2f3b99452fc796ba043c69081a27f2c2ade..e8cd89952e2816633ef494e48ed054f7e0ff48c0 100644 --- a/lib/std/wasm.zig +++ b/lib/std/wasm.zig @@ -664,7 +664,7 @@ pub const BlockType = enum(u8) { v128 = 0x7B, pub fn fromValtype(valtype: Valtype) BlockType { - return @enumFromInt(@intFromEnum(valtype)); + return @fromBackingInt(@intCast(@backingInt(valtype))); } }; diff --git a/lib/std/zig.zig b/lib/std/zig.zig index 424effacc3e7f1b38a977ce9e685dc3ced6dd83f..fafb3cac422ac17b36dee498ddecf014366fbc91 100644 --- a/lib/std/zig.zig +++ b/lib/std/zig.zig @@ -1764,12 +1764,12 @@ pub fn buildExeSubprocess( received_fs_inputs = true; var it = mem.splitScalar(u8, body, 0); while (it.next()) |prefixed_path| { - const prefix: Server.Message.PathPrefix = @enumFromInt(prefixed_path[0] - 1); + const prefix: Server.Message.PathPrefix = @fromBackingInt(@intCast(prefixed_path[0] - 1)); const sub_path = try gpa.dupe(u8, prefixed_path[1..]); var keep = false; defer if (!keep) gpa.free(sub_path); keep = man.addPrefixedPathPost(.{ - .prefix = @intFromEnum(prefix), + .prefix = @backingInt(prefix), .sub_path = sub_path, }) catch |err| switch (err) { error.Canceled, error.OutOfMemory => |e| return e, diff --git a/lib/std/zig/Ast.zig b/lib/std/zig/Ast.zig index 64141b806af7da5f490f45aa92356c84aefeed62..a0a2dda60d90503e92394892a82677b0d44a045a 100644 --- a/lib/std/zig/Ast.zig +++ b/lib/std/zig/Ast.zig @@ -41,15 +41,15 @@ pub const OptionalTokenIndex = enum(u32) { _, pub fn unwrap(oti: OptionalTokenIndex) ?TokenIndex { - return if (oti == .none) null else @intFromEnum(oti); + return if (oti == .none) null else @backingInt(oti); } pub fn fromToken(ti: TokenIndex) OptionalTokenIndex { - return @enumFromInt(ti); + return @fromBackingInt(@intCast(ti)); } pub fn fromOptional(oti: ?TokenIndex) OptionalTokenIndex { - return if (oti) |ti| @enumFromInt(ti) else .none; + return if (oti) |ti| @fromBackingInt(@intCast(ti)) else .none; } }; @@ -61,17 +61,17 @@ pub const TokenOffset = enum(i32) { pub fn init(base: TokenIndex, destination: TokenIndex) TokenOffset { const base_i64: i64 = base; const destination_i64: i64 = destination; - return @enumFromInt(destination_i64 - base_i64); + return @fromBackingInt(@intCast(destination_i64 - base_i64)); } pub fn toOptional(to: TokenOffset) OptionalTokenOffset { - const result: OptionalTokenOffset = @enumFromInt(@intFromEnum(to)); + const result: OptionalTokenOffset = @fromBackingInt(@intCast(@backingInt(to))); assert(result != .none); return result; } pub fn toAbsolute(offset: TokenOffset, base: TokenIndex) TokenIndex { - return @intCast(@as(i64, base) + @intFromEnum(offset)); + return @intCast(@as(i64, base) + @backingInt(offset)); } }; @@ -81,7 +81,7 @@ pub const OptionalTokenOffset = enum(i32) { _, pub fn unwrap(oto: OptionalTokenOffset) ?TokenOffset { - return if (oto == .none) null else @enumFromInt(@intFromEnum(oto)); + return if (oto == .none) null else @fromBackingInt(@intCast(@backingInt(oto))); } }; @@ -94,15 +94,15 @@ pub fn tokenStart(tree: *const Ast, token_index: TokenIndex) ByteOffset { } pub fn nodeTag(tree: *const Ast, node: Node.Index) Node.Tag { - return tree.nodes.items(.tag)[@intFromEnum(node)]; + return tree.nodes.items(.tag)[@backingInt(node)]; } pub fn nodeMainToken(tree: *const Ast, node: Node.Index) TokenIndex { - return tree.nodes.items(.main_token)[@intFromEnum(node)]; + return tree.nodes.items(.main_token)[@backingInt(node)]; } pub fn nodeData(tree: *const Ast, node: Node.Index) Node.Data { - return tree.nodes.items(.data)[@intFromEnum(node)]; + return tree.nodes.items(.data)[@backingInt(node)]; } pub fn isTokenPrecededByTags( @@ -295,11 +295,11 @@ pub fn tokenSlice(tree: Ast, token_index: TokenIndex) []const u8 { } pub fn extraDataSlice(tree: Ast, range: Node.SubRange, comptime T: type) []const T { - return @ptrCast(tree.extra_data[@intFromEnum(range.start)..@intFromEnum(range.end)]); + return @ptrCast(tree.extra_data[@backingInt(range.start)..@backingInt(range.end)]); } pub fn extraDataSliceWithLen(tree: Ast, start: ExtraIndex, len: u32, comptime T: type) []const T { - return @ptrCast(tree.extra_data[@intFromEnum(start)..][0..len]); + return @ptrCast(tree.extra_data[@backingInt(start)..][0..len]); } pub fn extraData(tree: Ast, index: ExtraIndex, comptime T: type) T { @@ -311,8 +311,8 @@ pub fn extraData(tree: Ast, index: ExtraIndex, comptime T: type) T { Node.OptionalIndex, OptionalTokenIndex, ExtraIndex, - => @enumFromInt(tree.extra_data[@intFromEnum(index) + i]), - TokenIndex => tree.extra_data[@intFromEnum(index) + i], + => @fromBackingInt(@intCast(tree.extra_data[@backingInt(index) + i])), + TokenIndex => tree.extra_data[@backingInt(index) + i], else => @compileError("unexpected field type: " ++ @typeName(field_type)), }; } @@ -330,7 +330,7 @@ pub fn rootDecls(tree: Ast) []const Node.Index { switch (tree.mode) { .zig => return tree.extraDataSlice(tree.nodeData(.root).extra_range, Node.Index), // Ensure that the returned slice points into the existing memory of the Ast - .zon => return (&tree.nodes.items(.data)[@intFromEnum(Node.Index.root)].node)[0..1], + .zon => return (&tree.nodes.items(.data)[@backingInt(Node.Index.root)].node)[0..1], } } @@ -994,7 +994,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { const params = tree.extraData(extra_index, Node.SubRange); assert(params.start != params.end); end_offset += 1; // for the rparen - n = @enumFromInt(tree.extra_data[@intFromEnum(params.end) - 1]); // last parameter + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(params.end) - 1])); // last parameter }, .tagged_union_enum_tag => { const arg, const extra_index = tree.nodeData(n).node_and_extra; @@ -1004,7 +1004,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { n = arg; } else { end_offset += 1; // for the rbrace - n = @enumFromInt(tree.extra_data[@intFromEnum(members.end) - 1]); // last parameter + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(members.end) - 1])); // last parameter } }, .call_comma, @@ -1014,7 +1014,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { const params = tree.extraData(extra_index, Node.SubRange); assert(params.start != params.end); end_offset += 2; // for the comma/semicolon + rparen/rbrace - n = @enumFromInt(tree.extra_data[@intFromEnum(params.end) - 1]); // last parameter + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(params.end) - 1])); // last parameter }, .@"switch" => { const condition, const extra_index = tree.nodeData(n).node_and_extra; @@ -1024,7 +1024,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { n = condition; } else { end_offset += 1; // for the rbrace - n = @enumFromInt(tree.extra_data[@intFromEnum(cases.end) - 1]); // last case + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(cases.end) - 1])); // last case } }, .container_decl_arg => { @@ -1035,7 +1035,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { n = arg; } else { end_offset += 1; // for the rbrace - n = @enumFromInt(tree.extra_data[@intFromEnum(members.end) - 1]); // last parameter + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(members.end) - 1])); // last parameter } }, .@"asm" => { @@ -1050,7 +1050,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { const elements = tree.extraData(extra_index, Node.SubRange); assert(elements.start != elements.end); end_offset += 1; // for the rbrace - n = @enumFromInt(tree.extra_data[@intFromEnum(elements.end) - 1]); // last element + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(elements.end) - 1])); // last element }, .array_init_comma, .struct_init_comma, @@ -1061,7 +1061,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { const members = tree.extraData(extra_index, Node.SubRange); assert(members.start != members.end); end_offset += 2; // for the comma + rbrace - n = @enumFromInt(tree.extra_data[@intFromEnum(members.end) - 1]); // last parameter + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(members.end) - 1])); // last parameter }, .array_init_dot, .struct_init_dot, @@ -1073,7 +1073,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { const range = tree.nodeData(n).extra_range; assert(range.start != range.end); end_offset += 1; // for the rbrace - n = @enumFromInt(tree.extra_data[@intFromEnum(range.end) - 1]); // last statement + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(range.end) - 1])); // last statement }, .array_init_dot_comma, .struct_init_dot_comma, @@ -1085,7 +1085,7 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { const range = tree.nodeData(n).extra_range; assert(range.start != range.end); end_offset += 2; // for the comma/semicolon + rbrace/rparen - n = @enumFromInt(tree.extra_data[@intFromEnum(range.end) - 1]); // last member + n = @fromBackingInt(@intCast(tree.extra_data[@backingInt(range.end) - 1])); // last member }, .call_one, => { @@ -1285,8 +1285,8 @@ pub fn lastToken(tree: Ast, node: Node.Index) TokenIndex { }, .@"for" => { const extra_index, const extra = tree.nodeData(n).@"for"; - const index = @intFromEnum(extra_index) + extra.inputs + @intFromBool(extra.has_else); - n = @enumFromInt(tree.extra_data[index]); + const index = @backingInt(extra_index) + extra.inputs + @intFromBool(extra.has_else); + n = @fromBackingInt(@intCast(tree.extra_data[index])); }, .array_type_sentinel => { _, const extra_index = tree.nodeData(n).node_and_extra; @@ -1365,9 +1365,9 @@ pub fn alignedVarDecl(tree: Ast, node: Node.Index) full.VarDecl { pub fn assignDestructure(tree: Ast, node: Node.Index) full.AssignDestructure { const extra_index, const value_expr = tree.nodeData(node).extra_and_node; - const variable_count = tree.extra_data[@intFromEnum(extra_index)]; + const variable_count = tree.extra_data[@backingInt(extra_index)]; return tree.fullAssignDestructureComponents(.{ - .variables = tree.extraDataSliceWithLen(@enumFromInt(@intFromEnum(extra_index) + 1), variable_count, Node.Index), + .variables = tree.extraDataSliceWithLen(@fromBackingInt(@intCast(@backingInt(extra_index) + 1)), variable_count, Node.Index), .equal_token = tree.nodeMainToken(node), .value_expr = value_expr, }); @@ -1856,7 +1856,7 @@ pub fn switchCaseOne(tree: Ast, node: Node.Index) full.SwitchCase { &.{} else // Ensure that the returned slice points into the existing memory of the Ast - (@as(*const Node.Index, @ptrCast(&tree.nodes.items(.data)[@intFromEnum(node)].opt_node_and_node[0])))[0..1], + (@as(*const Node.Index, @ptrCast(&tree.nodes.items(.data)[@backingInt(node)].opt_node_and_node[0])))[0..1], .arrow_token = tree.nodeMainToken(node), .target_expr = target_expr, }, node); @@ -1932,7 +1932,7 @@ pub fn whileFull(tree: Ast, node: Node.Index) full.While { } pub fn forSimple(tree: Ast, node: Node.Index) full.For { - const data = &tree.nodes.items(.data)[@intFromEnum(node)].node_and_node; + const data = &tree.nodes.items(.data)[@backingInt(node)].node_and_node; return tree.fullForComponents(.{ .for_token = tree.nodeMainToken(node), .inputs = (&data[0])[0..1], @@ -1944,8 +1944,8 @@ pub fn forSimple(tree: Ast, node: Node.Index) full.For { pub fn forFull(tree: Ast, node: Node.Index) full.For { const extra_index, const extra = tree.nodeData(node).@"for"; const inputs = tree.extraDataSliceWithLen(extra_index, extra.inputs, Node.Index); - const then_expr: Node.Index = @enumFromInt(tree.extra_data[@intFromEnum(extra_index) + extra.inputs]); - const else_expr: Node.OptionalIndex = if (extra.has_else) @enumFromInt(tree.extra_data[@intFromEnum(extra_index) + extra.inputs + 1]) else .none; + const then_expr: Node.Index = @fromBackingInt(@intCast(tree.extra_data[@backingInt(extra_index) + extra.inputs])); + const else_expr: Node.OptionalIndex = if (extra.has_else) @fromBackingInt(@intCast(tree.extra_data[@backingInt(extra_index) + extra.inputs + 1])) else .none; return tree.fullForComponents(.{ .for_token = tree.nodeMainToken(node), .inputs = inputs, @@ -2922,15 +2922,15 @@ pub const Node = struct { _, pub fn toOptional(i: Index) OptionalIndex { - const result: OptionalIndex = @enumFromInt(@intFromEnum(i)); + const result: OptionalIndex = @fromBackingInt(@intCast(@backingInt(i))); assert(result != .none); return result; } pub fn toOffset(base: Index, destination: Index) Offset { - const base_i64: i64 = @intFromEnum(base); - const destination_i64: i64 = @intFromEnum(destination); - return @enumFromInt(destination_i64 - base_i64); + const base_i64: i64 = @backingInt(base); + const destination_i64: i64 = @backingInt(destination); + return @fromBackingInt(@intCast(destination_i64 - base_i64)); } }; @@ -2941,7 +2941,7 @@ pub const Node = struct { _, pub fn unwrap(oi: OptionalIndex) ?Index { - return if (oi == .none) null else @enumFromInt(@intFromEnum(oi)); + return if (oi == .none) null else @fromBackingInt(@intCast(@backingInt(oi))); } pub fn fromOptional(oi: ?Index) OptionalIndex { @@ -2955,13 +2955,13 @@ pub const Node = struct { _, pub fn toOptional(o: Offset) OptionalOffset { - const result: OptionalOffset = @enumFromInt(@intFromEnum(o)); + const result: OptionalOffset = @fromBackingInt(@intCast(@backingInt(o))); assert(result != .none); return result; } pub fn toAbsolute(offset: Offset, base: Index) Index { - return @enumFromInt(@as(i64, @intFromEnum(base)) + @intFromEnum(offset)); + return @fromBackingInt(@intCast(@as(i64, @backingInt(base)) + @backingInt(offset))); } }; @@ -2971,7 +2971,7 @@ pub const Node = struct { _, pub fn unwrap(oo: OptionalOffset) ?Offset { - return if (oo == .none) null else @enumFromInt(@intFromEnum(oo)); + return if (oo == .none) null else @fromBackingInt(@intCast(@backingInt(oo))); } }; diff --git a/lib/std/zig/Ast/Render.zig b/lib/std/zig/Ast/Render.zig index 2c430ca716fcaace9e76ad67d80348ff3a88fb66..53d9027d1351ebcd4a5658f6d3702bfe22cc95ca 100644 --- a/lib/std/zig/Ast/Render.zig +++ b/lib/std/zig/Ast/Render.zig @@ -2191,7 +2191,7 @@ fn renderArrayInit( width.* = for (w) |c| { if (!std.ascii.isPrint(c)) break .nonprint; - } else @enumFromInt(w.len - @intFromBool(w[w.len - 1] == ',')); + } else @fromBackingInt(@intCast(w.len - @intFromBool(w[w.len - 1] == ','))); } else { width.* = .nonprint; } @@ -2264,7 +2264,7 @@ fn renderArrayInit( col = 0; continue; } - col_widths[col] = @max(col_widths[col], @intFromEnum(w)); + col_widths[col] = @max(col_widths[col], @backingInt(w)); col += 1; if (col == row_size) { col = 0; @@ -2284,7 +2284,7 @@ fn renderArrayInit( } } else { try renderExpression(r, e, .comma_space); - try ais.splatByteAll(' ', col_widths[col] - @intFromEnum(w)); + try ais.splatByteAll(' ', col_widths[col] - @backingInt(w)); col += 1; } } diff --git a/lib/std/zig/AstGen.zig b/lib/std/zig/AstGen.zig index 1b158188c832b05ee3027df3d31fde60268e14df..a3ced5fcecae6af2024fcccc419ef2015ac4911e 100644 --- a/lib/std/zig/AstGen.zig +++ b/lib/std/zig/AstGen.zig @@ -103,13 +103,13 @@ fn setExtra(astgen: *AstGen, index: usize, extra: anytype) void { Ast.OptionalTokenIndex, Ast.Node.Index, Ast.Node.OptionalIndex, - => @intFromEnum(@field(extra, field_name)), + => @backingInt(@field(extra, field_name)), Ast.TokenOffset, Ast.OptionalTokenOffset, Ast.Node.Offset, Ast.Node.OptionalOffset, - => @bitCast(@intFromEnum(@field(extra, field_name))), + => @bitCast(@backingInt(@field(extra, field_name))), i32, Zir.Inst.Call.Flags, @@ -207,7 +207,7 @@ pub fn generate(gpa: Allocator, tree: Ast) Allocator.Error!Zir { break :fatal true; }; - const err_index = @intFromEnum(Zir.ExtraIndex.compile_errors); + const err_index = @backingInt(Zir.ExtraIndex.compile_errors); if (astgen.compile_errors.items.len == 0) { astgen.extra.items[err_index] = 0; } else { @@ -223,7 +223,7 @@ pub fn generate(gpa: Allocator, tree: Ast) Allocator.Error!Zir { } } - const imports_index = @intFromEnum(Zir.ExtraIndex.imports); + const imports_index = @backingInt(Zir.ExtraIndex.imports); if (astgen.imports.count() == 0) { astgen.extra.items[imports_index] = 0; } else { @@ -1380,7 +1380,7 @@ fn fnProtoExprInner( defer param_gz.unstack(); param_gz.is_comptime = true; const param_type = try fullBodyExpr(¶m_gz, scope, coerced_type_ri, param_type_node, .normal); - const param_inst_expected: Zir.Inst.Index = @enumFromInt(astgen.instructions.len + 1); + const param_inst_expected: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len + 1)); _ = try param_gz.addBreakWithSrcNode(.break_inline, param_inst_expected, param_type, param_type_node); const name_token = param.name_token orelse tree.nodeMainToken(param_type_node); const tag: Zir.Inst.Tag = if (is_comptime) .param_comptime else .param; @@ -1506,7 +1506,7 @@ fn arrayInitExpr( .tag = .array_init_elem_type, .data = .{ .bin = .{ .lhs = array_ty, - .rhs = @enumFromInt(i), + .rhs = @fromBackingInt(@intCast(i)), } }, }); _ = try expr(gz, scope, .{ .rl = .{ .ty = this_elem_ty } }, elem_init); @@ -1598,7 +1598,7 @@ fn arrayInitExprAnon( for (elements) |elem_init| { const elem_ref = try expr(gz, scope, .{ .rl = .none }, elem_init); - astgen.extra.items[extra_index] = @intFromEnum(elem_ref); + astgen.extra.items[extra_index] = @backingInt(elem_ref); extra_index += 1; } return try gz.addPlNodePayloadIndex(.array_init_anon, node, payload_index); @@ -1621,14 +1621,14 @@ fn arrayInitExprTyped( .operands_len = @intCast(len), }); var extra_index = try reserveExtra(astgen, len); - astgen.extra.items[extra_index] = @intFromEnum(ty_inst); + astgen.extra.items[extra_index] = @backingInt(ty_inst); extra_index += 1; if (maybe_elem_ty_inst != .none) { const elem_ri: ResultInfo = .{ .rl = .{ .coerced_ty = maybe_elem_ty_inst } }; for (elements) |elem_init| { const elem_inst = try expr(gz, scope, elem_ri, elem_init); - astgen.extra.items[extra_index] = @intFromEnum(elem_inst); + astgen.extra.items[extra_index] = @backingInt(elem_inst); extra_index += 1; } } else { @@ -1637,12 +1637,12 @@ fn arrayInitExprTyped( .tag = .array_init_elem_type, .data = .{ .bin = .{ .lhs = ty_inst, - .rhs = @enumFromInt(i), + .rhs = @fromBackingInt(@intCast(i)), } }, }) } }; const elem_inst = try expr(gz, scope, ri, elem_init); - astgen.extra.items[extra_index] = @intFromEnum(elem_inst); + astgen.extra.items[extra_index] = @backingInt(elem_inst); extra_index += 1; } } @@ -1673,7 +1673,7 @@ fn arrayInitExprPtr( .ptr = array_ptr_inst, .index = @intCast(i), }); - astgen.extra.items[extra_index] = @intFromEnum(elem_ptr_inst.toIndex().?); + astgen.extra.items[extra_index] = @backingInt(elem_ptr_inst.toIndex().?); extra_index += 1; _ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = elem_ptr_inst } } }, elem_init); } @@ -1966,7 +1966,7 @@ fn structInitExprPtr( .lhs = struct_ptr_inst, .field_name_start = str_index, }); - astgen.extra.items[extra_index] = @intFromEnum(field_ptr.toIndex().?); + astgen.extra.items[extra_index] = @backingInt(field_ptr.toIndex().?); extra_index += 1; _ = try expr(gz, scope, .{ .rl = .{ .ptr = .{ .inst = field_ptr } } }, field_init); } @@ -2658,11 +2658,11 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As // Note that this array becomes invalid after appending more items to it // in the above while loop. const zir_tags = gz.astgen.instructions.items(.tag); - switch (zir_tags[@intFromEnum(inst)]) { + switch (zir_tags[@backingInt(inst)]) { // For some instructions, modify the zir data // so we can avoid a separate ensure_result_used instruction. .call, .field_call => { - const break_extra = gz.astgen.instructions.items(.data)[@intFromEnum(inst)].pl_node.payload_index; + const break_extra = gz.astgen.instructions.items(.data)[@backingInt(inst)].pl_node.payload_index; comptime assert(std.meta.fieldIndex(Zir.Inst.Call, "flags") == std.meta.fieldIndex(Zir.Inst.FieldCall, "flags")); const flags: *Zir.Inst.Call.Flags = @ptrCast(&gz.astgen.extra.items[ @@ -2672,7 +2672,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As break :b true; }, .builtin_call => { - const break_extra = gz.astgen.instructions.items(.data)[@intFromEnum(inst)].pl_node.payload_index; + const break_extra = gz.astgen.instructions.items(.data)[@backingInt(inst)].pl_node.payload_index; const flags: *Zir.Inst.BuiltinCall.Flags = @ptrCast(&gz.astgen.extra.items[ break_extra + std.meta.fieldIndex(Zir.Inst.BuiltinCall, "flags").? ]); @@ -2888,7 +2888,7 @@ fn addEnsureResult(gz: *GenZir, maybe_unused_result: Zir.Inst.Ref, statement: As .array_init_elem_ptr, => break :b false, - .extended => switch (gz.astgen.instructions.items(.data)[@intFromEnum(inst)].extended.opcode) { + .extended => switch (gz.astgen.instructions.items(.data)[@backingInt(inst)].extended.opcode) { .breakpoint, .disable_instrumentation, .disable_intrinsics, @@ -3075,7 +3075,7 @@ fn deferStmt( const expr_node = tree.nodeData(node).node; _ = try unusedResultExpr(&defer_gen, &defer_gen.base, expr_node); try checkUsed(gz, scope, &defer_gen.base); - _ = try defer_gen.addBreak(.break_inline, @enumFromInt(0), .void_value); + _ = try defer_gen.addBreak(.break_inline, @fromBackingInt(@intCast(0)), .void_value); const body = defer_gen.instructionsSlice(); const body_len = gz.astgen.countBodyLenAfterFixupsExtraRefs(body, &.{}); @@ -3663,12 +3663,12 @@ fn assignOp( .tag = .extended, .data = .{ .extended = .{ .opcode = .inplace_arith_result_ty, - .small = @intFromEnum(@as(Zir.Inst.InplaceOp, switch (op_inst_tag) { + .small = @backingInt(@as(Zir.Inst.InplaceOp, switch (op_inst_tag) { .add => .add_eq, .sub => .sub_eq, else => unreachable, })), - .operand = @intFromEnum(lhs), + .operand = @backingInt(lhs), } }, }), else => try gz.addUnNode(.typeof, lhs, infix_node), // same as LHS type @@ -3819,20 +3819,20 @@ fn ptrType( .src_node = gz.nodeIndexToRelative(node), }); if (sentinel_ref != .none) { - gz.astgen.extra.appendAssumeCapacity(@intFromEnum(sentinel_ref)); + gz.astgen.extra.appendAssumeCapacity(@backingInt(sentinel_ref)); } if (align_ref != .none) { - gz.astgen.extra.appendAssumeCapacity(@intFromEnum(align_ref)); + gz.astgen.extra.appendAssumeCapacity(@backingInt(align_ref)); } if (addrspace_ref != .none) { - gz.astgen.extra.appendAssumeCapacity(@intFromEnum(addrspace_ref)); + gz.astgen.extra.appendAssumeCapacity(@backingInt(addrspace_ref)); } if (bit_start_ref != .none) { - gz.astgen.extra.appendAssumeCapacity(@intFromEnum(bit_start_ref)); - gz.astgen.extra.appendAssumeCapacity(@intFromEnum(bit_end_ref)); + gz.astgen.extra.appendAssumeCapacity(@backingInt(bit_start_ref)); + gz.astgen.extra.appendAssumeCapacity(@backingInt(bit_end_ref)); } - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); const result = new_index.toRef(); gz.astgen.instructions.appendAssumeCapacity(.{ .tag = .ptr_type, .data = .{ .ptr_type = .{ @@ -3957,7 +3957,7 @@ const WipDecls = struct { wip.* = undefined; } fn nextDecl(wip: *WipDecls, decl_inst: Zir.Inst.Index) void { - wip.slice.get(wip.astgen)[wip.index] = @intFromEnum(decl_inst); + wip.slice.get(wip.astgen)[wip.index] = @backingInt(decl_inst); wip.index += 1; } }; @@ -4012,7 +4012,7 @@ fn fnDecl( }; const lib_name = if (fn_proto.lib_name) |lib_name_token| blk: { const lib_name_str = try astgen.strLitAsString(lib_name_token); - const lib_name_slice = astgen.string_bytes.items[@intFromEnum(lib_name_str.index)..][0..lib_name_str.len]; + const lib_name_slice = astgen.string_bytes.items[@backingInt(lib_name_str.index)..][0..lib_name_str.len]; if (mem.findScalar(u8, lib_name_slice, 0) != null) { return astgen.failTok(lib_name_token, "library name cannot contain null bytes", .{}); } else if (lib_name_str.len == 0) { @@ -4231,7 +4231,7 @@ fn fnDeclInner( var param_gz = decl_gz.makeSubBlock(scope); defer param_gz.unstack(); const param_type = try fullBodyExpr(¶m_gz, params_scope, coerced_type_ri, param_type_node, .normal); - const param_inst_expected: Zir.Inst.Index = @enumFromInt(astgen.instructions.len + 1); + const param_inst_expected: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len + 1)); _ = try param_gz.addBreakWithSrcNode(.break_inline, param_inst_expected, param_type, param_type_node); const param_type_is_generic = any_param_used; @@ -4276,7 +4276,7 @@ fn fnDeclInner( // In this case we will send a len=0 body which can be encoded more efficiently. break :inst inst; } - _ = try ret_gz.addBreak(.break_inline, @enumFromInt(0), inst); + _ = try ret_gz.addBreak(.break_inline, @fromBackingInt(@intCast(0)), inst); break :inst inst; }; const ret_body_param_refs = try astgen.fetchRemoveRefEntries(param_insts.items); @@ -4299,11 +4299,11 @@ fn fnDeclInner( // In this case we will send a len=0 body which can be encoded more efficiently. break :blk inst; } - _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst); + _ = try cc_gz.addBreak(.break_inline, @fromBackingInt(@intCast(0)), inst); break :blk inst; } else if (has_inline_keyword) { const inst = try cc_gz.addStdLangValue(decl_node, .calling_convention_inline); - _ = try cc_gz.addBreak(.break_inline, @enumFromInt(0), inst); + _ = try cc_gz.addBreak(.break_inline, @fromBackingInt(@intCast(0)), inst); break :blk inst; } else { break :blk .none; @@ -4428,7 +4428,7 @@ fn globalVarDecl( } else false; const lib_name = if (var_decl.lib_name) |lib_name_token| blk: { const lib_name_str = try astgen.strLitAsString(lib_name_token); - const lib_name_slice = astgen.string_bytes.items[@intFromEnum(lib_name_str.index)..][0..lib_name_str.len]; + const lib_name_slice = astgen.string_bytes.items[@backingInt(lib_name_str.index)..][0..lib_name_str.len]; if (mem.findScalar(u8, lib_name_slice, 0) != null) { return astgen.failTok(lib_name_token, "library name cannot contain null bytes", .{}); } else if (lib_name_str.len == 0) { @@ -4650,7 +4650,7 @@ fn testDecl( else => .empty, .string_literal => name: { const name = try astgen.strLitAsString(test_name_token); - const slice = astgen.string_bytes.items[@intFromEnum(name.index)..][0..name.len]; + const slice = astgen.string_bytes.items[@backingInt(name.index)..][0..name.len]; if (mem.findScalar(u8, slice, 0) != null) { return astgen.failTok(test_name_token, "test name cannot contain null bytes", .{}); } else if (slice.len == 0) { @@ -4941,7 +4941,7 @@ fn structDeclInner( member.convertToNonTupleLike(astgen.tree); assert(!member.ast.tuple_like); - field_names.get(astgen)[field_idx] = @intFromEnum(try astgen.identAsString(member.ast.main_token)); + field_names.get(astgen)[field_idx] = @backingInt(try astgen.identAsString(member.ast.main_token)); { const type_node = member.ast.type_expr.unwrap() orelse { @@ -5087,13 +5087,13 @@ fn tupleDecl( } const field_type_ref = try typeExpr(gz, scope, field.ast.type_expr.unwrap().?); - astgen.scratch.appendAssumeCapacity(@intFromEnum(field_type_ref)); + astgen.scratch.appendAssumeCapacity(@backingInt(field_type_ref)); if (field.ast.value_expr.unwrap()) |value_expr| { const field_init_ref = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = field_type_ref } }, value_expr, .tuple_field_default_value); - astgen.scratch.appendAssumeCapacity(@intFromEnum(field_init_ref)); + astgen.scratch.appendAssumeCapacity(@backingInt(field_init_ref)); } else { - astgen.scratch.appendAssumeCapacity(@intFromEnum(Zir.Inst.Ref.none)); + astgen.scratch.appendAssumeCapacity(@backingInt(Zir.Inst.Ref.none)); } } @@ -5221,7 +5221,7 @@ fn unionDeclInner( return astgen.failTok(comptime_token, "union fields cannot be marked comptime", .{}); } - field_names.get(astgen)[field_idx] = @intFromEnum(try astgen.identAsString(member.ast.main_token)); + field_names.get(astgen)[field_idx] = @backingInt(try astgen.identAsString(member.ast.main_token)); if (member.ast.type_expr.unwrap()) |type_node| { const type_ref = try typeExpr(&block_scope, &namespace.base, type_node); @@ -5454,7 +5454,7 @@ fn containerDecl( astgen.src_hasher.update(tree.getNodeSource(member_node)); - field_names.get(astgen)[field_idx] = @intFromEnum(try astgen.identAsString(member.ast.main_token)); + field_names.get(astgen)[field_idx] = @backingInt(try astgen.identAsString(member.ast.main_token)); if (member.ast.value_expr.unwrap()) |value_node| { if (tag_type_body_len == null) { @@ -5709,7 +5709,7 @@ fn errorSetDecl(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index) InnerError!Zi } gop.value_ptr.* = tok_i; - try astgen.extra.append(gpa, @intFromEnum(str_index)); + try astgen.extra.append(gpa, @backingInt(str_index)); fields_len += 1; }, else => unreachable, @@ -6343,7 +6343,7 @@ fn setCondBrPayload( ); const zir_datas = astgen.instructions.items(.data); - zir_datas[@intFromEnum(condbr)].pl_node.payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.CondBr{ + zir_datas[@backingInt(condbr)].pl_node.payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.CondBr{ .condition = cond, .then_body_len = then_body_len, .else_body_len = else_body_len, @@ -7319,7 +7319,7 @@ fn switchExpr( // this lowering to avoiding a rather complex special case in Sema. assert(switch_full.label_token != null); // use `switch_block_err_union` code path instead! - assert(.block == astgen.instructions.items(.tag)[@intFromEnum(peer_break_target.block_inst)]); + assert(.block == astgen.instructions.items(.tag)[@backingInt(peer_break_target.block_inst)]); block_scope.break_target = peer_break_target.block_inst; block_scope.setBreakResultInfo(peer_break_target.block_ri); }, @@ -7829,14 +7829,14 @@ fn switchExpr( .scalar_cases_len = @intCast(scalar_cases_len), }, }); - astgen.instructions.items(.data)[@intFromEnum(switch_block)].pl_node.payload_index = zir_payload_index; + astgen.instructions.items(.data)[@backingInt(switch_block)].pl_node.payload_index = zir_payload_index; if (multi_cases_len > 0) astgen.extra.appendAssumeCapacity(multi_cases_len); - if (payload_capture_inst_is_placeholder) astgen.extra.appendAssumeCapacity(@intFromEnum(payload_capture_inst)); - if (tag_capture_inst_is_placeholder) astgen.extra.appendAssumeCapacity(@intFromEnum(tag_capture_inst)); + if (payload_capture_inst_is_placeholder) astgen.extra.appendAssumeCapacity(@backingInt(payload_capture_inst)); + if (tag_capture_inst_is_placeholder) astgen.extra.appendAssumeCapacity(@backingInt(tag_capture_inst)); if (needs_non_err_handling) { const catch_or_if_src_node_offset = parent_gz.nodeIndexToRelative(catch_or_if_node); - astgen.extra.appendAssumeCapacity(@bitCast(@intFromEnum(catch_or_if_src_node_offset))); + astgen.extra.appendAssumeCapacity(@bitCast(@backingInt(catch_or_if_src_node_offset))); astgen.extra.appendAssumeCapacity(@bitCast(non_err_info)); } if (has_else) astgen.extra.appendAssumeCapacity(@bitCast(else_info)); @@ -8484,7 +8484,7 @@ fn numberLiteral(gz: *GenZir, ri: ResultInfo, node: Ast.Node.Index, source_node: var big_int = try std.math.big.int.Managed.init(gpa); defer big_int.deinit(); const prefix_offset: usize = if (base == .decimal) 0 else 2; - big_int.setString(@intFromEnum(base), bytes[prefix_offset..]) catch |err| switch (err) { + big_int.setString(@backingInt(base), bytes[prefix_offset..]) catch |err| switch (err) { error.InvalidCharacter => unreachable, // caught in `parseNumberLiteral` error.InvalidBase => unreachable, // we only pass 16, 8, 2, see above error.OutOfMemory => |e| return e, @@ -8586,7 +8586,7 @@ fn asmExpr( }, else => .{ .tag = .asm_expr, - .tmpl = @enumFromInt(@intFromEnum(try comptimeExpr(gz, scope, .{ .rl = .none }, full.ast.template, .inline_assembly_code))), + .tmpl = @fromBackingInt(@intCast(@backingInt(try comptimeExpr(gz, scope, .{ .rl = .none }, full.ast.template, .inline_assembly_code)))), }, }; @@ -8903,7 +8903,7 @@ fn typeOf( for (args, 0..) |arg, i| { const param_ref = try reachableExpr(&typeof_scope, &typeof_scope.base, .{ .rl = .none }, arg, node); - astgen.extra.items[args_index + i] = @intFromEnum(param_ref); + astgen.extra.items[args_index + i] = @backingInt(param_ref); } _ = try typeof_scope.addBreak(.break_inline, typeof_inst.toIndex().?, .void_value); @@ -8952,7 +8952,7 @@ fn minMax( var extra_index = try reserveExtra(gz.astgen, args.len); for (args) |arg| { const arg_ref = try expr(gz, scope, .{ .rl = .none }, arg); - astgen.extra.items[extra_index] = @intFromEnum(arg_ref); + astgen.extra.items[extra_index] = @backingInt(arg_ref); extra_index += 1; } const tag: Zir.Inst.Extended = switch (op) { @@ -9023,7 +9023,7 @@ fn builtinCall( } const str_lit_token = tree.nodeMainToken(operand_node); const str = try astgen.strLitAsString(str_lit_token); - const str_slice = astgen.string_bytes.items[@intFromEnum(str.index)..][0..str.len]; + const str_slice = astgen.string_bytes.items[@backingInt(str.index)..][0..str.len]; if (mem.findScalar(u8, str_slice, 0) != null) { return astgen.failTok(str_lit_token, "import path cannot contain null bytes", .{}); } else if (str.len == 0) { @@ -9054,7 +9054,7 @@ fn builtinCall( var extra_index = try reserveExtra(gz.astgen, params.len); for (params) |param| { const param_ref = try expr(gz, scope, .{ .rl = .none }, param); - astgen.extra.items[extra_index] = @intFromEnum(param_ref); + astgen.extra.items[extra_index] = @backingInt(param_ref); extra_index += 1; } const result = try gz.addExtendedMultiOpPayloadIndex(.compile_log, payload_index, params.len); @@ -9264,7 +9264,7 @@ fn builtinCall( const param_types = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_type_type } }, params[0], .fn_param_types); const param_attrs_ty = try gz.addExtendedPayloadSmall( .reify_slice_arg_ty, - @intFromEnum(Zir.Inst.ReifySliceArgInfo.type_to_fn_param_attrs), + @backingInt(Zir.Inst.ReifySliceArgInfo.type_to_fn_param_attrs), Zir.Inst.UnNode{ .node = gz.nodeIndexToRelative(params[0]), .operand = param_types }, ); const param_attrs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = param_attrs_ty } }, params[1], .fn_param_attrs); @@ -9286,17 +9286,17 @@ fn builtinCall( const field_names = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_slice_const_u8_type } }, params[2], .struct_field_names); const field_types_ty = try gz.addExtendedPayloadSmall( .reify_slice_arg_ty, - @intFromEnum(Zir.Inst.ReifySliceArgInfo.string_to_struct_field_type), + @backingInt(Zir.Inst.ReifySliceArgInfo.string_to_struct_field_type), Zir.Inst.UnNode{ .node = gz.nodeIndexToRelative(params[2]), .operand = field_names }, ); const field_attrs_ty = try gz.addExtendedPayloadSmall( .reify_slice_arg_ty, - @intFromEnum(Zir.Inst.ReifySliceArgInfo.string_to_struct_field_attrs), + @backingInt(Zir.Inst.ReifySliceArgInfo.string_to_struct_field_attrs), Zir.Inst.UnNode{ .node = gz.nodeIndexToRelative(params[2]), .operand = field_names }, ); const field_types = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = field_types_ty } }, params[3], .struct_field_types); const field_attrs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = field_attrs_ty } }, params[4], .struct_field_attrs); - const result = try gz.addExtendedPayloadSmall(.reify_struct, @intFromEnum(reify_name_strat), Zir.Inst.ReifyStruct{ + const result = try gz.addExtendedPayloadSmall(.reify_struct, @backingInt(reify_name_strat), Zir.Inst.ReifyStruct{ .src_line = gz.astgen.source_line, .node = node, .layout = layout, @@ -9314,17 +9314,17 @@ fn builtinCall( const field_names = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = .slice_const_slice_const_u8_type } }, params[2], .union_field_names); const field_types_ty = try gz.addExtendedPayloadSmall( .reify_slice_arg_ty, - @intFromEnum(Zir.Inst.ReifySliceArgInfo.string_to_union_field_type), + @backingInt(Zir.Inst.ReifySliceArgInfo.string_to_union_field_type), Zir.Inst.UnNode{ .node = gz.nodeIndexToRelative(params[2]), .operand = field_names }, ); const field_attrs_ty = try gz.addExtendedPayloadSmall( .reify_slice_arg_ty, - @intFromEnum(Zir.Inst.ReifySliceArgInfo.string_to_union_field_attrs), + @backingInt(Zir.Inst.ReifySliceArgInfo.string_to_union_field_attrs), Zir.Inst.UnNode{ .node = gz.nodeIndexToRelative(params[2]), .operand = field_names }, ); const field_types = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = field_types_ty } }, params[3], .union_field_types); const field_attrs = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = field_attrs_ty } }, params[4], .union_field_attrs); - const result = try gz.addExtendedPayloadSmall(.reify_union, @intFromEnum(reify_name_strat), Zir.Inst.ReifyUnion{ + const result = try gz.addExtendedPayloadSmall(.reify_union, @backingInt(reify_name_strat), Zir.Inst.ReifyUnion{ .src_line = gz.astgen.source_line, .node = node, .layout = layout, @@ -9346,7 +9346,7 @@ fn builtinCall( .rhs = field_names, }); const field_values = try comptimeExpr(gz, scope, .{ .rl = .{ .coerced_ty = field_values_ty } }, params[3], .enum_field_values); - const result = try gz.addExtendedPayloadSmall(.reify_enum, @intFromEnum(reify_name_strat), Zir.Inst.ReifyEnum{ + const result = try gz.addExtendedPayloadSmall(.reify_enum, @backingInt(reify_name_strat), Zir.Inst.ReifyEnum{ .src_line = gz.astgen.source_line, .node = node, .tag_ty = tag_ty, @@ -9779,7 +9779,7 @@ fn floatRoundOp( .trunc => .trunc, else => unreachable, }; - const result = try gz.addExtendedPayloadSmall(.round_op, @intFromEnum(round_op), Zir.Inst.BinNode{ + const result = try gz.addExtendedPayloadSmall(.round_op, @backingInt(round_op), Zir.Inst.BinNode{ .node = gz.nodeIndexToRelative(node), .lhs = dest_type, .rhs = operand, @@ -9985,7 +9985,7 @@ fn callExpr( .field => |field| assert(field.obj_ptr != .none), } - const call_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const call_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); const call_inst = call_index.toRef(); try gz.astgen.instructions.append(astgen.gpa, undefined); try gz.instructions.append(astgen.gpa, call_index); @@ -10026,14 +10026,14 @@ fn callExpr( .callee = callee_obj, .flags = .{ .pop_error_return_trace = !propagate_error_trace, - .packed_modifier = @intCast(@intFromEnum(modifier)), + .packed_modifier = @intCast(@backingInt(modifier)), .args_len = @intCast(call.ast.params.len), }, }); if (call.ast.params.len != 0) { try astgen.extra.appendSlice(astgen.gpa, astgen.scratch.items[scratch_top..]); } - gz.astgen.instructions.set(@intFromEnum(call_index), .{ + gz.astgen.instructions.set(@backingInt(call_index), .{ .tag = .call, .data = .{ .pl_node = .{ .src_node = gz.nodeIndexToRelative(node), @@ -10047,14 +10047,14 @@ fn callExpr( .field_name_start = callee_field.field_name_start, .flags = .{ .pop_error_return_trace = !propagate_error_trace, - .packed_modifier = @intCast(@intFromEnum(modifier)), + .packed_modifier = @intCast(@backingInt(modifier)), .args_len = @intCast(call.ast.params.len), }, }); if (call.ast.params.len != 0) { try astgen.extra.appendSlice(astgen.gpa, astgen.scratch.items[scratch_top..]); } - gz.astgen.instructions.set(@intFromEnum(call_index), .{ + gz.astgen.instructions.set(@backingInt(call_index), .{ .tag = .field_call, .data = .{ .pl_node = .{ .src_node = gz.nodeIndexToRelative(node), @@ -10480,8 +10480,8 @@ fn rvalueInner( const result = r: { if (raw_result.toIndex()) |result_index| { const zir_tags = gz.astgen.instructions.items(.tag); - const data = gz.astgen.instructions.items(.data)[@intFromEnum(result_index)]; - if (zir_tags[@intFromEnum(result_index)].isAlwaysVoid(data)) { + const data = gz.astgen.instructions.items(.data)[@backingInt(result_index)]; + if (zir_tags[@backingInt(result_index)].isAlwaysVoid(data)) { break :r Zir.Inst.Ref.void_value; } } @@ -10520,108 +10520,108 @@ fn rvalueInner( }, .ty => |ty_inst| { // Quickly eliminate some common, unnecessary type coercion. - const as_ty = @as(u64, @intFromEnum(Zir.Inst.Ref.type_type)) << 32; - const as_bool = @as(u64, @intFromEnum(Zir.Inst.Ref.bool_type)) << 32; - const as_void = @as(u64, @intFromEnum(Zir.Inst.Ref.void_type)) << 32; - const as_comptime_int = @as(u64, @intFromEnum(Zir.Inst.Ref.comptime_int_type)) << 32; - const as_usize = @as(u64, @intFromEnum(Zir.Inst.Ref.usize_type)) << 32; - const as_u1 = @as(u64, @intFromEnum(Zir.Inst.Ref.u1_type)) << 32; - const as_u8 = @as(u64, @intFromEnum(Zir.Inst.Ref.u8_type)) << 32; - switch ((@as(u64, @intFromEnum(ty_inst)) << 32) | @as(u64, @intFromEnum(result))) { - as_ty | @intFromEnum(Zir.Inst.Ref.u1_type), - as_ty | @intFromEnum(Zir.Inst.Ref.u8_type), - as_ty | @intFromEnum(Zir.Inst.Ref.i8_type), - as_ty | @intFromEnum(Zir.Inst.Ref.u16_type), - as_ty | @intFromEnum(Zir.Inst.Ref.u29_type), - as_ty | @intFromEnum(Zir.Inst.Ref.i16_type), - as_ty | @intFromEnum(Zir.Inst.Ref.u32_type), - as_ty | @intFromEnum(Zir.Inst.Ref.i32_type), - as_ty | @intFromEnum(Zir.Inst.Ref.u64_type), - as_ty | @intFromEnum(Zir.Inst.Ref.i64_type), - as_ty | @intFromEnum(Zir.Inst.Ref.u128_type), - as_ty | @intFromEnum(Zir.Inst.Ref.i128_type), - as_ty | @intFromEnum(Zir.Inst.Ref.usize_type), - as_ty | @intFromEnum(Zir.Inst.Ref.isize_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_char_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_short_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_ushort_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_int_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_uint_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_long_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_ulong_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_longlong_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_ulonglong_type), - as_ty | @intFromEnum(Zir.Inst.Ref.c_longdouble_type), - as_ty | @intFromEnum(Zir.Inst.Ref.f16_type), - as_ty | @intFromEnum(Zir.Inst.Ref.f32_type), - as_ty | @intFromEnum(Zir.Inst.Ref.f64_type), - as_ty | @intFromEnum(Zir.Inst.Ref.f80_type), - as_ty | @intFromEnum(Zir.Inst.Ref.f128_type), - as_ty | @intFromEnum(Zir.Inst.Ref.anyopaque_type), - as_ty | @intFromEnum(Zir.Inst.Ref.bool_type), - as_ty | @intFromEnum(Zir.Inst.Ref.void_type), - as_ty | @intFromEnum(Zir.Inst.Ref.type_type), - as_ty | @intFromEnum(Zir.Inst.Ref.anyerror_type), - as_ty | @intFromEnum(Zir.Inst.Ref.comptime_int_type), - as_ty | @intFromEnum(Zir.Inst.Ref.comptime_float_type), - as_ty | @intFromEnum(Zir.Inst.Ref.noreturn_type), - as_ty | @intFromEnum(Zir.Inst.Ref.anyframe_type), - 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.ptr_usize_type), - as_ty | @intFromEnum(Zir.Inst.Ref.ptr_const_comptime_int_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), - as_ty | @intFromEnum(Zir.Inst.Ref.slice_const_u8_type), - as_ty | @intFromEnum(Zir.Inst.Ref.slice_const_u8_sentinel_0_type), - as_ty | @intFromEnum(Zir.Inst.Ref.anyerror_void_error_union_type), - as_ty | @intFromEnum(Zir.Inst.Ref.generic_poison_type), - as_ty | @intFromEnum(Zir.Inst.Ref.empty_tuple_type), - as_comptime_int | @intFromEnum(Zir.Inst.Ref.zero), - as_comptime_int | @intFromEnum(Zir.Inst.Ref.one), - as_comptime_int | @intFromEnum(Zir.Inst.Ref.negative_one), - as_usize | @intFromEnum(Zir.Inst.Ref.undef_usize), - as_usize | @intFromEnum(Zir.Inst.Ref.zero_usize), - as_usize | @intFromEnum(Zir.Inst.Ref.one_usize), - as_u1 | @intFromEnum(Zir.Inst.Ref.undef_u1), - as_u1 | @intFromEnum(Zir.Inst.Ref.zero_u1), - as_u1 | @intFromEnum(Zir.Inst.Ref.one_u1), - as_u8 | @intFromEnum(Zir.Inst.Ref.zero_u8), - as_u8 | @intFromEnum(Zir.Inst.Ref.one_u8), - as_u8 | @intFromEnum(Zir.Inst.Ref.four_u8), - as_bool | @intFromEnum(Zir.Inst.Ref.undef_bool), - as_bool | @intFromEnum(Zir.Inst.Ref.bool_true), - as_bool | @intFromEnum(Zir.Inst.Ref.bool_false), - as_void | @intFromEnum(Zir.Inst.Ref.void_value), + const as_ty = @as(u64, @backingInt(Zir.Inst.Ref.type_type)) << 32; + const as_bool = @as(u64, @backingInt(Zir.Inst.Ref.bool_type)) << 32; + const as_void = @as(u64, @backingInt(Zir.Inst.Ref.void_type)) << 32; + const as_comptime_int = @as(u64, @backingInt(Zir.Inst.Ref.comptime_int_type)) << 32; + const as_usize = @as(u64, @backingInt(Zir.Inst.Ref.usize_type)) << 32; + const as_u1 = @as(u64, @backingInt(Zir.Inst.Ref.u1_type)) << 32; + const as_u8 = @as(u64, @backingInt(Zir.Inst.Ref.u8_type)) << 32; + switch ((@as(u64, @backingInt(ty_inst)) << 32) | @as(u64, @backingInt(result))) { + as_ty | @backingInt(Zir.Inst.Ref.u1_type), + as_ty | @backingInt(Zir.Inst.Ref.u8_type), + as_ty | @backingInt(Zir.Inst.Ref.i8_type), + as_ty | @backingInt(Zir.Inst.Ref.u16_type), + as_ty | @backingInt(Zir.Inst.Ref.u29_type), + as_ty | @backingInt(Zir.Inst.Ref.i16_type), + as_ty | @backingInt(Zir.Inst.Ref.u32_type), + as_ty | @backingInt(Zir.Inst.Ref.i32_type), + as_ty | @backingInt(Zir.Inst.Ref.u64_type), + as_ty | @backingInt(Zir.Inst.Ref.i64_type), + as_ty | @backingInt(Zir.Inst.Ref.u128_type), + as_ty | @backingInt(Zir.Inst.Ref.i128_type), + as_ty | @backingInt(Zir.Inst.Ref.usize_type), + as_ty | @backingInt(Zir.Inst.Ref.isize_type), + as_ty | @backingInt(Zir.Inst.Ref.c_char_type), + as_ty | @backingInt(Zir.Inst.Ref.c_short_type), + as_ty | @backingInt(Zir.Inst.Ref.c_ushort_type), + as_ty | @backingInt(Zir.Inst.Ref.c_int_type), + as_ty | @backingInt(Zir.Inst.Ref.c_uint_type), + as_ty | @backingInt(Zir.Inst.Ref.c_long_type), + as_ty | @backingInt(Zir.Inst.Ref.c_ulong_type), + as_ty | @backingInt(Zir.Inst.Ref.c_longlong_type), + as_ty | @backingInt(Zir.Inst.Ref.c_ulonglong_type), + as_ty | @backingInt(Zir.Inst.Ref.c_longdouble_type), + as_ty | @backingInt(Zir.Inst.Ref.f16_type), + as_ty | @backingInt(Zir.Inst.Ref.f32_type), + as_ty | @backingInt(Zir.Inst.Ref.f64_type), + as_ty | @backingInt(Zir.Inst.Ref.f80_type), + as_ty | @backingInt(Zir.Inst.Ref.f128_type), + as_ty | @backingInt(Zir.Inst.Ref.anyopaque_type), + as_ty | @backingInt(Zir.Inst.Ref.bool_type), + as_ty | @backingInt(Zir.Inst.Ref.void_type), + as_ty | @backingInt(Zir.Inst.Ref.type_type), + as_ty | @backingInt(Zir.Inst.Ref.anyerror_type), + as_ty | @backingInt(Zir.Inst.Ref.comptime_int_type), + as_ty | @backingInt(Zir.Inst.Ref.comptime_float_type), + as_ty | @backingInt(Zir.Inst.Ref.noreturn_type), + as_ty | @backingInt(Zir.Inst.Ref.anyframe_type), + as_ty | @backingInt(Zir.Inst.Ref.null_type), + as_ty | @backingInt(Zir.Inst.Ref.undefined_type), + as_ty | @backingInt(Zir.Inst.Ref.enum_literal_type), + as_ty | @backingInt(Zir.Inst.Ref.ptr_usize_type), + as_ty | @backingInt(Zir.Inst.Ref.ptr_const_comptime_int_type), + as_ty | @backingInt(Zir.Inst.Ref.manyptr_u8_type), + as_ty | @backingInt(Zir.Inst.Ref.manyptr_const_u8_type), + as_ty | @backingInt(Zir.Inst.Ref.manyptr_const_u8_sentinel_0_type), + as_ty | @backingInt(Zir.Inst.Ref.slice_const_u8_type), + as_ty | @backingInt(Zir.Inst.Ref.slice_const_u8_sentinel_0_type), + as_ty | @backingInt(Zir.Inst.Ref.anyerror_void_error_union_type), + as_ty | @backingInt(Zir.Inst.Ref.generic_poison_type), + as_ty | @backingInt(Zir.Inst.Ref.empty_tuple_type), + as_comptime_int | @backingInt(Zir.Inst.Ref.zero), + as_comptime_int | @backingInt(Zir.Inst.Ref.one), + as_comptime_int | @backingInt(Zir.Inst.Ref.negative_one), + as_usize | @backingInt(Zir.Inst.Ref.undef_usize), + as_usize | @backingInt(Zir.Inst.Ref.zero_usize), + as_usize | @backingInt(Zir.Inst.Ref.one_usize), + as_u1 | @backingInt(Zir.Inst.Ref.undef_u1), + as_u1 | @backingInt(Zir.Inst.Ref.zero_u1), + as_u1 | @backingInt(Zir.Inst.Ref.one_u1), + as_u8 | @backingInt(Zir.Inst.Ref.zero_u8), + as_u8 | @backingInt(Zir.Inst.Ref.one_u8), + as_u8 | @backingInt(Zir.Inst.Ref.four_u8), + as_bool | @backingInt(Zir.Inst.Ref.undef_bool), + as_bool | @backingInt(Zir.Inst.Ref.bool_true), + as_bool | @backingInt(Zir.Inst.Ref.bool_false), + as_void | @backingInt(Zir.Inst.Ref.void_value), => return result, // type of result is already correct - as_bool | @intFromEnum(Zir.Inst.Ref.undef) => return .undef_bool, - as_usize | @intFromEnum(Zir.Inst.Ref.undef) => return .undef_usize, - as_usize | @intFromEnum(Zir.Inst.Ref.undef_u1) => return .undef_usize, - as_u1 | @intFromEnum(Zir.Inst.Ref.undef) => return .undef_u1, + as_bool | @backingInt(Zir.Inst.Ref.undef) => return .undef_bool, + as_usize | @backingInt(Zir.Inst.Ref.undef) => return .undef_usize, + as_usize | @backingInt(Zir.Inst.Ref.undef_u1) => return .undef_usize, + as_u1 | @backingInt(Zir.Inst.Ref.undef) => return .undef_u1, - as_usize | @intFromEnum(Zir.Inst.Ref.zero) => return .zero_usize, - as_u1 | @intFromEnum(Zir.Inst.Ref.zero) => return .zero_u1, - as_u8 | @intFromEnum(Zir.Inst.Ref.zero) => return .zero_u8, - as_usize | @intFromEnum(Zir.Inst.Ref.one) => return .one_usize, - as_u1 | @intFromEnum(Zir.Inst.Ref.one) => return .one_u1, - as_u8 | @intFromEnum(Zir.Inst.Ref.one) => return .one_u8, - as_comptime_int | @intFromEnum(Zir.Inst.Ref.zero_usize) => return .zero, - as_u1 | @intFromEnum(Zir.Inst.Ref.zero_usize) => return .zero_u1, - as_u8 | @intFromEnum(Zir.Inst.Ref.zero_usize) => return .zero_u8, - as_comptime_int | @intFromEnum(Zir.Inst.Ref.one_usize) => return .one, - as_u1 | @intFromEnum(Zir.Inst.Ref.one_usize) => return .one_u1, - as_u8 | @intFromEnum(Zir.Inst.Ref.one_usize) => return .one_u8, - as_comptime_int | @intFromEnum(Zir.Inst.Ref.zero_u1) => return .zero, - as_comptime_int | @intFromEnum(Zir.Inst.Ref.zero_u8) => return .zero, - as_usize | @intFromEnum(Zir.Inst.Ref.zero_u1) => return .zero_usize, - as_usize | @intFromEnum(Zir.Inst.Ref.zero_u8) => return .zero_usize, - as_comptime_int | @intFromEnum(Zir.Inst.Ref.one_u1) => return .one, - as_comptime_int | @intFromEnum(Zir.Inst.Ref.one_u8) => return .one, - as_usize | @intFromEnum(Zir.Inst.Ref.one_u1) => return .one_usize, - as_usize | @intFromEnum(Zir.Inst.Ref.one_u8) => return .one_usize, + as_usize | @backingInt(Zir.Inst.Ref.zero) => return .zero_usize, + as_u1 | @backingInt(Zir.Inst.Ref.zero) => return .zero_u1, + as_u8 | @backingInt(Zir.Inst.Ref.zero) => return .zero_u8, + as_usize | @backingInt(Zir.Inst.Ref.one) => return .one_usize, + as_u1 | @backingInt(Zir.Inst.Ref.one) => return .one_u1, + as_u8 | @backingInt(Zir.Inst.Ref.one) => return .one_u8, + as_comptime_int | @backingInt(Zir.Inst.Ref.zero_usize) => return .zero, + as_u1 | @backingInt(Zir.Inst.Ref.zero_usize) => return .zero_u1, + as_u8 | @backingInt(Zir.Inst.Ref.zero_usize) => return .zero_u8, + as_comptime_int | @backingInt(Zir.Inst.Ref.one_usize) => return .one, + as_u1 | @backingInt(Zir.Inst.Ref.one_usize) => return .one_u1, + as_u8 | @backingInt(Zir.Inst.Ref.one_usize) => return .one_u8, + as_comptime_int | @backingInt(Zir.Inst.Ref.zero_u1) => return .zero, + as_comptime_int | @backingInt(Zir.Inst.Ref.zero_u8) => return .zero, + as_usize | @backingInt(Zir.Inst.Ref.zero_u1) => return .zero_usize, + as_usize | @backingInt(Zir.Inst.Ref.zero_u8) => return .zero_usize, + as_comptime_int | @backingInt(Zir.Inst.Ref.one_u1) => return .one, + as_comptime_int | @backingInt(Zir.Inst.Ref.one_u8) => return .one, + as_usize | @backingInt(Zir.Inst.Ref.one_u1) => return .one_usize, + as_usize | @backingInt(Zir.Inst.Ref.one_u8) => return .one_usize, // Need an explicit type coercion instruction. else => return gz.addPlNode(ri.zirTag(), src_node, Zir.Inst.As{ @@ -10791,7 +10791,7 @@ fn appendErrorNodeNotes( @branchHint(.cold); const gpa = astgen.gpa; const string_bytes = &astgen.string_bytes; - const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len); + const msg: Zir.NullTerminatedString = @fromBackingInt(@intCast(string_bytes.items.len)); try string_bytes.print(gpa, format ++ "\x00", args); const notes_index: u32 = if (notes.len != 0) blk: { const notes_start = astgen.extra.items.len; @@ -10883,7 +10883,7 @@ fn appendErrorTokNotesOff( @branchHint(.cold); const gpa = astgen.gpa; const string_bytes = &astgen.string_bytes; - const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len); + const msg: Zir.NullTerminatedString = @fromBackingInt(@intCast(string_bytes.items.len)); try string_bytes.print(gpa, format ++ "\x00", args); const notes_index: u32 = if (notes.len != 0) blk: { const notes_start = astgen.extra.items.len; @@ -10919,7 +10919,7 @@ fn errNoteTokOff( ) Allocator.Error!u32 { @branchHint(.cold); const string_bytes = &astgen.string_bytes; - const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len); + const msg: Zir.NullTerminatedString = @fromBackingInt(@intCast(string_bytes.items.len)); try string_bytes.print(astgen.gpa, format ++ "\x00", args); return astgen.addExtra(Zir.Inst.CompileErrors.Item{ .msg = msg, @@ -10938,7 +10938,7 @@ fn errNoteNode( ) Allocator.Error!u32 { @branchHint(.cold); const string_bytes = &astgen.string_bytes; - const msg: Zir.NullTerminatedString = @enumFromInt(string_bytes.items.len); + const msg: Zir.NullTerminatedString = @fromBackingInt(@intCast(string_bytes.items.len)); try string_bytes.print(astgen.gpa, format ++ "\x00", args); return astgen.addExtra(Zir.Inst.CompileErrors.Item{ .msg = msg, @@ -10962,11 +10962,11 @@ fn identAsString(astgen: *AstGen, ident_token: Ast.TokenIndex) !Zir.NullTerminat }); if (gop.found_existing) { string_bytes.shrinkRetainingCapacity(str_index); - return @enumFromInt(gop.key_ptr.*); + return @fromBackingInt(@intCast(gop.key_ptr.*)); } else { gop.key_ptr.* = str_index; try string_bytes.append(gpa, 0); - return @enumFromInt(str_index); + return @fromBackingInt(@intCast(str_index)); } } @@ -10980,7 +10980,7 @@ fn strLitAsString(astgen: *AstGen, str_lit_token: Ast.TokenIndex) !IndexSlice { try astgen.parseStrLit(str_lit_token, string_bytes, token_bytes, 0); const key: []const u8 = string_bytes.items[str_index..]; if (std.mem.findScalar(u8, key, 0)) |_| return .{ - .index = @enumFromInt(str_index), + .index = @fromBackingInt(@intCast(str_index)), .len = @intCast(key.len), }; const gop = try astgen.string_table.getOrPutContextAdapted(gpa, key, StringIndexAdapter{ @@ -10991,7 +10991,7 @@ fn strLitAsString(astgen: *AstGen, str_lit_token: Ast.TokenIndex) !IndexSlice { if (gop.found_existing) { string_bytes.shrinkRetainingCapacity(str_index); return .{ - .index = @enumFromInt(gop.key_ptr.*), + .index = @fromBackingInt(@intCast(gop.key_ptr.*)), .len = @intCast(key.len), }; } else { @@ -11001,7 +11001,7 @@ fn strLitAsString(astgen: *AstGen, str_lit_token: Ast.TokenIndex) !IndexSlice { // be null terminated for that to work. try string_bytes.append(gpa, 0); return .{ - .index = @enumFromInt(str_index), + .index = @fromBackingInt(@intCast(str_index)), .len = @intCast(key.len), }; } @@ -11035,7 +11035,7 @@ fn strLitNodeAsString(astgen: *AstGen, node: Ast.Node.Index) !IndexSlice { const len = string_bytes.items.len - str_index; try string_bytes.append(gpa, 0); return IndexSlice{ - .index = @enumFromInt(str_index), + .index = @fromBackingInt(@intCast(str_index)), .len = @intCast(len), }; } @@ -11333,14 +11333,14 @@ const GenZir = struct { if (gz.isEmpty()) return false; const tags = gz.astgen.instructions.items(.tag); const last_inst = gz.instructions.items[gz.instructions.items.len - 1]; - return tags[@intFromEnum(last_inst)].isNoReturn(); + return tags[@backingInt(last_inst)].isNoReturn(); } /// TODO all uses of this should be replaced with uses of `endsWithNoReturn`. fn refIsNoReturn(gz: GenZir, inst_ref: Zir.Inst.Ref) bool { if (inst_ref == .unreachable_value) return true; if (inst_ref.toIndex()) |inst_index| { - return gz.astgen.instructions.items(.tag)[@intFromEnum(inst_index)].isNoReturn(); + return gz.astgen.instructions.items(.tag)[@backingInt(inst_index)].isNoReturn(); } return false; } @@ -11391,7 +11391,7 @@ const GenZir = struct { @typeInfo(Zir.Inst.BoolBr).@"struct".field_names.len + body_len, ); const zir_datas = astgen.instructions.items(.data); - zir_datas[@intFromEnum(bool_br)].pl_node.payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.BoolBr{ + zir_datas[@backingInt(bool_br)].pl_node.payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.BoolBr{ .lhs = bool_br_lhs, .body_len = body_len, }); @@ -11408,14 +11408,14 @@ const GenZir = struct { const body_len = astgen.countBodyLenAfterFixups(body); const zir_tags = astgen.instructions.items(.tag); - assert(zir_tags[@intFromEnum(inst)] != .block_comptime); // use `setComptimeBlockBody` instead + assert(zir_tags[@backingInt(inst)] != .block_comptime); // use `setComptimeBlockBody` instead try astgen.extra.ensureUnusedCapacity( gpa, @typeInfo(Zir.Inst.Block).@"struct".field_names.len + body_len, ); const zir_datas = astgen.instructions.items(.data); - zir_datas[@intFromEnum(inst)].pl_node.payload_index = astgen.addExtraAssumeCapacity( + zir_datas[@backingInt(inst)].pl_node.payload_index = astgen.addExtraAssumeCapacity( Zir.Inst.Block{ .body_len = body_len }, ); astgen.appendBodyWithFixups(body); @@ -11431,14 +11431,14 @@ const GenZir = struct { const body_len = astgen.countBodyLenAfterFixups(body); const zir_tags = astgen.instructions.items(.tag); - assert(zir_tags[@intFromEnum(inst)] == .block_comptime); // use `setBlockBody` instead + assert(zir_tags[@backingInt(inst)] == .block_comptime); // use `setBlockBody` instead try astgen.extra.ensureUnusedCapacity( gpa, @typeInfo(Zir.Inst.BlockComptime).@"struct".field_names.len + body_len, ); const zir_datas = astgen.instructions.items(.data); - zir_datas[@intFromEnum(inst)].pl_node.payload_index = astgen.addExtraAssumeCapacity( + zir_datas[@backingInt(inst)].pl_node.payload_index = astgen.addExtraAssumeCapacity( Zir.Inst.BlockComptime{ .reason = comptime_reason, .body_len = body_len, @@ -11459,7 +11459,7 @@ const GenZir = struct { @typeInfo(Zir.Inst.Try).@"struct".field_names.len + body_len, ); const zir_datas = astgen.instructions.items(.data); - zir_datas[@intFromEnum(inst)].pl_node.payload_index = astgen.addExtraAssumeCapacity( + zir_datas[@backingInt(inst)].pl_node.payload_index = astgen.addExtraAssumeCapacity( Zir.Inst.Try{ .operand = operand, .body_len = body_len, @@ -11507,7 +11507,7 @@ const GenZir = struct { const astgen = gz.astgen; const gpa = astgen.gpa; const ret_ref = if (args.ret_ref == .void_type) .none else args.ret_ref; - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); try gz.instructions.ensureUnusedCapacity(gpa, 1); try astgen.instructions.ensureUnusedCapacity(gpa, 1); @@ -11598,11 +11598,11 @@ const GenZir = struct { if (cc_body.len != 0) { astgen.extra.appendAssumeCapacity(astgen.countBodyLenAfterFixups(cc_body)); astgen.appendBodyWithFixups(cc_body); - const break_extra = zir_datas[@intFromEnum(cc_body[cc_body.len - 1])].@"break".payload_index; + const break_extra = zir_datas[@backingInt(cc_body[cc_body.len - 1])].@"break".payload_index; astgen.extra.items[break_extra + std.meta.fieldIndex(Zir.Inst.Break, "block_inst").?] = - @intFromEnum(new_index); + @backingInt(new_index); } else if (args.cc_ref != .none) { - astgen.extra.appendAssumeCapacity(@intFromEnum(args.cc_ref)); + astgen.extra.appendAssumeCapacity(@backingInt(args.cc_ref)); } if (ret_body.len != 0) { astgen.extra.appendAssumeCapacity( @@ -11611,11 +11611,11 @@ const GenZir = struct { ); astgen.appendBodyWithFixups(args.ret_param_refs); astgen.appendBodyWithFixups(ret_body); - const break_extra = zir_datas[@intFromEnum(ret_body[ret_body.len - 1])].@"break".payload_index; + const break_extra = zir_datas[@backingInt(ret_body[ret_body.len - 1])].@"break".payload_index; astgen.extra.items[break_extra + std.meta.fieldIndex(Zir.Inst.Break, "block_inst").?] = - @intFromEnum(new_index); + @backingInt(new_index); } else if (ret_ref != .none) { - astgen.extra.appendAssumeCapacity(@intFromEnum(ret_ref)); + astgen.extra.appendAssumeCapacity(@backingInt(ret_ref)); } if (args.noalias_bits != 0) { @@ -11652,11 +11652,11 @@ const GenZir = struct { astgen.appendBodyWithFixups(args.ret_param_refs); astgen.appendBodyWithFixups(ret_body); - const break_extra = zir_datas[@intFromEnum(ret_body[ret_body.len - 1])].@"break".payload_index; + const break_extra = zir_datas[@backingInt(ret_body[ret_body.len - 1])].@"break".payload_index; astgen.extra.items[break_extra + std.meta.fieldIndex(Zir.Inst.Break, "block_inst").?] = - @intFromEnum(new_index); + @backingInt(new_index); } else if (ret_ref != .none) { - astgen.extra.appendAssumeCapacity(@intFromEnum(ret_ref)); + astgen.extra.appendAssumeCapacity(@backingInt(ret_ref)); } astgen.appendBodyWithFixupsExtraRefsArrayList(&astgen.extra, body, args.param_insts); astgen.extra.appendSliceAssumeCapacity(src_locs_and_hash); @@ -11704,11 +11704,11 @@ const GenZir = struct { try astgen.instructions.ensureUnusedCapacity(gpa, 1); try astgen.string_bytes.ensureUnusedCapacity(gpa, @sizeOf(std.math.big.Limb) * limbs.len); - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); astgen.instructions.appendAssumeCapacity(.{ .tag = .int_big, .data = .{ .str = .{ - .start = @enumFromInt(astgen.string_bytes.items.len), + .start = @fromBackingInt(@intCast(astgen.string_bytes.items.len)), .len = @intCast(limbs.len), } }, }); @@ -11749,7 +11749,7 @@ const GenZir = struct { src_node: Ast.Node.Index, ) !Zir.Inst.Index { assert(operand != .none); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); try gz.astgen.instructions.append(gz.astgen.gpa, .{ .tag = tag, .data = .{ .un_node = .{ @@ -11772,7 +11772,7 @@ const GenZir = struct { try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1); const payload_index = try gz.astgen.addExtra(extra); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); gz.astgen.instructions.appendAssumeCapacity(.{ .tag = tag, .data = .{ .pl_node = .{ @@ -11829,7 +11829,7 @@ const GenZir = struct { gz.astgen.appendBodyWithFixupsExtraRefsArrayList(&gz.astgen.extra, param_body, prev_param_insts); param_gz.unstack(); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); gz.astgen.instructions.appendAssumeCapacity(.{ .tag = tag, .data = .{ .pl_tok = .{ @@ -11842,7 +11842,7 @@ const GenZir = struct { } fn addStdLangValue(gz: *GenZir, src_node: Ast.Node.Index, val: Zir.Inst.StdLangValue) !Zir.Inst.Ref { - return addExtendedNodeSmall(gz, .std_lang_value, src_node, @intFromEnum(val)); + return addExtendedNodeSmall(gz, .std_lang_value, src_node, @backingInt(val)); } fn addExtendedPayload(gz: *GenZir, opcode: Zir.Inst.Extended, extra: anytype) !Zir.Inst.Ref { @@ -11861,7 +11861,7 @@ const GenZir = struct { try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1); const payload_index = try gz.astgen.addExtra(extra); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); gz.astgen.instructions.appendAssumeCapacity(.{ .tag = .extended, .data = .{ .extended = .{ @@ -11893,7 +11893,7 @@ const GenZir = struct { const payload_index = astgen.addExtraAssumeCapacity(Zir.Inst.NodeMultiOp{ .src_node = gz.nodeIndexToRelative(node), }); - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); astgen.instructions.appendAssumeCapacity(.{ .tag = .extended, .data = .{ .extended = .{ @@ -11918,7 +11918,7 @@ const GenZir = struct { try gz.instructions.ensureUnusedCapacity(gpa, 1); try astgen.instructions.ensureUnusedCapacity(gpa, 1); - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); astgen.instructions.appendAssumeCapacity(.{ .tag = .extended, .data = .{ .extended = .{ @@ -11942,13 +11942,13 @@ const GenZir = struct { try gz.instructions.ensureUnusedCapacity(gpa, 1); try astgen.instructions.ensureUnusedCapacity(gpa, 1); - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); astgen.instructions.appendAssumeCapacity(.{ .tag = .extended, .data = .{ .extended = .{ .opcode = opcode, .small = small, - .operand = @bitCast(@intFromEnum(gz.nodeIndexToRelative(src_node))), + .operand = @bitCast(@backingInt(gz.nodeIndexToRelative(src_node))), } }, }); gz.instructions.appendAssumeCapacity(new_index); @@ -11980,7 +11980,7 @@ const GenZir = struct { abs_tok_index: Ast.TokenIndex, ) !Zir.Inst.Index { const astgen = gz.astgen; - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); assert(operand != .none); try astgen.instructions.append(astgen.gpa, .{ .tag = tag, @@ -12130,7 +12130,7 @@ const GenZir = struct { try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1); try gz.astgen.extra.ensureUnusedCapacity(gpa, @typeInfo(Zir.Inst.Break).@"struct".field_names.len); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); gz.astgen.instructions.appendAssumeCapacity(.{ .tag = tag, .data = .{ .@"break" = .{ @@ -12228,7 +12228,7 @@ const GenZir = struct { .data = .{ .extended = .{ .opcode = opcode, .small = undefined, - .operand = @bitCast(@intFromEnum(gz.nodeIndexToRelative(src_node))), + .operand = @bitCast(@backingInt(gz.nodeIndexToRelative(src_node))), } }, }); } @@ -12259,10 +12259,10 @@ const GenZir = struct { .src_node = gz.nodeIndexToRelative(args.node), }); if (args.type_inst != .none) { - astgen.extra.appendAssumeCapacity(@intFromEnum(args.type_inst)); + astgen.extra.appendAssumeCapacity(@backingInt(args.type_inst)); } if (args.align_inst != .none) { - astgen.extra.appendAssumeCapacity(@intFromEnum(args.align_inst)); + astgen.extra.appendAssumeCapacity(@backingInt(args.align_inst)); } const has_type: u4 = @intFromBool(args.type_inst != .none); @@ -12271,7 +12271,7 @@ const GenZir = struct { const is_comptime: u4 = @intFromBool(args.is_comptime); const small: u16 = has_type | (has_align << 1) | (is_const << 2) | (is_comptime << 3); - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); astgen.instructions.appendAssumeCapacity(.{ .tag = .extended, .data = .{ .extended = .{ @@ -12326,7 +12326,7 @@ const GenZir = struct { .inputs_len = @intCast(args.inputs.len), }; - const new_index: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); astgen.instructions.appendAssumeCapacity(.{ .tag = .extended, .data = .{ .extended = .{ @@ -12343,7 +12343,7 @@ const GenZir = struct { /// Does *not* append the block instruction to the scope. /// Leaves the `payload_index` field undefined. fn makeBlockInst(gz: *GenZir, tag: Zir.Inst.Tag, node: Ast.Node.Index) !Zir.Inst.Index { - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); const gpa = gz.astgen.gpa; try gz.astgen.instructions.append(gpa, .{ .tag = tag, @@ -12359,7 +12359,7 @@ const GenZir = struct { /// Does *not* append the block instruction to the scope. /// Leaves the `payload_index` field undefined. Use `setDeclaration` to finalize. fn makeDeclaration(gz: *GenZir, node: Ast.Node.Index) !Zir.Inst.Index { - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); try gz.astgen.instructions.append(gz.astgen.gpa, .{ .tag = .declaration, .data = .{ .declaration = .{ @@ -12375,7 +12375,7 @@ const GenZir = struct { fn addCondBr(gz: *GenZir, tag: Zir.Inst.Tag, node: Ast.Node.Index) !Zir.Inst.Index { const gpa = gz.astgen.gpa; try gz.instructions.ensureUnusedCapacity(gpa, 1); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); try gz.astgen.instructions.append(gpa, .{ .tag = tag, .data = .{ .pl_node = .{ @@ -12436,7 +12436,7 @@ const GenZir = struct { astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names)); astgen.extra.appendSliceAssumeCapacity(args.remaining); - astgen.instructions.set(@intFromEnum(inst), .{ + astgen.instructions.set(@backingInt(inst), .{ .tag = .extended, .data = .{ .extended = .{ .opcode = .struct_decl, @@ -12507,7 +12507,7 @@ const GenZir = struct { astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names)); astgen.extra.appendSliceAssumeCapacity(args.remaining); - astgen.instructions.set(@intFromEnum(inst), .{ + astgen.instructions.set(@backingInt(inst), .{ .tag = .extended, .data = .{ .extended = .{ .opcode = .union_decl, @@ -12571,7 +12571,7 @@ const GenZir = struct { astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names)); astgen.extra.appendSliceAssumeCapacity(args.remaining); - astgen.instructions.set(@intFromEnum(inst), .{ + astgen.instructions.set(@backingInt(inst), .{ .tag = .extended, .data = .{ .extended = .{ .opcode = .enum_decl, @@ -12620,7 +12620,7 @@ const GenZir = struct { astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.capture_names)); astgen.extra.appendSliceAssumeCapacity(@ptrCast(args.decls)); - astgen.instructions.set(@intFromEnum(inst), .{ + astgen.instructions.set(@backingInt(inst), .{ .tag = .extended, .data = .{ .extended = .{ .opcode = .opaque_decl, @@ -12643,7 +12643,7 @@ const GenZir = struct { try gz.instructions.ensureUnusedCapacity(gpa, 1); try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); gz.astgen.instructions.appendAssumeCapacity(inst); gz.instructions.appendAssumeCapacity(new_index); return new_index; @@ -12654,7 +12654,7 @@ const GenZir = struct { try gz.instructions.ensureUnusedCapacity(gpa, 1); try gz.astgen.instructions.ensureUnusedCapacity(gpa, 1); - const new_index: Zir.Inst.Index = @enumFromInt(gz.astgen.instructions.len); + const new_index: Zir.Inst.Index = @fromBackingInt(@intCast(gz.astgen.instructions.len)); gz.astgen.instructions.len += 1; gz.instructions.appendAssumeCapacity(new_index); return new_index; @@ -12683,7 +12683,7 @@ const GenZir = struct { /// This can only be for short-lived references; the memory becomes invalidated /// when another string is added. fn nullTerminatedString(astgen: AstGen, index: Zir.NullTerminatedString) [*:0]const u8 { - return @ptrCast(astgen.string_bytes.items[@intFromEnum(index)..]); + return @ptrCast(astgen.string_bytes.items[@backingInt(index)..]); } /// Local variables shadowing detection, including function parameters. @@ -13136,7 +13136,7 @@ fn scanContainer( } fn appendPlaceholder(astgen: *AstGen) Allocator.Error!Zir.Inst.Index { - const inst: Zir.Inst.Index = @enumFromInt(astgen.instructions.len); + const inst: Zir.Inst.Index = @fromBackingInt(@intCast(astgen.instructions.len)); try astgen.instructions.append(astgen.gpa, .{ .tag = .extended, .data = .{ .extended = .{ @@ -13183,7 +13183,7 @@ fn appendPossiblyRefdBodyInst( list: *std.ArrayList(u32), body_inst: Zir.Inst.Index, ) void { - list.appendAssumeCapacity(@intFromEnum(body_inst)); + list.appendAssumeCapacity(@backingInt(body_inst)); const kv = astgen.ref_table.fetchRemove(body_inst) orelse return; const ref_inst = kv.value; return appendPossiblyRefdBodyInst(astgen, list, ref_inst); @@ -13221,8 +13221,8 @@ fn emitDbgStmt(gz: *GenZir, lc: LineColumn) !void { if (gz.instructions.items.len > gz.instructions_top) { const astgen = gz.astgen; const last = gz.instructions.items[gz.instructions.items.len - 1]; - if (astgen.instructions.items(.tag)[@intFromEnum(last)] == .dbg_stmt) { - astgen.instructions.items(.data)[@intFromEnum(last)].dbg_stmt = .{ + if (astgen.instructions.items(.tag)[@backingInt(last)] == .dbg_stmt) { + astgen.instructions.items(.data)[@backingInt(last)].dbg_stmt = .{ .line = lc[0], .column = lc[1], }; @@ -13245,7 +13245,7 @@ fn emitDbgStmt(gz: *GenZir, lc: LineColumn) !void { fn emitDbgStmtForceCurrentIndex(gz: *GenZir, lc: LineColumn) !void { const astgen = gz.astgen; if (gz.instructions.items.len > gz.instructions_top and - @intFromEnum(gz.instructions.items[gz.instructions.items.len - 1]) == astgen.instructions.len - 1) + @backingInt(gz.instructions.items[gz.instructions.items.len - 1]) == astgen.instructions.len - 1) { const last = astgen.instructions.len - 1; if (astgen.instructions.items(.tag)[last] == .dbg_stmt) { @@ -13523,14 +13523,14 @@ fn setDeclaration( .flags_0 = flags_arr[0], .flags_1 = flags_arr[1], }; - astgen.instructions.items(.data)[@intFromEnum(decl_inst)].declaration.payload_index = + astgen.instructions.items(.data)[@backingInt(decl_inst)].declaration.payload_index = astgen.addExtraAssumeCapacity(extra); if (id.hasName()) { - astgen.extra.appendAssumeCapacity(@intFromEnum(args.name)); + astgen.extra.appendAssumeCapacity(@backingInt(args.name)); } if (id.hasLibName()) { - astgen.extra.appendAssumeCapacity(@intFromEnum(args.lib_name)); + astgen.extra.appendAssumeCapacity(@backingInt(args.lib_name)); } if (id.hasTypeBody()) { astgen.extra.appendAssumeCapacity(type_len); diff --git a/lib/std/zig/ErrorBundle.zig b/lib/std/zig/ErrorBundle.zig index 4b51c9f4b99104f808d925b026e4b067559d0562..03ff0f83f22ae3184aced9a856e443f65d1273a0 100644 --- a/lib/std/zig/ErrorBundle.zig +++ b/lib/std/zig/ErrorBundle.zig @@ -107,17 +107,17 @@ pub fn getMessages(eb: ErrorBundle) []const MessageIndex { } pub fn getErrorMessage(eb: ErrorBundle, index: MessageIndex) ErrorMessage { - return eb.extraData(ErrorMessage, @intFromEnum(index)).data; + return eb.extraData(ErrorMessage, @backingInt(index)).data; } pub fn getSourceLocation(eb: ErrorBundle, index: SourceLocationIndex) SourceLocation { assert(index != .none); - return eb.extraData(SourceLocation, @intFromEnum(index)).data; + return eb.extraData(SourceLocation, @backingInt(index)).data; } pub fn getNotes(eb: ErrorBundle, index: MessageIndex) []const MessageIndex { const notes_len = eb.getErrorMessage(index).notes_len; - const start = @intFromEnum(index) + @typeInfo(ErrorMessage).@"struct".field_names.len; + const start = @backingInt(index) + @typeInfo(ErrorMessage).@"struct".field_names.len; return @as([]const MessageIndex, @ptrCast(eb.extra[start..][0..notes_len])); } @@ -135,8 +135,8 @@ fn extraData(eb: ErrorBundle, comptime T: type, index: usize) struct { data: T, inline for (field_names, field_types) |field_name, field_type| { @field(result, field_name) = switch (field_type) { u32 => eb.extra[i], - MessageIndex => @as(MessageIndex, @enumFromInt(eb.extra[i])), - SourceLocationIndex => @as(SourceLocationIndex, @enumFromInt(eb.extra[i])), + MessageIndex => @as(MessageIndex, @fromBackingInt(@intCast(eb.extra[i]))), + SourceLocationIndex => @as(SourceLocationIndex, @fromBackingInt(@intCast(eb.extra[i]))), else => @compileError("bad field type"), }; i += 1; @@ -209,7 +209,7 @@ fn renderErrorMessage( const w = t.writer; const err_msg = eb.getErrorMessage(err_msg_index); if (err_msg.src_loc != .none) { - const src = eb.extraData(SourceLocation, @intFromEnum(err_msg.src_loc)); + const src = eb.extraData(SourceLocation, @backingInt(err_msg.src_loc)); var prefix: Writer.Discarding = .init(&.{}); try w.splatByteAll(' ', indent); prefix.count += indent; @@ -445,20 +445,20 @@ pub const Wip = struct { try wip.addRootErrorMessage(msg); const notes_start = try wip.reserveNotes(@intCast(notes.len)); for (notes_start.., notes) |i, note| { - wip.extra.items[i] = @intFromEnum(wip.addErrorMessageAssumeCapacity(note)); + wip.extra.items[i] = @backingInt(wip.addErrorMessageAssumeCapacity(note)); } } pub fn addErrorMessage(wip: *Wip, em: ErrorMessage) Allocator.Error!MessageIndex { - return @enumFromInt(try addExtra(wip, em)); + return @fromBackingInt(@intCast(try addExtra(wip, em))); } pub fn addErrorMessageAssumeCapacity(wip: *Wip, em: ErrorMessage) MessageIndex { - return @enumFromInt(addExtraAssumeCapacity(wip, em)); + return @fromBackingInt(@intCast(addExtraAssumeCapacity(wip, em))); } pub fn addSourceLocation(wip: *Wip, sl: SourceLocation) Allocator.Error!SourceLocationIndex { - return @enumFromInt(try addExtra(wip, sl)); + return @fromBackingInt(@intCast(try addExtra(wip, sl))); } pub fn addReferenceTrace(wip: *Wip, rt: ReferenceTrace) Allocator.Error!void { @@ -477,7 +477,7 @@ pub const Wip = struct { const notes_start = wip.reserveNotes(@intCast(other_list.len)) catch unreachable; for (notes_start.., other_list) |note, message| { // This line can cause `wip.extra.items` to be resized. - const note_index = @intFromEnum(wip.addOtherMessage(other, message) catch unreachable); + const note_index = @backingInt(wip.addOtherMessage(other, message) catch unreachable); wip.extra.items[note] = note_index; } } @@ -512,7 +512,7 @@ pub const Wip = struct { src_path: []const u8, ) !void { const Zir = std.zig.Zir; - const payload_index = zir.extra[@intFromEnum(Zir.ExtraIndex.compile_errors)]; + const payload_index = zir.extra[@backingInt(Zir.ExtraIndex.compile_errors)]; assert(payload_index != 0); const header = zir.extraData(Zir.Inst.CompileErrors, payload_index); @@ -568,7 +568,7 @@ pub const Wip = struct { const loc = std.zig.findLineColumn(source, span.main); // This line can cause `wip.extra.items` to be resized. - const note_index = @intFromEnum(try eb.addErrorMessage(.{ + const note_index = @backingInt(try eb.addErrorMessage(.{ .msg = try eb.addString(msg), .src_loc = try eb.addSourceLocation(.{ .src_path = try eb.addString(src_path), @@ -607,7 +607,7 @@ pub const Wip = struct { const end = token_start + @as(u32, @intCast(tree.tokenSlice(token).len)); break :span .{ .start = start, .end = end, .main = start }; } else { - break :span tree.nodeToSpan(@enumFromInt(err.node_or_offset)); + break :span tree.nodeToSpan(@fromBackingInt(@intCast(err.node_or_offset))); } }; const err_loc = std.zig.findLineColumn(source, err_span.main); @@ -636,13 +636,13 @@ pub const Wip = struct { const end = token_start + @as(u32, @intCast(tree.tokenSlice(token).len)); break :span .{ .start = start, .end = end, .main = start }; } else { - break :span tree.nodeToSpan(@enumFromInt(note.node_or_offset)); + break :span tree.nodeToSpan(@fromBackingInt(@intCast(note.node_or_offset))); } }; const note_loc = std.zig.findLineColumn(source, note_span.main); // This line can cause `wip.extra.items` to be resized. - const note_index = @intFromEnum(try eb.addErrorMessage(.{ + const note_index = @backingInt(try eb.addErrorMessage(.{ .msg = try eb.addString(note.msg.get(zoir)), .src_loc = try eb.addSourceLocation(.{ .src_path = try eb.addString(src_path), @@ -674,7 +674,7 @@ pub const Wip = struct { }); const notes_start = try wip.reserveNotes(other_msg.notes_len); for (notes_start.., other.getNotes(msg_index)) |note, other_note| { - wip.extra.items[note] = @intFromEnum(try wip.addOtherMessage(other, other_note)); + wip.extra.items[note] = @backingInt(try wip.addOtherMessage(other, other_note)); } return msg; } @@ -691,7 +691,7 @@ pub const Wip = struct { defer ref_traces.deinit(wip.gpa); if (other_sl.reference_trace_len > 0) { - var ref_index = other.extraData(SourceLocation, @intFromEnum(index)).end; + var ref_index = other.extraData(SourceLocation, @backingInt(index)).end; for (0..other_sl.reference_trace_len) |_| { const other_ref_trace_ed = other.extraData(ReferenceTrace, ref_index); const other_ref_trace = other_ref_trace_ed.data; @@ -753,8 +753,8 @@ pub const Wip = struct { inline for (field_names, field_types) |field_name, field_type| { wip.extra.items[i] = switch (field_type) { u32 => @field(extra, field_name), - MessageIndex => @intFromEnum(@field(extra, field_name)), - SourceLocationIndex => @intFromEnum(@field(extra, field_name)), + MessageIndex => @backingInt(@field(extra, field_name)), + SourceLocationIndex => @backingInt(@field(extra, field_name)), else => @compileError("bad field type"), }; i += 1; @@ -811,7 +811,7 @@ pub const Wip = struct { .notes_len = 1, }); const i = try wip.reserveNotes(1); - const note_index = @intFromEnum(wip.addErrorMessageAssumeCapacity(.{ + const note_index = @backingInt(wip.addErrorMessageAssumeCapacity(.{ .msg = try wip.addString("this is a note"), .src_loc = try wip.addSourceLocation(.{ .src_path = try wip.addString("bar"), diff --git a/lib/std/zig/Parse.zig b/lib/std/zig/Parse.zig index e71bb0ea6f4b8fd6e14a638ae1e9b059c10be016..facb74a006b5389a61bcc6a089234028fa0b1128 100644 --- a/lib/std/zig/Parse.zig +++ b/lib/std/zig/Parse.zig @@ -34,15 +34,15 @@ fn tokenStart(p: *const Parse, token_index: TokenIndex) Ast.ByteOffset { } fn nodeTag(p: *const Parse, node: Node.Index) Node.Tag { - return p.nodes.items(.tag)[@intFromEnum(node)]; + return p.nodes.items(.tag)[@backingInt(node)]; } fn nodeMainToken(p: *const Parse, node: Node.Index) TokenIndex { - return p.nodes.items(.main_token)[@intFromEnum(node)]; + return p.nodes.items(.main_token)[@backingInt(node)]; } fn nodeData(p: *const Parse, node: Node.Index) Node.Data { - return p.nodes.items(.data)[@intFromEnum(node)]; + return p.nodes.items(.data)[@backingInt(node)]; } const SmallSpan = union(enum) { @@ -69,20 +69,20 @@ const Members = struct { fn listToSpan(p: *Parse, list: []const Node.Index) Allocator.Error!Node.SubRange { try p.extra_data.appendSlice(p.gpa, @ptrCast(list)); return .{ - .start = @enumFromInt(p.extra_data.items.len - list.len), - .end = @enumFromInt(p.extra_data.items.len), + .start = @fromBackingInt(@intCast(p.extra_data.items.len - list.len)), + .end = @fromBackingInt(@intCast(p.extra_data.items.len)), }; } fn addNode(p: *Parse, elem: Ast.Node) Allocator.Error!Node.Index { - const result: Node.Index = @enumFromInt(p.nodes.len); + const result: Node.Index = @fromBackingInt(@intCast(p.nodes.len)); try p.nodes.append(p.gpa, elem); return result; } fn setNode(p: *Parse, i: usize, elem: Ast.Node) Node.Index { p.nodes.set(i, elem); - return @enumFromInt(i); + return @fromBackingInt(@intCast(i)); } fn reserveNode(p: *Parse, tag: Ast.Node.Tag) !usize { @@ -105,14 +105,14 @@ fn unreserveNode(p: *Parse, node_index: usize) void { fn addExtra(p: *Parse, extra: anytype) Allocator.Error!ExtraIndex { const info = @typeInfo(@TypeOf(extra)).@"struct"; try p.extra_data.ensureUnusedCapacity(p.gpa, info.field_names.len); - const result: ExtraIndex = @enumFromInt(p.extra_data.items.len); + const result: ExtraIndex = @fromBackingInt(@intCast(p.extra_data.items.len)); inline for (info.field_names, info.field_types) |field_name, field_type| { const data: u32 = switch (field_type) { Node.Index, Node.OptionalIndex, OptionalTokenIndex, ExtraIndex, - => @intFromEnum(@field(extra, field_name)), + => @backingInt(@field(extra, field_name)), TokenIndex, => @field(extra, field_name), else => @compileError("unexpected field type"), @@ -796,9 +796,9 @@ fn parseFnProto(p: *Parse) !?Node.Index { fn setVarDeclInitExpr(p: *Parse, var_decl: Node.Index, init_expr: Node.OptionalIndex) void { const init_expr_result = switch (p.nodeTag(var_decl)) { - .simple_var_decl => &p.nodes.items(.data)[@intFromEnum(var_decl)].opt_node_and_opt_node[1], - .aligned_var_decl => &p.nodes.items(.data)[@intFromEnum(var_decl)].node_and_opt_node[1], - .local_var_decl, .global_var_decl => &p.nodes.items(.data)[@intFromEnum(var_decl)].extra_and_opt_node[1], + .simple_var_decl => &p.nodes.items(.data)[@backingInt(var_decl)].opt_node_and_opt_node[1], + .aligned_var_decl => &p.nodes.items(.data)[@backingInt(var_decl)].node_and_opt_node[1], + .local_var_decl, .global_var_decl => &p.nodes.items(.data)[@backingInt(var_decl)].extra_and_opt_node[1], else => unreachable, }; init_expr_result.* = init_expr; @@ -1114,7 +1114,7 @@ fn expectVarAssignStatement(p: *Parse, comptime_token: ?TokenIndex) !Node.Index // An actual destructure! No need for any `comptime` wrapper here. - const extra_start: ExtraIndex = @enumFromInt(p.extra_data.items.len); + const extra_start: ExtraIndex = @fromBackingInt(@intCast(p.extra_data.items.len)); try p.extra_data.ensureUnusedCapacity(p.gpa, lhs_count + 1); p.extra_data.appendAssumeCapacity(@intCast(lhs_count)); p.extra_data.appendSliceAssumeCapacity(@ptrCast(p.scratch.items[scratch_top..])); @@ -1488,7 +1488,7 @@ fn finishAssignDestructureExpr(p: *Parse, first_lhs: Node.Index) !Node.Index { const lhs_count = p.scratch.items.len - scratch_top; assert(lhs_count > 1); // we already had first_lhs, and must have at least one more lvalue - const extra_start: ExtraIndex = @enumFromInt(p.extra_data.items.len); + const extra_start: ExtraIndex = @fromBackingInt(@intCast(p.extra_data.items.len)); try p.extra_data.ensureUnusedCapacity(p.gpa, lhs_count + 1); p.extra_data.appendAssumeCapacity(@intCast(lhs_count)); p.extra_data.appendSliceAssumeCapacity(@ptrCast(p.scratch.items[scratch_top..])); @@ -1579,7 +1579,7 @@ fn parseExprPrecedence(p: *Parse, min_prec: i32) Error!?Node.Index { while (true) { const tok_tag = p.tokenTag(p.tok_i); - const info = operTable[@as(usize, @intCast(@intFromEnum(tok_tag)))]; + const info = operTable[@as(usize, @intCast(@backingInt(tok_tag)))]; if (info.prec < min_prec) { break; } diff --git a/lib/std/zig/TokenSmith.zig b/lib/std/zig/TokenSmith.zig index ce460d3228081487a9d99bf44cc2e42197929869..3f8cb2bec05dd15b564643633d484c30e8d60842 100644 --- a/lib/std/zig/TokenSmith.zig +++ b/lib/std/zig/TokenSmith.zig @@ -248,8 +248,8 @@ pub fn list(t: *TokenSmith) TokenList.Slice { .capacity = t.tags_len, }; comptime std.debug.assert(slice.ptrs.len == 2); - slice.ptrs[@intFromEnum(TokenList.Field.tag)] = @ptrCast(&t.tag_buf); - slice.ptrs[@intFromEnum(TokenList.Field.start)] = @ptrCast(&t.start_buf); + slice.ptrs[@backingInt(TokenList.Field.tag)] = @ptrCast(&t.tag_buf); + slice.ptrs[@backingInt(TokenList.Field.start)] = @ptrCast(&t.start_buf); return slice; } diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig index f118e24a216eed245c10faf6e36a16958937d83a..bce7bd281ef314870fe68528cde51d4813a41a17 100644 --- a/lib/std/zig/Zir.zig +++ b/lib/std/zig/Zir.zig @@ -84,13 +84,13 @@ pub fn extraData(code: Zir, comptime T: type, index: usize) ExtraData(T) { Ast.OptionalTokenIndex, Ast.Node.Index, Ast.Node.OptionalIndex, - => @enumFromInt(code.extra[i]), + => @fromBackingInt(@intCast(code.extra[i])), Ast.TokenOffset, Ast.OptionalTokenOffset, Ast.Node.Offset, Ast.Node.OptionalOffset, - => @enumFromInt(@as(i32, @bitCast(code.extra[i]))), + => @fromBackingInt(@intCast(@as(i32, @bitCast(code.extra[i])))), Inst.Call.Flags, Inst.BuiltinCall.Flags, @@ -118,7 +118,7 @@ pub const NullTerminatedString = enum(u32) { /// Given an index into `string_bytes` returns the null-terminated string found there. pub fn nullTerminatedString(code: Zir, index: NullTerminatedString) [:0]const u8 { - const slice = code.string_bytes[@intFromEnum(index)..]; + const slice = code.string_bytes[@backingInt(index)..]; return slice[0..std.mem.findScalar(u8, slice, 0).? :0]; } @@ -131,7 +131,7 @@ pub fn bodySlice(zir: Zir, start: usize, len: usize) []Inst.Index { } pub fn hasCompileErrors(code: Zir) bool { - if (code.extra[@intFromEnum(ExtraIndex.compile_errors)] != 0) { + if (code.extra[@backingInt(ExtraIndex.compile_errors)] != 0) { return true; } else { assert(code.instructions.len != 0); // i.e. lowering did not fail @@ -2202,11 +2202,11 @@ pub const Inst = struct { _, pub fn toRef(i: Index) Inst.Ref { - return @enumFromInt(Ref.static_len + @intFromEnum(i)); + return @fromBackingInt(@intCast(Ref.static_len + @backingInt(i))); } pub fn toOptional(i: Index) OptionalIndex { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } }; @@ -2218,7 +2218,7 @@ pub const Inst = struct { _, pub fn unwrap(oi: OptionalIndex) ?Index { - return if (oi == .none) null else @enumFromInt(@intFromEnum(oi)); + return if (oi == .none) null else @fromBackingInt(@intCast(@backingInt(oi))); } }; @@ -2370,9 +2370,9 @@ pub const Inst = struct { pub fn toIndex(inst: Ref) ?Index { assert(inst != .none); - const ref_int = @intFromEnum(inst); + const ref_int = @backingInt(inst); if (ref_int >= static_len) { - return @enumFromInt(ref_int - static_len); + return @fromBackingInt(@intCast(ref_int - static_len)); } else { return null; } @@ -2429,7 +2429,7 @@ pub const Inst = struct { len: u32, pub fn get(self: @This(), code: Zir) []const u8 { - return code.string_bytes[@intFromEnum(self.start)..][0..self.len]; + return code.string_bytes[@backingInt(self.start)..][0..self.len]; } }, str_tok: struct { @@ -3009,7 +3009,7 @@ pub const Inst = struct { pub fn isNamedTest(name: Name, zir: Zir) bool { return switch (name) { .@"comptime", .unnamed_test => false, - _ => zir.string_bytes[@intFromEnum(name)] == 0, + _ => zir.string_bytes[@backingInt(name)] == 0, }; } pub fn toString(name: Name, zir: Zir) ?NullTerminatedString { @@ -3017,12 +3017,12 @@ pub const Inst = struct { .@"comptime", .unnamed_test => return null, _ => {}, } - const idx: u32 = @intFromEnum(name); + const idx: u32 = @backingInt(name); if (zir.string_bytes[idx] == 0) { // Named test - return @enumFromInt(idx + 1); + return @fromBackingInt(@intCast(idx + 1)); } - return @enumFromInt(idx); + return @fromBackingInt(@intCast(idx)); } }; @@ -3441,8 +3441,8 @@ pub const Inst = struct { pub fn wrap(unwrapped: ItemInfo.Unwrapped) ItemInfo { const data_uncasted: u32 = switch (unwrapped) { - .enum_literal => |str_index| @intFromEnum(str_index), - .error_value => |str_index| @intFromEnum(str_index), + .enum_literal => |str_index| @backingInt(str_index), + .error_value => |str_index| @backingInt(str_index), .body_len => |body_len| body_len, .under => 0, }; @@ -3451,8 +3451,8 @@ pub const Inst = struct { pub fn unwrap(item_info: ItemInfo) ItemInfo.Unwrapped { return switch (item_info.kind) { - .enum_literal => .{ .enum_literal = @enumFromInt(item_info.data) }, - .error_value => .{ .error_value = @enumFromInt(item_info.data) }, + .enum_literal => .{ .enum_literal = @fromBackingInt(@intCast(item_info.data)) }, + .error_value => .{ .error_value = @fromBackingInt(@intCast(item_info.data)) }, .body_len => .{ .body_len = item_info.data }, .under => .under, }; @@ -3557,29 +3557,29 @@ pub const Inst = struct { }, .instruction => |inst| .{ .tag = .instruction, - .data = @intCast(@intFromEnum(inst)), + .data = @intCast(@backingInt(inst)), }, .instruction_load => |inst| .{ .tag = .instruction_load, - .data = @intCast(@intFromEnum(inst)), + .data = @intCast(@backingInt(inst)), }, .decl_val => |str| .{ .tag = .decl_val, - .data = @intCast(@intFromEnum(str)), + .data = @intCast(@backingInt(str)), }, .decl_ref => |str| .{ .tag = .decl_ref, - .data = @intCast(@intFromEnum(str)), + .data = @intCast(@backingInt(str)), }, }; } pub fn unwrap(cap: Capture) Unwrapped { return switch (cap.tag) { .nested => .{ .nested = @intCast(cap.data) }, - .instruction => .{ .instruction = @enumFromInt(cap.data) }, - .instruction_load => .{ .instruction_load = @enumFromInt(cap.data) }, - .decl_val => .{ .decl_val = @enumFromInt(cap.data) }, - .decl_ref => .{ .decl_ref = @enumFromInt(cap.data) }, + .instruction => .{ .instruction = @fromBackingInt(@intCast(cap.data)) }, + .instruction_load => .{ .instruction_load = @fromBackingInt(@intCast(cap.data)) }, + .decl_val => .{ .decl_val = @fromBackingInt(@intCast(cap.data)) }, + .decl_ref => .{ .decl_ref = @fromBackingInt(@intCast(cap.data)) }, }; } }; @@ -4084,8 +4084,8 @@ pub fn findTrackableFields( var found_defers: std.AutoHashMapUnmanaged(u32, void) = .empty; defer found_defers.deinit(gpa); - assert(zir.instructions.items(.tag)[@intFromEnum(type_decl_inst)] == .extended); - switch (zir.instructions.items(.data)[@intFromEnum(type_decl_inst)].extended.opcode) { + assert(zir.instructions.items(.tag)[@backingInt(type_decl_inst)] == .extended); + switch (zir.instructions.items(.data)[@backingInt(type_decl_inst)].extended.opcode) { .struct_decl => { const struct_decl = zir.getStructDecl(type_decl_inst); var it = struct_decl.iterateFields(); @@ -4128,7 +4128,7 @@ fn findTrackableInner( const tags = zir.instructions.items(.tag); const datas = zir.instructions.items(.data); - switch (tags[@intFromEnum(inst)]) { + switch (tags[@backingInt(inst)]) { .declaration => unreachable, // Boring instruction tags first. These have no body and are not declarations or type declarations. @@ -4369,7 +4369,7 @@ fn findTrackableInner( => return contents.other.append(gpa, inst), .extended => { - const extended = datas[@intFromEnum(inst)].extended; + const extended = datas[@backingInt(inst)].extended; switch (extended.opcode) { .value_placeholder => unreachable, @@ -4460,7 +4460,7 @@ fn findTrackableInner( .func, .func_inferred, => { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.Func, inst_data.payload_index); if (extra.data.body_len == 0) { @@ -4486,7 +4486,7 @@ fn findTrackableInner( return zir.findTrackableBody(gpa, contents, defers, body); }, .func_fancy => { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index); if (extra.data.body_len == 0) { @@ -4534,19 +4534,19 @@ fn findTrackableInner( .typeof_builtin, .loop, => { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.Block, inst_data.payload_index); const body = zir.bodySlice(extra.end, extra.data.body_len); return zir.findTrackableBody(gpa, contents, defers, body); }, .block_comptime => { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.BlockComptime, inst_data.payload_index); const body = zir.bodySlice(extra.end, extra.data.body_len); return zir.findTrackableBody(gpa, contents, defers, body); }, .condbr, .condbr_inline => { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.CondBr, inst_data.payload_index); const then_body = zir.bodySlice(extra.end, extra.data.then_body_len); const else_body = zir.bodySlice(extra.end + then_body.len, extra.data.else_body_len); @@ -4554,7 +4554,7 @@ fn findTrackableInner( try zir.findTrackableBody(gpa, contents, defers, else_body); }, .@"try", .try_ptr => { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.Try, inst_data.payload_index); const body = zir.bodySlice(extra.end, extra.data.body_len); try zir.findTrackableBody(gpa, contents, defers, body); @@ -4602,14 +4602,14 @@ fn findTrackableInner( .suspend_block => @panic("TODO iterate suspend block"), .param, .param_comptime => { - const inst_data = datas[@intFromEnum(inst)].pl_tok; + const inst_data = datas[@backingInt(inst)].pl_tok; const extra = zir.extraData(Inst.Param, inst_data.payload_index); const body = zir.bodySlice(extra.end, extra.data.type.body_len); try zir.findTrackableBody(gpa, contents, defers, body); }, inline .call, .field_call => |tag| { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = zir.extraData(switch (tag) { .call => Inst.Call, .field_call => Inst.FieldCall, @@ -4625,7 +4625,7 @@ fn findTrackableInner( } }, .@"defer" => { - const inst_data = datas[@intFromEnum(inst)].@"defer"; + const inst_data = datas[@backingInt(inst)].@"defer"; const gop = try defers.getOrPut(gpa, inst_data.index); if (!gop.found_existing) { const body = zir.bodySlice(inst_data.index, inst_data.len); @@ -4661,9 +4661,9 @@ pub const FnInfo = struct { pub fn getParamBody(zir: Zir, fn_inst: Inst.Index) []const Zir.Inst.Index { const tags = zir.instructions.items(.tag); const datas = zir.instructions.items(.data); - const inst_data = datas[@intFromEnum(fn_inst)].pl_node; + const inst_data = datas[@backingInt(fn_inst)].pl_node; - const param_block_index = switch (tags[@intFromEnum(fn_inst)]) { + const param_block_index = switch (tags[@backingInt(fn_inst)]) { .func, .func_inferred => blk: { const extra = zir.extraData(Inst.Func, inst_data.payload_index); break :blk extra.data.param_block; @@ -4675,9 +4675,9 @@ pub fn getParamBody(zir: Zir, fn_inst: Inst.Index) []const Zir.Inst.Index { else => unreachable, }; - switch (tags[@intFromEnum(param_block_index)]) { + switch (tags[@backingInt(param_block_index)]) { .block, .block_comptime, .block_inline => { - const param_block = zir.extraData(Inst.Block, datas[@intFromEnum(param_block_index)].pl_node.payload_index); + const param_block = zir.extraData(Inst.Block, datas[@backingInt(param_block_index)].pl_node.payload_index); return zir.bodySlice(param_block.end, param_block.data.body_len); }, .declaration => { @@ -4688,7 +4688,7 @@ pub fn getParamBody(zir: Zir, fn_inst: Inst.Index) []const Zir.Inst.Index { } pub fn getParamName(zir: Zir, param_inst: Inst.Index) ?NullTerminatedString { - const inst = zir.instructions.get(@intFromEnum(param_inst)); + const inst = zir.instructions.get(@backingInt(param_inst)); return switch (inst.tag) { .param, .param_comptime => zir.extraData(Inst.Param, inst.data.pl_tok.payload_index).data.name, .param_anytype, .param_anytype_comptime => inst.data.str_tok.start, @@ -4706,9 +4706,9 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo { ret_ty_body: []const Inst.Index, ret_ty_is_generic: bool, ies: bool, - } = switch (tags[@intFromEnum(fn_inst)]) { + } = switch (tags[@backingInt(fn_inst)]) { .func, .func_inferred => |tag| blk: { - const inst_data = datas[@intFromEnum(fn_inst)].pl_node; + const inst_data = datas[@backingInt(fn_inst)].pl_node; const extra = zir.extraData(Inst.Func, inst_data.payload_index); var extra_index: usize = extra.end; @@ -4720,7 +4720,7 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo { ret_ty_ref = .void_type; }, 1 => { - ret_ty_ref = @enumFromInt(zir.extra[extra_index]); + ret_ty_ref = @fromBackingInt(@intCast(zir.extra[extra_index])); extra_index += 1; }, else => { @@ -4742,7 +4742,7 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo { }; }, .func_fancy => blk: { - const inst_data = datas[@intFromEnum(fn_inst)].pl_node; + const inst_data = datas[@backingInt(fn_inst)].pl_node; const extra = zir.extraData(Inst.FuncFancy, inst_data.payload_index); var extra_index: usize = extra.end; @@ -4760,7 +4760,7 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo { ret_ty_body = zir.bodySlice(extra_index, body_len); extra_index += ret_ty_body.len; } else if (extra.data.bits.has_ret_ty_ref) { - ret_ty_ref = @enumFromInt(zir.extra[extra_index]); + ret_ty_ref = @fromBackingInt(@intCast(zir.extra[extra_index])); extra_index += 1; } else { ret_ty_ref = .void_type; @@ -4784,7 +4784,7 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo { const param_body = zir.getParamBody(fn_inst); var total_params_len: u32 = 0; for (param_body) |inst| { - switch (tags[@intFromEnum(inst)]) { + switch (tags[@backingInt(inst)]) { .param, .param_comptime, .param_anytype, .param_anytype_comptime => { total_params_len += 1; }, @@ -4804,8 +4804,8 @@ pub fn getFnInfo(zir: Zir, fn_inst: Inst.Index) FnInfo { } pub fn getDeclaration(zir: Zir, inst: Zir.Inst.Index) Inst.Declaration.Unwrapped { - assert(zir.instructions.items(.tag)[@intFromEnum(inst)] == .declaration); - const pl_node = zir.instructions.items(.data)[@intFromEnum(inst)].declaration; + assert(zir.instructions.items(.tag)[@backingInt(inst)] == .declaration); + const pl_node = zir.instructions.items(.data)[@backingInt(inst)].declaration; const extra = zir.extraData(Inst.Declaration, pl_node.payload_index); const flags_vals: [2]u32 = .{ extra.data.flags_0, extra.data.flags_1 }; @@ -4816,13 +4816,13 @@ pub fn getDeclaration(zir: Zir, inst: Zir.Inst.Index) Inst.Declaration.Unwrapped const name: NullTerminatedString = if (flags.id.hasName()) name: { const name = zir.extra[extra_index]; extra_index += 1; - break :name @enumFromInt(name); + break :name @fromBackingInt(@intCast(name)); } else .empty; const lib_name: NullTerminatedString = if (flags.id.hasLibName()) lib_name: { const lib_name = zir.extra[extra_index]; extra_index += 1; - break :lib_name @enumFromInt(lib_name); + break :lib_name @fromBackingInt(@intCast(lib_name)); } else .empty; const type_body_len: u32 = if (flags.id.hasTypeBody()) len: { @@ -4877,9 +4877,9 @@ pub fn getDeclaration(zir: Zir, inst: Zir.Inst.Index) Inst.Declaration.Unwrapped pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash { const tag = zir.instructions.items(.tag); const data = zir.instructions.items(.data); - switch (tag[@intFromEnum(inst)]) { + switch (tag[@backingInt(inst)]) { .declaration => { - const declaration = data[@intFromEnum(inst)].declaration; + const declaration = data[@backingInt(inst)].declaration; const extra = zir.extraData(Inst.Declaration, declaration.payload_index); return @bitCast([4]u32{ extra.data.src_hash_0, @@ -4889,7 +4889,7 @@ pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash { }); }, .func, .func_inferred => { - const pl_node = data[@intFromEnum(inst)].pl_node; + const pl_node = data[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.Func, pl_node.payload_index); if (extra.data.body_len == 0) { // Function type or extern fn - no associated hash @@ -4907,7 +4907,7 @@ pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash { }); }, .func_fancy => { - const pl_node = data[@intFromEnum(inst)].pl_node; + const pl_node = data[@backingInt(inst)].pl_node; const extra = zir.extraData(Inst.FuncFancy, pl_node.payload_index); if (extra.data.body_len == 0) { // Function type or extern fn - no associated hash @@ -4936,7 +4936,7 @@ pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash { .extended => {}, else => return null, } - const extended = data[@intFromEnum(inst)].extended; + const extended = data[@backingInt(inst)].extended; switch (extended.opcode) { .struct_decl => { const extra = zir.extraData(Inst.StructDecl, extended.operand).data; @@ -4970,12 +4970,12 @@ pub fn getAssociatedSrcHash(zir: Zir, inst: Zir.Inst.Index) ?std.zig.SrcHash { } pub fn getSwitchBlock(zir: *const Zir, switch_inst: Inst.Index) UnwrappedSwitchBlock { - const has_non_err = switch (zir.instructions.items(.tag)[@intFromEnum(switch_inst)]) { + const has_non_err = switch (zir.instructions.items(.tag)[@backingInt(switch_inst)]) { .switch_block, .switch_block_ref => false, .switch_block_err_union => true, else => unreachable, }; - const inst_data = zir.instructions.items(.data)[@intFromEnum(switch_inst)].pl_node; + const inst_data = zir.instructions.items(.data)[@backingInt(switch_inst)].pl_node; const extra = zir.extraData(Inst.SwitchBlock, inst_data.payload_index); const bits = extra.data.bits; var extra_index = extra.end; @@ -4985,17 +4985,17 @@ pub fn getSwitchBlock(zir: *const Zir, switch_inst: Inst.Index) UnwrappedSwitchB break :len multi_cases_len; } else 0; const payload_capture_placeholder: Inst.OptionalIndex = if (bits.payload_capture_inst_is_placeholder) inst: { - const inst: Inst.Index = @enumFromInt(zir.extra[extra_index]); + const inst: Inst.Index = @fromBackingInt(@intCast(zir.extra[extra_index])); extra_index += 1; break :inst inst.toOptional(); } else .none; const tag_capture_placeholder: Inst.OptionalIndex = if (bits.tag_capture_inst_is_placeholder) inst: { - const inst: Inst.Index = @enumFromInt(zir.extra[extra_index]); + const inst: Inst.Index = @fromBackingInt(@intCast(zir.extra[extra_index])); extra_index += 1; break :inst inst.toOptional(); } else .none; const catch_or_if_src_node_offset: Ast.Node.OptionalOffset = if (has_non_err) node_offset: { - const node_offset: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(zir.extra[extra_index]))); + const node_offset: Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(zir.extra[extra_index])))); extra_index += 1; break :node_offset node_offset.toOptional(); } else .none; @@ -5212,7 +5212,7 @@ pub const inst_tracking_version = 0; /// thus may be given an `InternPool.TrackedInst`. pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void { comptime assert(Zir.inst_tracking_version == 0); - const inst = zir.instructions.get(@intFromEnum(inst_idx)); + const inst = zir.instructions.get(@backingInt(inst_idx)); switch (inst.tag) { .struct_init, .struct_init_ref, @@ -5246,7 +5246,7 @@ pub fn assertTrackable(zir: Zir, inst_idx: Zir.Inst.Index) void { } pub fn typeDecls(zir: Zir, type_decl: Inst.Index) []const Zir.Inst.Index { - const inst = zir.instructions.get(@intFromEnum(type_decl)); + const inst = zir.instructions.get(@backingInt(type_decl)); assert(inst.tag == .extended); return switch (inst.data.extended.opcode) { .struct_decl => zir.getStructDecl(type_decl).decls, @@ -5258,7 +5258,7 @@ pub fn typeDecls(zir: Zir, type_decl: Inst.Index) []const Zir.Inst.Index { } pub fn getStructDecl(zir: *const Zir, struct_decl: Inst.Index) UnwrappedStructDecl { - const inst_data = zir.instructions.get(@intFromEnum(struct_decl)); + const inst_data = zir.instructions.get(@backingInt(struct_decl)); assert(inst_data.tag == .extended); assert(inst_data.data.extended.opcode == .struct_decl); const small: Inst.StructDecl.Small = @bitCast(inst_data.data.extended.small); @@ -5409,7 +5409,7 @@ pub const UnwrappedStructDecl = struct { }; pub fn getUnionDecl(zir: *const Zir, union_decl: Inst.Index) UnwrappedUnionDecl { - const inst_data = zir.instructions.get(@intFromEnum(union_decl)); + const inst_data = zir.instructions.get(@backingInt(union_decl)); assert(inst_data.tag == .extended); assert(inst_data.data.extended.opcode == .union_decl); const small: Inst.UnionDecl.Small = @bitCast(inst_data.data.extended.small); @@ -5543,7 +5543,7 @@ pub const UnwrappedUnionDecl = struct { }; pub fn getEnumDecl(zir: *const Zir, enum_decl: Inst.Index) UnwrappedEnumDecl { - const inst_data = zir.instructions.get(@intFromEnum(enum_decl)); + const inst_data = zir.instructions.get(@backingInt(enum_decl)); assert(inst_data.tag == .extended); assert(inst_data.data.extended.opcode == .enum_decl); const small: Inst.EnumDecl.Small = @bitCast(inst_data.data.extended.small); @@ -5658,7 +5658,7 @@ pub const UnwrappedEnumDecl = struct { }; pub fn getOpaqueDecl(zir: *const Zir, opaque_decl: Inst.Index) UnwrappedOpaqueDecl { - const inst_data = zir.instructions.get(@intFromEnum(opaque_decl)); + const inst_data = zir.instructions.get(@backingInt(opaque_decl)); assert(inst_data.tag == .extended); assert(inst_data.data.extended.opcode == .opaque_decl); const small: Inst.OpaqueDecl.Small = @bitCast(inst_data.data.extended.small); diff --git a/lib/std/zig/Zoir.zig b/lib/std/zig/Zoir.zig index d82b8f1861f3e8b645e79651f55aea3da3d8ccce..d29315aa5cb91ab12167ee39a3022f87505cda11 100644 --- a/lib/std/zig/Zoir.zig +++ b/lib/std/zig/Zoir.zig @@ -106,7 +106,7 @@ pub const Node = union(enum) { _, pub fn get(idx: Index, zoir: Zoir) Node { - const repr = zoir.nodes.get(@intFromEnum(idx)); + const repr = zoir.nodes.get(@backingInt(idx)); return switch (repr.tag) { .true => .true, .false => .false, @@ -129,30 +129,30 @@ pub const Node = union(enum) { .float_literal_small => .{ .float_literal = @as(f32, @bitCast(repr.data)) }, .float_literal => .{ .float_literal = @bitCast(zoir.extra[repr.data..][0..4].*) }, .char_literal => .{ .char_literal = @intCast(repr.data) }, - .enum_literal => .{ .enum_literal = @enumFromInt(repr.data) }, + .enum_literal => .{ .enum_literal = @fromBackingInt(@intCast(repr.data)) }, .string_literal => .{ .string_literal = s: { const start, const len = zoir.extra[repr.data..][0..2].*; break :s zoir.string_bytes[start..][0..len]; } }, - .string_literal_null => .{ .string_literal = NullTerminatedString.get(@enumFromInt(repr.data), zoir) }, + .string_literal_null => .{ .string_literal = NullTerminatedString.get(@fromBackingInt(@intCast(repr.data)), zoir) }, .empty_literal => .empty_literal, .array_literal => .{ .array_literal = a: { const elem_count, const first_elem = zoir.extra[repr.data..][0..2].*; - break :a .{ .start = @enumFromInt(first_elem), .len = elem_count }; + break :a .{ .start = @fromBackingInt(@intCast(first_elem)), .len = elem_count }; } }, .struct_literal => .{ .struct_literal = s: { const elem_count, const first_elem = zoir.extra[repr.data..][0..2].*; const field_names = zoir.extra[repr.data + 2 ..][0..elem_count]; break :s .{ .names = @ptrCast(field_names), - .vals = .{ .start = @enumFromInt(first_elem), .len = elem_count }, + .vals = .{ .start = @fromBackingInt(@intCast(first_elem)), .len = elem_count }, }; } }, }; } pub fn getAstNode(idx: Index, zoir: Zoir) std.zig.Ast.Node.Index { - return zoir.nodes.items(.ast_node)[@intFromEnum(idx)]; + return zoir.nodes.items(.ast_node)[@backingInt(idx)]; } pub const Range = struct { @@ -161,7 +161,7 @@ pub const Node = union(enum) { pub fn at(r: Range, i: u32) Index { assert(i < r.len); - return @enumFromInt(@intFromEnum(r.start) + i); + return @fromBackingInt(@intCast(@backingInt(r.start) + i)); } }; }; @@ -228,8 +228,8 @@ pub const Node = union(enum) { pub const NullTerminatedString = enum(u32) { _, pub fn get(nts: NullTerminatedString, zoir: Zoir) [:0]const u8 { - const idx = std.mem.findScalar(u8, zoir.string_bytes[@intFromEnum(nts)..], 0).?; - return zoir.string_bytes[@intFromEnum(nts)..][0..idx :0]; + const idx = std.mem.findScalar(u8, zoir.string_bytes[@backingInt(nts)..], 0).?; + return zoir.string_bytes[@backingInt(nts)..][0..idx :0]; } }; diff --git a/lib/std/zig/ZonGen.zig b/lib/std/zig/ZonGen.zig index 2360570f523b0044591945753369ed16ceb5c45f..97ab7c5ab707b537246eae1d2ea714bbc1ae21b7 100644 --- a/lib/std/zig/ZonGen.zig +++ b/lib/std/zig/ZonGen.zig @@ -327,14 +327,14 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator }; zg.setNode(dest_node, .{ .tag = .enum_literal, - .data = @intFromEnum(str_index), + .data = @backingInt(str_index), .ast_node = node, }); }, .string_literal, .multiline_string_literal => if (zg.strLitAsString(node)) |result| switch (result) { .nts => |nts| zg.setNode(dest_node, .{ .tag = .string_literal_null, - .data = @intFromEnum(nts), + .data = @backingInt(nts), .ast_node = node, }), .slice => |slice| { @@ -377,7 +377,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator }); for (full.ast.elements, first_elem..) |elem_node, elem_dest_node| { - try zg.expr(elem_node, @enumFromInt(elem_dest_node)); + try zg.expr(elem_node, @fromBackingInt(@intCast(elem_dest_node))); } }, @@ -429,7 +429,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator for (full.ast.fields, names_start.., first_elem..) |elem_node, extra_name_idx, elem_dest_node| { const name_token = tree.firstToken(elem_node) - 2; if (zg.identAsString(name_token)) |name_str| { - zg.extra.items[extra_name_idx] = @intFromEnum(name_str); + zg.extra.items[extra_name_idx] = @backingInt(name_str); const gop = try field_names.getOrPut(bfa, name_str); if (gop.found_existing and !reported_any_duplicate) { reported_any_duplicate = true; @@ -443,7 +443,7 @@ fn expr(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) Allocator error.BadString => {}, // there's an error, so it's fine to not populate `zg.extra` error.OutOfMemory => |e| return e, } - try zg.expr(elem_node, @enumFromInt(elem_dest_node)); + try zg.expr(elem_node, @fromBackingInt(@intCast(elem_dest_node))); } }, } @@ -590,11 +590,11 @@ fn strLitAsString(zg: *ZonGen, str_node: Ast.Node.Index) error{ OutOfMemory, Bad ); if (gop.found_existing) { string_bytes.shrinkRetainingCapacity(str_index); - return .{ .nts = @enumFromInt(gop.key_ptr.*) }; + return .{ .nts = @fromBackingInt(@intCast(gop.key_ptr.*)) }; } gop.key_ptr.* = str_index; try string_bytes.append(gpa, 0); - return .{ .nts = @enumFromInt(str_index) }; + return .{ .nts = @fromBackingInt(@intCast(str_index)) }; } fn identAsString(zg: *ZonGen, ident_token: Ast.TokenIndex) !Zoir.NullTerminatedString { @@ -610,11 +610,11 @@ fn identAsString(zg: *ZonGen, ident_token: Ast.TokenIndex) !Zoir.NullTerminatedS ); if (gop.found_existing) { string_bytes.shrinkRetainingCapacity(str_index); - return @enumFromInt(gop.key_ptr.*); + return @fromBackingInt(@intCast(gop.key_ptr.*)); } gop.key_ptr.* = str_index; try string_bytes.append(gpa, 0); - return @enumFromInt(str_index); + return @fromBackingInt(@intCast(str_index)); } fn numberLiteral(zg: *ZonGen, num_node: Ast.Node.Index, src_node: Ast.Node.Index, dest_node: Zoir.Node.Index, sign: enum { negative, positive }) !void { @@ -656,7 +656,7 @@ fn numberLiteral(zg: *ZonGen, num_node: Ast.Node.Index, src_node: Ast.Node.Index }; var big_int: std.math.big.int.Managed = try .init(gpa); defer big_int.deinit(); - big_int.setString(@intFromEnum(base), num_without_prefix) catch |err| switch (err) { + big_int.setString(@backingInt(base), num_without_prefix) catch |err| switch (err) { error.InvalidCharacter => unreachable, // caught in `parseNumberLiteral` error.InvalidBase => unreachable, // we only pass 16, 8, 2, see above error.OutOfMemory => |e| return e, @@ -763,7 +763,7 @@ fn identifier(zg: *ZonGen, node: Ast.Node.Index, dest_node: Zoir.Node.Index) !vo } fn setNode(zg: *ZonGen, dest: Zoir.Node.Index, repr: Zoir.Node.Repr) void { - zg.nodes.set(@intFromEnum(dest), repr); + zg.nodes.set(@backingInt(dest), repr); } fn lowerStrLitError( @@ -812,9 +812,9 @@ fn errNoteNode(zg: *ZonGen, node: Ast.Node.Index, comptime format: []const u8, a const message_idx: u32 = @intCast(zg.string_bytes.items.len); try zg.string_bytes.print(zg.gpa, format ++ "\x00", args); return .{ - .msg = @enumFromInt(message_idx), + .msg = @fromBackingInt(@intCast(message_idx)), .token = .none, - .node_or_offset = @intFromEnum(node), + .node_or_offset = @backingInt(node), }; } @@ -822,20 +822,20 @@ fn errNoteTok(zg: *ZonGen, tok: Ast.TokenIndex, comptime format: []const u8, arg const message_idx: u32 = @intCast(zg.string_bytes.items.len); try zg.string_bytes.print(zg.gpa, format ++ "\x00", args); return .{ - .msg = @enumFromInt(message_idx), + .msg = @fromBackingInt(@intCast(message_idx)), .token = .fromToken(tok), .node_or_offset = 0, }; } fn addErrorNode(zg: *ZonGen, node: Ast.Node.Index, comptime format: []const u8, args: anytype) Allocator.Error!void { - return zg.addErrorInner(.none, @intFromEnum(node), format, args, &.{}); + return zg.addErrorInner(.none, @backingInt(node), format, args, &.{}); } fn addErrorTok(zg: *ZonGen, tok: Ast.TokenIndex, comptime format: []const u8, args: anytype) Allocator.Error!void { return zg.addErrorInner(.fromToken(tok), 0, format, args, &.{}); } fn addErrorNodeNotes(zg: *ZonGen, node: Ast.Node.Index, comptime format: []const u8, args: anytype, notes: []const Zoir.CompileError.Note) Allocator.Error!void { - return zg.addErrorInner(.none, @intFromEnum(node), format, args, notes); + return zg.addErrorInner(.none, @backingInt(node), format, args, notes); } fn addErrorTokNotes(zg: *ZonGen, tok: Ast.TokenIndex, comptime format: []const u8, args: anytype, notes: []const Zoir.CompileError.Note) Allocator.Error!void { return zg.addErrorInner(.fromToken(tok), 0, format, args, notes); @@ -864,7 +864,7 @@ fn addErrorInner( try zg.string_bytes.print(gpa, format ++ "\x00", args); try zg.compile_errors.append(gpa, .{ - .msg = @enumFromInt(message_idx), + .msg = @fromBackingInt(@intCast(message_idx)), .token = token, .node_or_offset = node_or_offset, .first_note = first_note, diff --git a/lib/std/zig/llvm/BitcodeReader.zig b/lib/std/zig/llvm/BitcodeReader.zig index 3ed1e0e9286317f1104e3588d4da56e2f019fe89..f32a85e01e36dd7176871fdac0fef32ee2d5a8e7 100644 --- a/lib/std/zig/llvm/BitcodeReader.zig +++ b/lib/std/zig/llvm/BitcodeReader.zig @@ -70,23 +70,23 @@ pub const Record = struct { try operands.append(.{ .literal = record.operands[i + 1] }); i += 2; }, - @intFromEnum(Abbrev.Operand.Encoding.fixed) => { + @backingInt(Abbrev.Operand.Encoding.fixed) => { try operands.append(.{ .encoding = .{ .fixed = @intCast(record.operands[i + 1]) } }); i += 2; }, - @intFromEnum(Abbrev.Operand.Encoding.vbr) => { + @backingInt(Abbrev.Operand.Encoding.vbr) => { try operands.append(.{ .encoding = .{ .vbr = @intCast(record.operands[i + 1]) } }); i += 2; }, - @intFromEnum(Abbrev.Operand.Encoding.array) => { + @backingInt(Abbrev.Operand.Encoding.array) => { try operands.append(.{ .encoding = .{ .array = 6 } }); i += 1; }, - @intFromEnum(Abbrev.Operand.Encoding.char6) => { + @backingInt(Abbrev.Operand.Encoding.char6) => { try operands.append(.{ .encoding = .char6 }); i += 1; }, - @intFromEnum(Abbrev.Operand.Encoding.blob) => { + @backingInt(Abbrev.Operand.Encoding.blob) => { try operands.append(.{ .encoding = .{ .blob = 6 } }); i += 1; }, @@ -225,8 +225,8 @@ fn nextRecord(bc: *BitcodeReader) !?Record { }), 0 => { const encoding: Abbrev.Operand.Encoding = - @enumFromInt(try bc.readFixed(u3, 3)); - try operands.append(@intFromEnum(encoding)); + @fromBackingInt(@intCast(try bc.readFixed(u3, 3))); + try operands.append(@backingInt(encoding)); switch (encoding) { .fixed, .vbr => try operands.append(try bc.readVbr(u7, 5)), .array, .char6, .blob => {}, @@ -285,14 +285,14 @@ fn startBlock(bc: *BitcodeReader, block_id: ?u32, new_abbrev_len: u6) !void { @typeInfo(Abbrev.Builtin).@"enum".field_names.len + abbrevs.len, ); - assert(state.abbrevs.abbrevs.items.len == @intFromEnum(Abbrev.Builtin.end_block)); + assert(state.abbrevs.abbrevs.items.len == @backingInt(Abbrev.Builtin.end_block)); try state.abbrevs.addAbbrevAssumeCapacity(bc.allocator, .{ .operands = &.{ .{ .literal = Abbrev.Builtin.end_block.toRecordId() }, .align_32_bits, }, }); - assert(state.abbrevs.abbrevs.items.len == @intFromEnum(Abbrev.Builtin.enter_subblock)); + assert(state.abbrevs.abbrevs.items.len == @backingInt(Abbrev.Builtin.enter_subblock)); try state.abbrevs.addAbbrevAssumeCapacity(bc.allocator, .{ .operands = &.{ .{ .literal = Abbrev.Builtin.enter_subblock.toRecordId() }, @@ -302,7 +302,7 @@ fn startBlock(bc: *BitcodeReader, block_id: ?u32, new_abbrev_len: u6) !void { .block_len, }, }); - assert(state.abbrevs.abbrevs.items.len == @intFromEnum(Abbrev.Builtin.define_abbrev)); + assert(state.abbrevs.abbrevs.items.len == @backingInt(Abbrev.Builtin.define_abbrev)); try state.abbrevs.addAbbrevAssumeCapacity(bc.allocator, .{ .operands = &.{ .{ .literal = Abbrev.Builtin.define_abbrev.toRecordId() }, @@ -310,7 +310,7 @@ fn startBlock(bc: *BitcodeReader, block_id: ?u32, new_abbrev_len: u6) !void { .abbrev_op, }, }); - assert(state.abbrevs.abbrevs.items.len == @intFromEnum(Abbrev.Builtin.unabbrev_record)); + assert(state.abbrevs.abbrevs.items.len == @backingInt(Abbrev.Builtin.unabbrev_record)); try state.abbrevs.addAbbrevAssumeCapacity(bc.allocator, .{ .operands = &.{ .{ .encoding = .{ .vbr = 6 } }, // code @@ -459,7 +459,7 @@ const Abbrev = struct { const first_record_id: u32 = std.math.maxInt(u32) - @typeInfo(Builtin).@"enum".field_names.len + 1; fn toRecordId(builtin: Builtin) u32 { - return first_record_id + @intFromEnum(builtin); + return first_record_id + @backingInt(builtin); } }; diff --git a/lib/std/zig/llvm/Builder.zig b/lib/std/zig/llvm/Builder.zig index f780e28f5c4d897d8a920c890c38933ea8f0ee85..38c6a53cdd13c50fe4e6a0a172649647a94bfb3b 100644 --- a/lib/std/zig/llvm/Builder.zig +++ b/lib/std/zig/llvm/Builder.zig @@ -112,7 +112,7 @@ pub const String = enum(u32) { fn format(data: FormatData, w: *Writer) Writer.Error!void { assert(data.string != .none); const string_slice = data.string.slice(data.builder) orelse - return w.print("{d}", .{@intFromEnum(data.string)}); + return w.print("{d}", .{@backingInt(data.string)}); const quote_behavior = data.quote_behavior orelse return w.writeAll(string_slice); return printEscapedString(string_slice, quote_behavior, w); } @@ -142,12 +142,12 @@ pub const String = enum(u32) { } fn fromIndex(index: ?usize) String { - return @enumFromInt(@as(u32, @intCast((index orelse return .none) + - @intFromEnum(String.empty)))); + return @fromBackingInt(@intCast(@as(u32, @intCast((index orelse return .none) + + @backingInt(String.empty))))); } fn toIndex(self: String) ?usize { - return std.math.sub(u32, @intFromEnum(self), @intFromEnum(String.empty)) catch null; + return std.math.sub(u32, @backingInt(self), @backingInt(String.empty)) catch null; } const Adapter = struct { @@ -272,19 +272,19 @@ pub const Type = enum(u32) { pub const Simple = enum(u5) { const Code = ir.ModuleBlock.TypeBlock.Code; - void = @intFromEnum(Code.VOID), - half = @intFromEnum(Code.HALF), - bfloat = @intFromEnum(Code.BFLOAT), - float = @intFromEnum(Code.FLOAT), - double = @intFromEnum(Code.DOUBLE), - fp128 = @intFromEnum(Code.FP128), - x86_fp80 = @intFromEnum(Code.X86_FP80), - ppc_fp128 = @intFromEnum(Code.PPC_FP128), - x86_amx = @intFromEnum(Code.X86_AMX), - x86_mmx = @intFromEnum(Code.X86_MMX), - label = @intFromEnum(Code.LABEL), - token = @intFromEnum(Code.TOKEN), - metadata = @intFromEnum(Code.METADATA), + void = @backingInt(Code.VOID), + half = @backingInt(Code.HALF), + bfloat = @backingInt(Code.BFLOAT), + float = @backingInt(Code.FLOAT), + double = @backingInt(Code.DOUBLE), + fp128 = @backingInt(Code.FP128), + x86_fp80 = @backingInt(Code.X86_FP80), + ppc_fp128 = @backingInt(Code.PPC_FP128), + x86_amx = @backingInt(Code.X86_AMX), + x86_mmx = @backingInt(Code.X86_MMX), + label = @backingInt(Code.LABEL), + token = @backingInt(Code.TOKEN), + metadata = @backingInt(Code.METADATA), }; pub const Function = struct { @@ -344,11 +344,11 @@ pub const Type = enum(u32) { }; pub fn tag(self: Type, builder: *const Builder) Tag { - return builder.type_items.items[@intFromEnum(self)].tag; + return builder.type_items.items[@backingInt(self)].tag; } pub fn unnamedTag(self: Type, builder: *const Builder) Tag { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .named_structure => builder.typeExtraData(Type.NamedStructure, item.data).body .unnamedTag(builder), @@ -357,7 +357,7 @@ pub const Type = enum(u32) { } pub fn scalarTag(self: Type, builder: *const Builder) Tag { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .vector, .scalable_vector => builder.typeExtraData(Type.Vector, item.data) .child.tag(builder), @@ -396,9 +396,9 @@ pub const Type = enum(u32) { switch (self) { .ptr => return .default, else => { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; assert(item.tag == .pointer); - return @enumFromInt(item.data); + return @fromBackingInt(@intCast(item.data)); }, } } @@ -419,7 +419,7 @@ pub const Type = enum(u32) { } pub fn functionParameters(self: Type, builder: *const Builder) []const Type { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; switch (item.tag) { .function, .vararg_function, @@ -432,7 +432,7 @@ pub const Type = enum(u32) { } pub fn functionReturn(self: Type, builder: *const Builder) Type { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; switch (item.tag) { .function, .vararg_function, @@ -491,7 +491,7 @@ pub const Type = enum(u32) { .fp128, .ppc_fp128, .i128 => 128, .ptr, .@"ptr addrspace(4)" => @panic("TODO: query data layout"), _ => { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .simple, .function, @@ -515,7 +515,7 @@ pub const Type = enum(u32) { } pub fn childType(self: Type, builder: *const Builder) Type { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .vector, .scalable_vector, @@ -529,7 +529,7 @@ pub const Type = enum(u32) { pub fn scalarType(self: Type, builder: *const Builder) Type { if (self.isFloatingPoint()) return self; - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .integer, .pointer, @@ -548,7 +548,7 @@ pub const Type = enum(u32) { pub fn changeScalarAssumeCapacity(self: Type, scalar: Type, builder: *Builder) Type { if (self.isFloatingPoint()) return scalar; - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .integer, .pointer, @@ -569,7 +569,7 @@ pub const Type = enum(u32) { } pub fn vectorLen(self: Type, builder: *const Builder) u32 { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .vector, .scalable_vector, @@ -584,7 +584,7 @@ pub const Type = enum(u32) { } pub fn changeLengthAssumeCapacity(self: Type, len: u32, builder: *Builder) Type { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { inline .vector, .scalable_vector, @@ -610,7 +610,7 @@ pub const Type = enum(u32) { } pub fn aggregateLen(self: Type, builder: *const Builder) usize { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .vector, .scalable_vector, @@ -627,7 +627,7 @@ pub const Type = enum(u32) { } pub fn structFields(self: Type, builder: *const Builder) []const Type { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; switch (item.tag) { .structure, .packed_structure, @@ -643,7 +643,7 @@ pub const Type = enum(u32) { pub fn childTypeAt(self: Type, indices: []const u32, builder: *const Builder) Type { if (indices.len == 0) return self; - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .small_array => builder.typeExtraData(Type.Vector, item.data).child .childTypeAt(indices[1..], builder), @@ -685,9 +685,9 @@ pub const Type = enum(u32) { fn format(data: FormatData, w: *Writer) Writer.Error!void { assert(data.type != .none); if (data.mode == .m) { - const item = data.builder.type_items.items[@intFromEnum(data.type)]; + const item = data.builder.type_items.items[@backingInt(data.type)]; switch (item.tag) { - .simple => try w.writeAll(switch (@as(Simple, @enumFromInt(item.data))) { + .simple => try w.writeAll(switch (@as(Simple, @fromBackingInt(@intCast(item.data)))) { .void => "isVoid", .half => "f16", .bfloat => "bf16", @@ -760,7 +760,7 @@ pub const Type = enum(u32) { return; } if (std.enums.tagName(Type, data.type)) |name| return w.writeAll(name); - const item = data.builder.type_items.items[@intFromEnum(data.type)]; + const item = data.builder.type_items.items[@backingInt(data.type)]; switch (item.tag) { .simple => unreachable, .function, .vararg_function => |kind| { @@ -786,7 +786,7 @@ pub const Type = enum(u32) { } }, .integer => try w.print("i{d}", .{item.data}), - .pointer => try w.print("ptr{f}", .{@as(AddrSpace, @enumFromInt(item.data)).fmt(" ")}), + .pointer => try w.print("ptr{f}", .{@as(AddrSpace, @fromBackingInt(@intCast(item.data))).fmt(" ")}), .target => { var extra = data.builder.typeExtraDataTrail(Type.Target, item.data); const types = extra.trail.next(extra.data.types_len, Type, data.builder); @@ -891,7 +891,7 @@ pub const Type = enum(u32) { => true, .none => unreachable, _ => { - const item = builder.type_items.items[@intFromEnum(self)]; + const item = builder.type_items.items[@backingInt(self)]; return switch (item.tag) { .simple => unreachable, .function, @@ -1045,7 +1045,7 @@ pub const Attribute = union(Kind) { const storage = self.toStorage(builder); if (storage.kind.toString()) |kind| return .{ .string = .{ .kind = kind, - .value = @enumFromInt(storage.value), + .value = @fromBackingInt(@intCast(storage.value)), } } else return switch (storage.kind) { inline .zeroext, .signext, @@ -1149,7 +1149,7 @@ pub const Attribute = union(Kind) { return @unionInit(Attribute, field_name, switch (field_type) { void => {}, u32 => storage.value, - Alignment.Lazy, String, Type, UwTable => @enumFromInt(storage.value), + Alignment.Lazy, String, Type, UwTable => @fromBackingInt(@intCast(storage.value)), AllocKind, AllocSize, FpClass, Memory, VScaleRange => @bitCast(storage.value), else => @compileError("bad payload type: " ++ field_name ++ ": " ++ @typeName(field_type)), @@ -1338,7 +1338,7 @@ pub const Attribute = union(Kind) { } fn toStorage(self: Index, builder: *const Builder) Storage { - return builder.attributes.keys()[@intFromEnum(self)]; + return builder.attributes.keys()[@backingInt(self)]; } }; @@ -1447,14 +1447,14 @@ pub const Attribute = union(Kind) { pub fn fromString(str: String) Kind { assert(!str.isAnon()); - const kind: Kind = @enumFromInt(@intFromEnum(str)); + const kind: Kind = @fromBackingInt(@intCast(@backingInt(str))); assert(kind != .none); return kind; } fn toString(self: Kind) ?String { assert(self != .none); - const str: String = @enumFromInt(@intFromEnum(self)); + const str: String = @fromBackingInt(@intCast(@backingInt(self))); return if (str.isAnon()) null else str; } }; @@ -1581,13 +1581,13 @@ pub const Attribute = union(Kind) { inline else => |value, tag| .{ .kind = @as(Kind, self), .value = switch (@TypeOf(value)) { void => 0, u32 => value, - Alignment.Lazy, String, Type, UwTable => @intFromEnum(value), + Alignment.Lazy, String, Type, UwTable => @backingInt(value), AllocKind, AllocSize, FpClass, Memory, VScaleRange => @bitCast(value), else => @compileError("bad payload type: " ++ @tagName(tag) ++ @typeName(@TypeOf(value))), } }, .string => |string_attr| .{ .kind = Kind.fromString(string_attr.kind), - .value = @intFromEnum(string_attr.value), + .value = @backingInt(string_attr.value), }, .none => unreachable, }; @@ -1599,8 +1599,8 @@ pub const Attributes = enum(u32) { _, pub fn slice(self: Attributes, builder: *const Builder) []const Attribute.Index { - const start = builder.attributes_indices.items[@intFromEnum(self)]; - const end = builder.attributes_indices.items[@intFromEnum(self) + 1]; + const start = builder.attributes_indices.items[@backingInt(self)]; + const end = builder.attributes_indices.items[@backingInt(self) + 1]; return @ptrCast(builder.attributes_extra.items[start..end]); } @@ -1785,8 +1785,8 @@ pub const FunctionAttributes = enum(u32) { } fn slice(self: FunctionAttributes, builder: *const Builder) []const Attributes { - const start = builder.attributes_indices.items[@intFromEnum(self)]; - const end = builder.attributes_indices.items[@intFromEnum(self) + 1]; + const start = builder.attributes_indices.items[@backingInt(self)]; + const end = builder.attributes_indices.items[@backingInt(self) + 1]; return @ptrCast(builder.attributes_extra.items[start..end]); } }; @@ -1907,87 +1907,87 @@ pub const AddrSpace = enum(u24) { // See llvm/lib/Target/X86/X86.h pub const x86 = struct { - pub const gs: AddrSpace = @enumFromInt(256); - pub const fs: AddrSpace = @enumFromInt(257); - pub const ss: AddrSpace = @enumFromInt(258); + pub const gs: AddrSpace = @fromBackingInt(@intCast(256)); + pub const fs: AddrSpace = @fromBackingInt(@intCast(257)); + pub const ss: AddrSpace = @fromBackingInt(@intCast(258)); - pub const ptr32_sptr: AddrSpace = @enumFromInt(270); - pub const ptr32_uptr: AddrSpace = @enumFromInt(271); - pub const ptr64: AddrSpace = @enumFromInt(272); + pub const ptr32_sptr: AddrSpace = @fromBackingInt(@intCast(270)); + pub const ptr32_uptr: AddrSpace = @fromBackingInt(@intCast(271)); + pub const ptr64: AddrSpace = @fromBackingInt(@intCast(272)); }; pub const x86_64 = x86; // See llvm/lib/Target/AVR/AVR.h pub const avr = struct { - pub const data: AddrSpace = @enumFromInt(0); - pub const program: AddrSpace = @enumFromInt(1); - pub const program1: AddrSpace = @enumFromInt(2); - pub const program2: AddrSpace = @enumFromInt(3); - pub const program3: AddrSpace = @enumFromInt(4); - pub const program4: AddrSpace = @enumFromInt(5); - pub const program5: AddrSpace = @enumFromInt(6); + pub const data: AddrSpace = @fromBackingInt(@intCast(0)); + pub const program: AddrSpace = @fromBackingInt(@intCast(1)); + pub const program1: AddrSpace = @fromBackingInt(@intCast(2)); + pub const program2: AddrSpace = @fromBackingInt(@intCast(3)); + pub const program3: AddrSpace = @fromBackingInt(@intCast(4)); + pub const program4: AddrSpace = @fromBackingInt(@intCast(5)); + pub const program5: AddrSpace = @fromBackingInt(@intCast(6)); }; // See llvm/lib/Target/NVPTX/NVPTX.h pub const nvptx = struct { - pub const generic: AddrSpace = @enumFromInt(0); - pub const global: AddrSpace = @enumFromInt(1); - pub const constant: AddrSpace = @enumFromInt(2); - pub const shared: AddrSpace = @enumFromInt(3); - pub const param: AddrSpace = @enumFromInt(4); - pub const local: AddrSpace = @enumFromInt(5); + pub const generic: AddrSpace = @fromBackingInt(@intCast(0)); + pub const global: AddrSpace = @fromBackingInt(@intCast(1)); + pub const constant: AddrSpace = @fromBackingInt(@intCast(2)); + pub const shared: AddrSpace = @fromBackingInt(@intCast(3)); + pub const param: AddrSpace = @fromBackingInt(@intCast(4)); + pub const local: AddrSpace = @fromBackingInt(@intCast(5)); }; // See llvm/lib/Target/AMDGPU/AMDGPU.h pub const amdgpu = struct { - pub const flat: AddrSpace = @enumFromInt(0); - pub const global: AddrSpace = @enumFromInt(1); - pub const region: AddrSpace = @enumFromInt(2); - pub const local: AddrSpace = @enumFromInt(3); - pub const constant: AddrSpace = @enumFromInt(4); - pub const private: AddrSpace = @enumFromInt(5); - pub const constant_32bit: AddrSpace = @enumFromInt(6); - pub const buffer_fat_pointer: AddrSpace = @enumFromInt(7); - pub const buffer_resource: AddrSpace = @enumFromInt(8); - pub const buffer_strided_pointer: AddrSpace = @enumFromInt(9); - pub const param_d: AddrSpace = @enumFromInt(6); - pub const param_i: AddrSpace = @enumFromInt(7); - pub const constant_buffer_0: AddrSpace = @enumFromInt(8); - pub const constant_buffer_1: AddrSpace = @enumFromInt(9); - pub const constant_buffer_2: AddrSpace = @enumFromInt(10); - pub const constant_buffer_3: AddrSpace = @enumFromInt(11); - pub const constant_buffer_4: AddrSpace = @enumFromInt(12); - pub const constant_buffer_5: AddrSpace = @enumFromInt(13); - pub const constant_buffer_6: AddrSpace = @enumFromInt(14); - pub const constant_buffer_7: AddrSpace = @enumFromInt(15); - pub const constant_buffer_8: AddrSpace = @enumFromInt(16); - pub const constant_buffer_9: AddrSpace = @enumFromInt(17); - pub const constant_buffer_10: AddrSpace = @enumFromInt(18); - pub const constant_buffer_11: AddrSpace = @enumFromInt(19); - pub const constant_buffer_12: AddrSpace = @enumFromInt(20); - pub const constant_buffer_13: AddrSpace = @enumFromInt(21); - pub const constant_buffer_14: AddrSpace = @enumFromInt(22); - pub const constant_buffer_15: AddrSpace = @enumFromInt(23); - pub const streamout_register: AddrSpace = @enumFromInt(128); + pub const flat: AddrSpace = @fromBackingInt(@intCast(0)); + pub const global: AddrSpace = @fromBackingInt(@intCast(1)); + pub const region: AddrSpace = @fromBackingInt(@intCast(2)); + pub const local: AddrSpace = @fromBackingInt(@intCast(3)); + pub const constant: AddrSpace = @fromBackingInt(@intCast(4)); + pub const private: AddrSpace = @fromBackingInt(@intCast(5)); + pub const constant_32bit: AddrSpace = @fromBackingInt(@intCast(6)); + pub const buffer_fat_pointer: AddrSpace = @fromBackingInt(@intCast(7)); + pub const buffer_resource: AddrSpace = @fromBackingInt(@intCast(8)); + pub const buffer_strided_pointer: AddrSpace = @fromBackingInt(@intCast(9)); + pub const param_d: AddrSpace = @fromBackingInt(@intCast(6)); + pub const param_i: AddrSpace = @fromBackingInt(@intCast(7)); + pub const constant_buffer_0: AddrSpace = @fromBackingInt(@intCast(8)); + pub const constant_buffer_1: AddrSpace = @fromBackingInt(@intCast(9)); + pub const constant_buffer_2: AddrSpace = @fromBackingInt(@intCast(10)); + pub const constant_buffer_3: AddrSpace = @fromBackingInt(@intCast(11)); + pub const constant_buffer_4: AddrSpace = @fromBackingInt(@intCast(12)); + pub const constant_buffer_5: AddrSpace = @fromBackingInt(@intCast(13)); + pub const constant_buffer_6: AddrSpace = @fromBackingInt(@intCast(14)); + pub const constant_buffer_7: AddrSpace = @fromBackingInt(@intCast(15)); + pub const constant_buffer_8: AddrSpace = @fromBackingInt(@intCast(16)); + pub const constant_buffer_9: AddrSpace = @fromBackingInt(@intCast(17)); + pub const constant_buffer_10: AddrSpace = @fromBackingInt(@intCast(18)); + pub const constant_buffer_11: AddrSpace = @fromBackingInt(@intCast(19)); + pub const constant_buffer_12: AddrSpace = @fromBackingInt(@intCast(20)); + pub const constant_buffer_13: AddrSpace = @fromBackingInt(@intCast(21)); + pub const constant_buffer_14: AddrSpace = @fromBackingInt(@intCast(22)); + pub const constant_buffer_15: AddrSpace = @fromBackingInt(@intCast(23)); + pub const streamout_register: AddrSpace = @fromBackingInt(@intCast(128)); }; pub const spirv = struct { - pub const function: AddrSpace = @enumFromInt(0); - pub const cross_workgroup: AddrSpace = @enumFromInt(1); - pub const uniform_constant: AddrSpace = @enumFromInt(2); - pub const workgroup: AddrSpace = @enumFromInt(3); - pub const generic: AddrSpace = @enumFromInt(4); - pub const device_only_intel: AddrSpace = @enumFromInt(5); - pub const host_only_intel: AddrSpace = @enumFromInt(6); - pub const input: AddrSpace = @enumFromInt(7); + pub const function: AddrSpace = @fromBackingInt(@intCast(0)); + pub const cross_workgroup: AddrSpace = @fromBackingInt(@intCast(1)); + pub const uniform_constant: AddrSpace = @fromBackingInt(@intCast(2)); + pub const workgroup: AddrSpace = @fromBackingInt(@intCast(3)); + pub const generic: AddrSpace = @fromBackingInt(@intCast(4)); + pub const device_only_intel: AddrSpace = @fromBackingInt(@intCast(5)); + pub const host_only_intel: AddrSpace = @fromBackingInt(@intCast(6)); + pub const input: AddrSpace = @fromBackingInt(@intCast(7)); }; // See llvm/include/llvm/CodeGen/WasmAddressSpaces.h pub const wasm = struct { - pub const default: AddrSpace = @enumFromInt(0); - pub const variable: AddrSpace = @enumFromInt(1); - pub const externref: AddrSpace = @enumFromInt(10); - pub const funcref: AddrSpace = @enumFromInt(20); + pub const default: AddrSpace = @fromBackingInt(@intCast(0)); + pub const variable: AddrSpace = @fromBackingInt(@intCast(1)); + pub const externref: AddrSpace = @fromBackingInt(@intCast(10)); + pub const funcref: AddrSpace = @fromBackingInt(@intCast(20)); }; pub fn format(addr_space: AddrSpace, w: *Writer) Writer.Error!void { @@ -2030,20 +2030,20 @@ pub const Alignment = enum(u6) { _, pub fn wrap(a: Alignment) Lazy { - return @enumFromInt(@intFromEnum(a)); + return @fromBackingInt(@intCast(@backingInt(a))); } pub fn resolve(l: Lazy, b: *const Builder) Alignment { - return switch (@intFromEnum(l)) { - 0...maxInt(u6) => |raw| @enumFromInt(raw), + return switch (@backingInt(l)) { + 0...maxInt(u6) => |raw| @fromBackingInt(@intCast(raw)), else => |offset_index| b.alignment_forward_references.items[offset_index - maxInt(u6)], }; } fn fromFwdRefIndex(index: usize) Lazy { - return @enumFromInt(index + maxInt(u6)); + return @fromBackingInt(@intCast(index + maxInt(u6))); } fn toFwdRefIndex(l: Lazy) usize { - return @intFromEnum(l) - maxInt(u6); + return @backingInt(l) - maxInt(u6); } }; @@ -2051,13 +2051,13 @@ pub const Alignment = enum(u6) { if (bytes == 0) return .default; assert(std.math.isPowerOfTwo(bytes)); assert(bytes <= 1 << 32); - return @enumFromInt(@ctz(bytes)); + return @fromBackingInt(@intCast(@ctz(bytes))); } pub fn toByteUnits(self: Alignment) ?u64 { return switch (self) { .default => null, - else => @as(u64, 1) << @intFromEnum(self), + else => @as(u64, 1) << @backingInt(self), }; } @@ -2065,13 +2065,13 @@ pub const Alignment = enum(u6) { pub fn max(a: Alignment, b: Alignment) Alignment { assert(a != .default); assert(b != .default); - return @enumFromInt(@max(@intFromEnum(a), @intFromEnum(b))); + return @fromBackingInt(@intCast(@max(@backingInt(a), @backingInt(b)))); } pub fn toLlvm(self: Alignment) u6 { return switch (self) { .default => 0, - else => @intFromEnum(self) + 1, + else => @backingInt(self) + 1, }; } @@ -2214,7 +2214,7 @@ pub const CallConv = enum(u10) { .m68k_rtdcc, .riscv_vectorcallcc, => try w.print(" {s}", .{@tagName(self)}), - _ => try w.print(" cc{d}", .{@intFromEnum(self)}), + _ => try w.print(" cc{d}", .{@backingInt(self)}), } } }; @@ -2244,7 +2244,7 @@ pub const StrtabString = enum(u32) { fn format(data: FormatData, w: *Writer) Writer.Error!void { assert(data.string != .none); const string_slice = data.string.slice(data.builder) orelse - return w.print("{d}", .{@intFromEnum(data.string)}); + return w.print("{d}", .{@backingInt(data.string)}); const quote_behavior = data.quote_behavior orelse return w.writeAll(string_slice); return printEscapedString(string_slice, quote_behavior, w); } @@ -2261,12 +2261,12 @@ pub const StrtabString = enum(u32) { } fn fromIndex(index: ?usize) StrtabString { - return @enumFromInt(@as(u32, @intCast((index orelse return .none) + - @intFromEnum(StrtabString.empty)))); + return @fromBackingInt(@intCast(@as(u32, @intCast((index orelse return .none) + + @backingInt(StrtabString.empty))))); } fn toIndex(self: StrtabString) ?usize { - return std.math.sub(u32, @intFromEnum(self), @intFromEnum(StrtabString.empty)) catch null; + return std.math.sub(u32, @backingInt(self), @backingInt(StrtabString.empty)) catch null; } const Adapter = struct { @@ -2354,7 +2354,7 @@ pub const Global = struct { pub fn unwrap(orig_index: Index, builder: *const Builder) Index { var cur = orig_index; while (true) { - switch (builder.globals.values()[@intFromEnum(cur)].kind) { + switch (builder.globals.values()[@backingInt(cur)].kind) { .replaced => |replacement| cur = replacement, else => return cur, } @@ -2366,15 +2366,15 @@ pub const Global = struct { } pub fn ptr(self: Index, builder: *Builder) *Global { - return &builder.globals.values()[@intFromEnum(self.unwrap(builder))]; + return &builder.globals.values()[@backingInt(self.unwrap(builder))]; } pub fn ptrConst(self: Index, builder: *const Builder) *const Global { - return &builder.globals.values()[@intFromEnum(self.unwrap(builder))]; + return &builder.globals.values()[@backingInt(self.unwrap(builder))]; } pub fn name(self: Index, builder: *const Builder) StrtabString { - return builder.globals.keys()[@intFromEnum(self.unwrap(builder))]; + return builder.globals.keys()[@backingInt(self.unwrap(builder))]; } pub fn strtab(self: Index, builder: *const Builder) struct { @@ -2398,7 +2398,7 @@ pub const Global = struct { } pub fn toConst(global: Index) Constant { - return @enumFromInt(@intFromEnum(Constant.first_global) + @intFromEnum(global)); + return @fromBackingInt(@intCast(@backingInt(Constant.first_global) + @backingInt(global))); } pub fn toValue(global: Index) Value { @@ -2468,7 +2468,7 @@ pub const Global = struct { pub fn toNewFunction(global: Index, builder: *Builder) Allocator.Error!Function.Index { try builder.functions.ensureUnusedCapacity(builder.gpa, 1); errdefer comptime unreachable; - const function: Function.Index = @enumFromInt(builder.functions.items.len); + const function: Function.Index = @fromBackingInt(@intCast(builder.functions.items.len)); builder.functions.appendAssumeCapacity(.{ .global = global, .strip = undefined, @@ -2482,7 +2482,7 @@ pub const Global = struct { pub fn toNewVariable(global: Index, builder: *Builder) Allocator.Error!Variable.Index { try builder.variables.ensureUnusedCapacity(builder.gpa, 1); errdefer comptime unreachable; - const variable: Variable.Index = @enumFromInt(builder.variables.items.len); + const variable: Variable.Index = @fromBackingInt(@intCast(builder.variables.items.len)); builder.variables.appendAssumeCapacity(.{ .global = global }); global.ptr(builder).kind = .{ .variable = variable }; return variable; @@ -2493,7 +2493,7 @@ pub const Global = struct { pub fn toNewAlias(global: Index, builder: *Builder) Allocator.Error!Alias.Index { try builder.aliases.ensureUnusedCapacity(builder.gpa, 1); errdefer comptime unreachable; - const alias: Alias.Index = @enumFromInt(builder.aliases.items.len); + const alias: Alias.Index = @fromBackingInt(@intCast(builder.aliases.items.len)); builder.aliass.appendAssumeCapacity(.{ .global = global, .aliasee = .none }); global.ptr(builder).kind = .{ .alias = alias }; return alias; @@ -2522,11 +2522,11 @@ pub const Global = struct { fn renameAssumeCapacity(self: Index, new_name: StrtabString, builder: *Builder) void { const old_name = self.name(builder); if (new_name == old_name) return; - const index = @intFromEnum(self.unwrap(builder)); + const index = @backingInt(self.unwrap(builder)); _ = builder.addGlobalAssumeCapacity(new_name, builder.globals.values()[index]); builder.globals.swapRemoveAt(index); if (!old_name.isAnon()) return; - builder.next_unnamed_global = @enumFromInt(@intFromEnum(builder.next_unnamed_global) - 1); + builder.next_unnamed_global = @fromBackingInt(@intCast(@backingInt(builder.next_unnamed_global) - 1)); if (builder.next_unnamed_global == old_name) return; builder.getGlobal(builder.next_unnamed_global).?.renameAssumeCapacity(old_name, builder); } @@ -2539,7 +2539,7 @@ pub const Global = struct { fn replaceAssumeCapacity(self: Index, other: Index, builder: *Builder) void { if (self.eql(other, builder)) return; - builder.next_replaced_global = @enumFromInt(@intFromEnum(builder.next_replaced_global) - 1); + builder.next_replaced_global = @fromBackingInt(@intCast(@backingInt(builder.next_replaced_global) - 1)); self.renameAssumeCapacity(builder.next_replaced_global, builder); self.ptr(builder).kind = .{ .replaced = other.unwrap(builder) }; } @@ -2556,11 +2556,11 @@ pub const Alias = struct { _, pub fn ptr(self: Index, builder: *Builder) *Alias { - return &builder.aliases.items[@intFromEnum(self)]; + return &builder.aliases.items[@backingInt(self)]; } pub fn ptrConst(self: Index, builder: *const Builder) *const Alias { - return &builder.aliases.items[@intFromEnum(self)]; + return &builder.aliases.items[@backingInt(self)]; } pub fn name(self: Index, builder: *const Builder) StrtabString { @@ -2608,11 +2608,11 @@ pub const Variable = struct { _, pub fn ptr(self: Index, builder: *Builder) *Variable { - return &builder.variables.items[@intFromEnum(self)]; + return &builder.variables.items[@backingInt(self)]; } pub fn ptrConst(self: Index, builder: *const Builder) *const Variable { - return &builder.variables.items[@intFromEnum(self)]; + return &builder.variables.items[@backingInt(self)]; } pub fn name(self: Index, builder: *const Builder) StrtabString { @@ -4119,11 +4119,11 @@ pub const Function = struct { _, pub fn ptr(self: Index, builder: *Builder) *Function { - return &builder.functions.items[@intFromEnum(self)]; + return &builder.functions.items[@backingInt(self)]; } pub fn ptrConst(self: Index, builder: *const Builder) *const Function { - return &builder.functions.items[@intFromEnum(self)]; + return &builder.functions.items[@backingInt(self)]; } pub fn name(self: Index, builder: *const Builder) StrtabString { @@ -4479,19 +4479,19 @@ pub const Function = struct { _, pub fn name(self: Instruction.Index, function: *const Function) String { - return function.names[@intFromEnum(self)]; + return function.names[@backingInt(self)]; } pub fn valueIndex(self: Instruction.Index, function: *const Function) u32 { - return function.value_indices[@intFromEnum(self)]; + return function.value_indices[@backingInt(self)]; } pub fn toValue(self: Instruction.Index) Value { - return @enumFromInt(@intFromEnum(self)); + return @fromBackingInt(@intCast(@backingInt(self))); } pub fn isTerminatorWip(self: Instruction.Index, wip: *const WipFunction) bool { - return switch (wip.instructions.items(.tag)[@intFromEnum(self)]) { + return switch (wip.instructions.items(.tag)[@backingInt(self)]) { .br, .br_cond, .indirectbr, @@ -4505,7 +4505,7 @@ pub const Function = struct { } pub fn hasResultWip(self: Instruction.Index, wip: *const WipFunction) bool { - return switch (wip.instructions.items(.tag)[@intFromEnum(self)]) { + return switch (wip.instructions.items(.tag)[@backingInt(self)]) { .br, .br_cond, .fence, @@ -4532,7 +4532,7 @@ pub const Function = struct { } pub fn typeOfWip(self: Instruction.Index, wip: *const WipFunction) Type { - const instruction = wip.instructions.get(@intFromEnum(self)); + const instruction = wip.instructions.get(@backingInt(self)); return switch (instruction.tag) { .add, .@"add nsw", @@ -4679,7 +4679,7 @@ pub const Function = struct { .changeScalarAssumeCapacity(.i1, wip.builder), .fneg, .@"fneg fast", - => @as(Value, @enumFromInt(instruction.data)).typeOfWip(wip), + => @as(Value, @fromBackingInt(@intCast(instruction.data))).typeOfWip(wip), .getelementptr, .@"getelementptr inbounds", => { @@ -4721,7 +4721,7 @@ pub const Function = struct { builder: *Builder, ) Type { const function = function_index.ptrConst(builder); - const instruction = function.instructions.get(@intFromEnum(self)); + const instruction = function.instructions.get(@backingInt(self)); return switch (instruction.tag) { .add, .@"add nsw", @@ -4871,7 +4871,7 @@ pub const Function = struct { .changeScalarAssumeCapacity(.i1, builder), .fneg, .@"fneg fast", - => @as(Value, @enumFromInt(instruction.data)).typeOf(function_index, builder), + => @as(Value, @fromBackingInt(@intCast(instruction.data))).typeOf(function_index, builder), .getelementptr, .@"getelementptr inbounds", => { @@ -4963,11 +4963,11 @@ pub const Function = struct { pub fn fromMetadata(metadata: Metadata) Weights { assert(metadata.kind == .node); - return @enumFromInt(metadata.index); + return @fromBackingInt(@intCast(metadata.index)); } pub fn toMetadata(weights: Weights) Metadata { - return .{ .index = @intCast(@intFromEnum(weights)), .kind = .node }; + return .{ .index = @intCast(@backingInt(weights)), .kind = .node }; } }; }; @@ -5156,7 +5156,7 @@ pub const Function = struct { assert(argument.tag == .arg); assert(argument.data == index); - const argument_index: Instruction.Index = @enumFromInt(index); + const argument_index: Instruction.Index = @fromBackingInt(@intCast(index)); return argument_index.toValue(); } @@ -5202,7 +5202,7 @@ pub const Function = struct { Type, Value, Instruction.BrCond.Weights, - => @enumFromInt(value), + => @fromBackingInt(@intCast(value)), MemoryAccessInfo, Instruction.Alloca.Info, Instruction.Call.Info, @@ -5271,15 +5271,15 @@ pub const WipFunction = struct { _, pub fn ptr(self: Index, wip: *WipFunction) *Block { - return &wip.blocks.items[@intFromEnum(self)]; + return &wip.blocks.items[@backingInt(self)]; } pub fn ptrConst(self: Index, wip: *const WipFunction) *const Block { - return &wip.blocks.items[@intFromEnum(self)]; + return &wip.blocks.items[@backingInt(self)]; } pub fn toInst(self: Index, function: *const Function) Instruction.Index { - return function.blocks[@intFromEnum(self)].instruction; + return function.blocks[@backingInt(self)].instruction; } }; }; @@ -5327,14 +5327,14 @@ pub const WipFunction = struct { assert(argument.tag == .arg); assert(argument.data == index); - const argument_index: Instruction.Index = @enumFromInt(index); + const argument_index: Instruction.Index = @fromBackingInt(@intCast(index)); return argument_index.toValue(); } pub fn block(self: *WipFunction, incoming: u32, name: []const u8) Allocator.Error!Block.Index { try self.blocks.ensureUnusedCapacity(self.builder.gpa, 1); - const index: Block.Index = @enumFromInt(self.blocks.items.len); + const index: Block.Index = @fromBackingInt(@intCast(self.blocks.items.len)); const final_name = if (self.strip) .empty else try self.builder.string(name); self.blocks.appendAssumeCapacity(.{ .name = final_name, @@ -5347,7 +5347,7 @@ pub const WipFunction = struct { pub fn ret(self: *WipFunction, val: Value) Allocator.Error!Instruction.Index { assert(val.typeOfWip(self) == self.function.typeOf(self.builder).functionReturn(self.builder)); try self.ensureUnusedExtraCapacity(1, NoExtra, 0); - return try self.addInst(null, .{ .tag = .ret, .data = @intFromEnum(val) }); + return try self.addInst(null, .{ .tag = .ret, .data = @backingInt(val) }); } pub fn retVoid(self: *WipFunction) Allocator.Error!Instruction.Index { @@ -5357,7 +5357,7 @@ pub const WipFunction = struct { pub fn br(self: *WipFunction, dest: Block.Index) Allocator.Error!Instruction.Index { try self.ensureUnusedExtraCapacity(1, NoExtra, 0); - const instruction = try self.addInst(null, .{ .tag = .br, .data = @intFromEnum(dest) }); + const instruction = try self.addInst(null, .{ .tag = .br, .data = @backingInt(dest) }); dest.ptr(self).branches += 1; return instruction; } @@ -5409,7 +5409,7 @@ pub const WipFunction = struct { dest: Block.Index, wip: *WipFunction, ) Allocator.Error!void { - const instruction = wip.instructions.get(@intFromEnum(self.instruction)); + const instruction = wip.instructions.get(@backingInt(self.instruction)); var extra = wip.extraDataTrail(Instruction.Switch, instruction.data); assert(val.typeOf(wip.builder) == extra.data.val.typeOfWip(wip)); extra.trail.nextMut(extra.data.cases_len, Constant, wip)[self.index] = val; @@ -5419,7 +5419,7 @@ pub const WipFunction = struct { } pub fn finish(self: WipSwitch, wip: *WipFunction) void { - const instruction = wip.instructions.get(@intFromEnum(self.instruction)); + const instruction = wip.instructions.get(@backingInt(self.instruction)); const extra = wip.extraData(Instruction.Switch, instruction.data); assert(self.index == extra.cases_len); } @@ -5483,7 +5483,7 @@ pub const WipFunction = struct { else => unreachable, } try self.ensureUnusedExtraCapacity(1, NoExtra, 0); - const instruction = try self.addInst(name, .{ .tag = tag, .data = @intFromEnum(val) }); + const instruction = try self.addInst(name, .{ .tag = tag, .data = @backingInt(val) }); return instruction.toValue(); } @@ -6060,7 +6060,7 @@ pub const WipFunction = struct { ) void { const incoming_len = self.block.ptrConst(wip).incoming; assert(vals.len == incoming_len and blocks.len == incoming_len); - const instruction = wip.instructions.get(@intFromEnum(self.instruction)); + const instruction = wip.instructions.get(@backingInt(self.instruction)); var extra = wip.extraDataTrail(Instruction.Phi, instruction.data); for (vals) |val| assert(val.typeOfWip(wip) == extra.data.type); @memcpy(extra.trail.nextMut(incoming_len, Value, wip), vals); @@ -6326,7 +6326,7 @@ pub const WipFunction = struct { if (val == .none) return .none; return switch (val.unwrap()) { .instruction => |instruction| instructions.items[ - @intFromEnum(instruction) + @backingInt(instruction) ].toValue(), .constant => |constant| constant.toValue(), .metadata => |metadata| metadata.toValue(), @@ -6366,7 +6366,7 @@ pub const WipFunction = struct { Type, Value, Instruction.BrCond.Weights, - => @intFromEnum(value), + => @backingInt(value), MemoryAccessInfo, Instruction.Alloca.Info, Instruction.Call.Info, @@ -6388,7 +6388,7 @@ pub const WipFunction = struct { fn appendMappedValues(wip_extra: *@This(), vals: []const Value, ctx: anytype) void { for (wip_extra.items[wip_extra.index..][0..vals.len], vals) |*extra, val| - extra.* = @intFromEnum(ctx.map(val)); + extra.* = @backingInt(ctx.map(val)); wip_extra.index += @intCast(vals.len); } @@ -6414,24 +6414,24 @@ pub const WipFunction = struct { errdefer function.instructions.shrinkRetainingCapacity(0); { - var final_instruction_index: Instruction.Index = @enumFromInt(0); + var final_instruction_index: Instruction.Index = @fromBackingInt(@intCast(0)); for (0..params_len) |param_index| { instructions.items[param_index] = final_instruction_index; - final_instruction_index = @enumFromInt(@intFromEnum(final_instruction_index) + 1); + final_instruction_index = @fromBackingInt(@intCast(@backingInt(final_instruction_index) + 1)); } for (blocks, self.blocks.items) |*final_block, current_block| { assert(current_block.incoming == current_block.branches); final_block.instruction = final_instruction_index; - final_instruction_index = @enumFromInt(@intFromEnum(final_instruction_index) + 1); + final_instruction_index = @fromBackingInt(@intCast(@backingInt(final_instruction_index) + 1)); for (current_block.instructions.items) |instruction| { - instructions.items[@intFromEnum(instruction)] = final_instruction_index; - final_instruction_index = @enumFromInt(@intFromEnum(final_instruction_index) + 1); + instructions.items[@backingInt(instruction)] = final_instruction_index; + final_instruction_index = @fromBackingInt(@intCast(@backingInt(final_instruction_index) + 1)); } } } var wip_name: struct { - next_name: String = @enumFromInt(0), + next_name: String = @fromBackingInt(@intCast(0)), next_unique_name: std.AutoHashMap(String, String), builder: *Builder, @@ -6440,19 +6440,19 @@ pub const WipFunction = struct { .none => return .none, .empty => { assert(wip_name.next_name != .none); - defer wip_name.next_name = @enumFromInt(@intFromEnum(wip_name.next_name) + 1); + defer wip_name.next_name = @fromBackingInt(@intCast(@backingInt(wip_name.next_name) + 1)); return wip_name.next_name; }, _ => { assert(!name.isAnon()); const gop = try wip_name.next_unique_name.getOrPut(name); if (!gop.found_existing) { - gop.value_ptr.* = @enumFromInt(0); + gop.value_ptr.* = @fromBackingInt(@intCast(0)); return name; } while (true) { - gop.value_ptr.* = @enumFromInt(@intFromEnum(gop.value_ptr.*) + 1); + gop.value_ptr.* = @fromBackingInt(@intCast(@backingInt(gop.value_ptr.*) + 1)); const unique_name = try wip_name.builder.fmt("{f}{s}{f}", .{ name.fmtRaw(wip_name.builder), sep, @@ -6460,7 +6460,7 @@ pub const WipFunction = struct { }); const unique_gop = try wip_name.next_unique_name.getOrPut(unique_name); if (!unique_gop.found_existing) { - unique_gop.value_ptr.* = @enumFromInt(0); + unique_gop.value_ptr.* = @fromBackingInt(@intCast(0)); return unique_name; } } @@ -6475,16 +6475,16 @@ pub const WipFunction = struct { var value_index: u32 = 0; for (0..params_len) |param_index| { - const old_argument_index: Instruction.Index = @enumFromInt(param_index); - const new_argument_index: Instruction.Index = @enumFromInt(function.instructions.len); - const argument = self.instructions.get(@intFromEnum(old_argument_index)); + const old_argument_index: Instruction.Index = @fromBackingInt(@intCast(param_index)); + const new_argument_index: Instruction.Index = @fromBackingInt(@intCast(function.instructions.len)); + const argument = self.instructions.get(@backingInt(old_argument_index)); assert(argument.tag == .arg); assert(argument.data == param_index); value_indices[function.instructions.len] = value_index; value_index += 1; function.instructions.appendAssumeCapacity(argument); - names[@intFromEnum(new_argument_index)] = try wip_name.map( - if (self.strip) .empty else self.names.items[@intFromEnum(old_argument_index)], + names[@backingInt(new_argument_index)] = try wip_name.map( + if (self.strip) .empty else self.names.items[@backingInt(old_argument_index)], ".", ); if (self.debug_locations.get(old_argument_index)) |location| { @@ -6495,16 +6495,16 @@ pub const WipFunction = struct { } } for (self.blocks.items) |current_block| { - const new_block_index: Instruction.Index = @enumFromInt(function.instructions.len); + const new_block_index: Instruction.Index = @fromBackingInt(@intCast(function.instructions.len)); value_indices[function.instructions.len] = value_index; function.instructions.appendAssumeCapacity(.{ .tag = .block, .data = current_block.incoming, }); - names[@intFromEnum(new_block_index)] = try wip_name.map(current_block.name, ""); + names[@backingInt(new_block_index)] = try wip_name.map(current_block.name, ""); for (current_block.instructions.items) |old_instruction_index| { - const new_instruction_index: Instruction.Index = @enumFromInt(function.instructions.len); - var instruction = self.instructions.get(@intFromEnum(old_instruction_index)); + const new_instruction_index: Instruction.Index = @fromBackingInt(@intCast(function.instructions.len)); + var instruction = self.instructions.get(@backingInt(old_instruction_index)); switch (instruction.tag) { .add, .@"add nsw", @@ -6702,7 +6702,7 @@ pub const WipFunction = struct { .fneg, .@"fneg fast", .ret, - => instruction.data = @intFromEnum(instructions.map(@enumFromInt(instruction.data))), + => instruction.data = @backingInt(instructions.map(@fromBackingInt(@intCast(instruction.data)))), .getelementptr, .@"getelementptr inbounds", => { @@ -6815,10 +6815,10 @@ pub const WipFunction = struct { }, } function.instructions.appendAssumeCapacity(instruction); - names[@intFromEnum(new_instruction_index)] = try wip_name.map(if (self.strip) + names[@backingInt(new_instruction_index)] = try wip_name.map(if (self.strip) if (old_instruction_index.hasResultWip(self)) .empty else .none else - self.names.items[@intFromEnum(old_instruction_index)], "."); + self.names.items[@backingInt(old_instruction_index)], "."); if (self.debug_locations.get(old_instruction_index)) |location| { debug_locations.putAssumeCapacity(new_instruction_index, location); @@ -6828,7 +6828,7 @@ pub const WipFunction = struct { debug_values[index] = new_instruction_index; } - value_indices[@intFromEnum(new_instruction_index)] = value_index; + value_indices[@backingInt(new_instruction_index)] = value_index; if (old_instruction_index.hasResultWip(self)) value_index += 1; } } @@ -6996,7 +6996,7 @@ pub const WipFunction = struct { else .none; - const index: Instruction.Index = @enumFromInt(self.instructions.len); + const index: Instruction.Index = @fromBackingInt(@intCast(self.instructions.len)); self.instructions.appendAssumeCapacity(instruction); if (!self.strip) { self.names.appendAssumeCapacity(final_name); @@ -7026,7 +7026,7 @@ pub const WipFunction = struct { Type, Value, Instruction.BrCond.Weights, - => @intFromEnum(value), + => @backingInt(value), MemoryAccessInfo, Instruction.Alloca.Info, Instruction.Call.Info, @@ -7079,7 +7079,7 @@ pub const WipFunction = struct { Type, Value, Instruction.BrCond.Weights, - => @enumFromInt(value), + => @fromBackingInt(@intCast(value)), MemoryAccessInfo, Instruction.Alloca.Info, Instruction.Call.Info, @@ -7268,7 +7268,7 @@ pub const Constant = enum(u32) { no_init = (1 << 30) - 1, _, - const first_global: Constant = @enumFromInt(1 << 29); + const first_global: Constant = @fromBackingInt(@intCast(1 << 29)); pub const Tag = enum(u7) { positive_integer, @@ -7441,14 +7441,14 @@ pub const Constant = enum(u32) { constant: u30, global: Global.Index, } { - return if (@intFromEnum(self) < @intFromEnum(first_global)) - .{ .constant = @intCast(@intFromEnum(self)) } + return if (@backingInt(self) < @backingInt(first_global)) + .{ .constant = @intCast(@backingInt(self)) } else - .{ .global = @enumFromInt(@intFromEnum(self) - @intFromEnum(first_global)) }; + .{ .global = @fromBackingInt(@intCast(@backingInt(self) - @backingInt(first_global))) }; } pub fn toValue(self: Constant) Value { - return @enumFromInt(Value.first_constant + @intFromEnum(self)); + return @fromBackingInt(@intCast(Value.first_constant + @backingInt(self))); } pub fn typeOf(self: Constant, builder: *Builder) Type { @@ -7474,7 +7474,7 @@ pub const Constant = enum(u32) { .zeroinitializer, .undef, .poison, - => @enumFromInt(item.data), + => @fromBackingInt(@intCast(item.data)), .structure, .packed_structure, .array, @@ -7482,7 +7482,7 @@ pub const Constant = enum(u32) { => builder.constantExtraData(Aggregate, item.data).type, .splat => builder.constantExtraData(Splat, item.data).type, .string => builder.arrayTypeAssumeCapacity( - @as(String, @enumFromInt(item.data)).slice(builder).?.len, + @as(String, @fromBackingInt(@intCast(item.data))).slice(builder).?.len, .i8, ), .blockaddress => builder.ptrTypeAssumeCapacity( @@ -7491,7 +7491,7 @@ pub const Constant = enum(u32) { ), .dso_local_equivalent, .no_cfi, - => builder.ptrTypeAssumeCapacity(@as(Function.Index, @enumFromInt(item.data)) + => builder.ptrTypeAssumeCapacity(@as(Function.Index, @fromBackingInt(@intCast(item.data))) .ptrConst(builder).global.ptrConst(builder).addr_space), .trunc, .ptrtoint, @@ -7802,7 +7802,7 @@ pub const Constant = enum(u32) { try w.writeByte('>'); }, .string => try w.print("c{f}", .{ - @as(String, @enumFromInt(item.data)).fmtQ(data.builder), + @as(String, @fromBackingInt(@intCast(item.data))).fmtQ(data.builder), }), .blockaddress => |tag| { const extra = data.builder.constantExtraData(BlockAddress, item.data); @@ -7816,7 +7816,7 @@ pub const Constant = enum(u32) { .dso_local_equivalent, .no_cfi, => |tag| { - const function: Function.Index = @enumFromInt(item.data); + const function: Function.Index = @fromBackingInt(@intCast(item.data)); try w.print("{s} {f}", .{ @tagName(tag), function.ptrConst(data.builder).global.fmt(data.builder), @@ -7905,10 +7905,10 @@ pub const Constant = enum(u32) { pub const Value = enum(u32) { none = maxInt(u31), - false = first_constant + @intFromEnum(Constant.false), - true = first_constant + @intFromEnum(Constant.true), - @"0" = first_constant + @intFromEnum(Constant.@"0"), - @"1" = first_constant + @intFromEnum(Constant.@"1"), + false = first_constant + @backingInt(Constant.false), + true = first_constant + @backingInt(Constant.true), + @"0" = first_constant + @backingInt(Constant.@"0"), + @"1" = first_constant + @backingInt(Constant.@"1"), _, const first_constant = 1 << 30; @@ -7919,12 +7919,12 @@ pub const Value = enum(u32) { constant: Constant, metadata: Metadata, } { - return if (@intFromEnum(self) < first_constant) - .{ .instruction = @enumFromInt(@intFromEnum(self)) } - else if (@intFromEnum(self) < first_metadata) - .{ .constant = @enumFromInt(@intFromEnum(self) - first_constant) } + return if (@backingInt(self) < first_constant) + .{ .instruction = @fromBackingInt(@intCast(@backingInt(self))) } + else if (@backingInt(self) < first_metadata) + .{ .constant = @fromBackingInt(@intCast(@backingInt(self) - first_constant)) } else - .{ .metadata = @bitCast(@intFromEnum(self) - first_metadata) }; + .{ .metadata = @bitCast(@backingInt(self) - first_metadata) }; } pub fn typeOfWip(self: Value, wip: *const WipFunction) Type { @@ -8016,7 +8016,7 @@ pub const Metadata = packed struct(u32) { return .{ .index = metadata.index, .kind = metadata.kind, .is_none = false }; } pub fn toValue(metadata: Metadata) Value { - return @enumFromInt(Value.first_metadata + @as(u32, @bitCast(metadata))); + return @fromBackingInt(@intCast(Value.first_metadata + @as(u32, @bitCast(metadata)))); } pub const String = enum(u32) { @@ -8032,7 +8032,7 @@ pub const Metadata = packed struct(u32) { pub fn unwrap(metadata: Metadata.String.Optional) ?Metadata.String { return switch (metadata) { .none => null, - else => @enumFromInt(@intFromEnum(metadata)), + else => @fromBackingInt(@intCast(@backingInt(metadata))), }; } pub fn toMetadata(metadata: Metadata.String.Optional) Metadata.Optional { @@ -8040,14 +8040,14 @@ pub const Metadata = packed struct(u32) { } }; pub fn toOptional(metadata: Metadata.String) Metadata.String.Optional { - return @enumFromInt(@intFromEnum(metadata)); + return @fromBackingInt(@intCast(@backingInt(metadata))); } pub fn toMetadata(metadata: Metadata.String) Metadata { - return .{ .index = @intCast(@intFromEnum(metadata)), .kind = .string }; + return .{ .index = @intCast(@backingInt(metadata)), .kind = .string }; } pub fn slice(metadata: Metadata.String, builder: *const Builder) []const u8 { - const index = @intFromEnum(metadata); + const index = @backingInt(metadata); const start = builder.metadata_string_indices.items[index]; const end = builder.metadata_string_indices.items[index + 1]; return builder.metadata_string_bytes.items[start..end]; @@ -8059,7 +8059,7 @@ pub const Metadata = packed struct(u32) { return @truncate(std.hash.Wyhash.hash(0, key)); } pub fn eql(ctx: Adapter, lhs_key: []const u8, _: void, rhs_index: usize) bool { - const rhs_metadata: Metadata.String = @enumFromInt(rhs_index); + const rhs_metadata: Metadata.String = @fromBackingInt(@intCast(rhs_index)); return std.mem.eql(u8, lhs_key, rhs_metadata.slice(ctx.builder)); } }; @@ -8077,7 +8077,7 @@ pub const Metadata = packed struct(u32) { }; pub fn toString(metadata: Metadata) Metadata.String { assert(metadata.kind == .string); - return @enumFromInt(metadata.index); + return @fromBackingInt(@intCast(metadata.index)); } pub const Tag = enum(u6) { @@ -8542,7 +8542,7 @@ pub const Metadata = packed struct(u32) { try w.writeByte(')'); }, .constant => try Constant.format(.{ - .constant = @enumFromInt(node_item.data), + .constant = @fromBackingInt(@intCast(node_item.data)), .builder = builder, .flags = data.specialized orelse .{}, }, w), @@ -8744,7 +8744,7 @@ pub fn init(options: Options) Allocator.Error!Builder { .string_bytes = .empty, .types = .empty, - .next_unnamed_type = @enumFromInt(0), + .next_unnamed_type = @fromBackingInt(@intCast(0)), .next_unique_type_id = .empty, .type_map = .empty, .type_items = .empty, @@ -8758,7 +8758,7 @@ pub fn init(options: Options) Allocator.Error!Builder { .function_attributes_set = .empty, .globals = .empty, - .next_unnamed_global = @enumFromInt(0), + .next_unnamed_global = @fromBackingInt(@intCast(0)), .next_replaced_global = .none, .next_unique_global_id = .empty, .aliases = .empty, @@ -8815,7 +8815,7 @@ pub fn init(options: Options) Allocator.Error!Builder { assert(self.intTypeAssumeCapacity(bits) == @field(Type, std.fmt.comptimePrint("i{d}", .{bits}))); inline for (.{ 0, 4 }) |addr_space_index| { - const addr_space: AddrSpace = @enumFromInt(addr_space_index); + const addr_space: AddrSpace = @fromBackingInt(@intCast(addr_space_index)); assert(self.ptrTypeAssumeCapacity(addr_space) == @field(Type, std.fmt.comptimePrint("ptr{f}", .{addr_space.fmt(" ")}))); } @@ -9070,9 +9070,9 @@ pub fn namedTypeSetBody( named_type: Type, body_type: Type, ) void { - const named_item = self.type_items.items[@intFromEnum(named_type)]; + const named_item = self.type_items.items[@backingInt(named_type)]; self.type_extra.items[named_item.data + std.meta.fieldIndex(Type.NamedStructure, "body").?] = - @intFromEnum(body_type); + @backingInt(body_type); } pub fn attr(self: *Builder, attribute: Attribute) Allocator.Error!Attribute.Index { @@ -9080,7 +9080,7 @@ pub fn attr(self: *Builder, attribute: Attribute) Allocator.Error!Attribute.Inde const gop = self.attributes.getOrPutAssumeCapacity(attribute.toStorage()); if (!gop.found_existing) gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn attrs(self: *Builder, attributes: []Attribute.Index) Allocator.Error!Attributes { @@ -9089,20 +9089,20 @@ pub fn attrs(self: *Builder, attributes: []Attribute.Index) Allocator.Error!Attr const lhs_kind = lhs.getKind(builder); const rhs_kind = rhs.getKind(builder); assert(lhs_kind != rhs_kind); - return @intFromEnum(lhs_kind) < @intFromEnum(rhs_kind); + return @backingInt(lhs_kind) < @backingInt(rhs_kind); } }.lessThan); - return @enumFromInt(try self.attrGeneric(@ptrCast(attributes))); + return @fromBackingInt(@intCast(try self.attrGeneric(@ptrCast(attributes)))); } pub fn fnAttrs(self: *Builder, fn_attributes: []const Attributes) Allocator.Error!FunctionAttributes { try self.function_attributes_set.ensureUnusedCapacity(self.gpa, 1); - const function_attributes: FunctionAttributes = @enumFromInt(try self.attrGeneric(@ptrCast( + const function_attributes: FunctionAttributes = @fromBackingInt(@intCast(try self.attrGeneric(@ptrCast( fn_attributes[0..if (std.mem.lastIndexOfNone(Attributes, fn_attributes, &.{.none})) |last| last + 1 else 0], - ))); + )))); _ = self.function_attributes_set.getOrPutAssumeCapacity(function_attributes); return function_attributes; @@ -9121,13 +9121,13 @@ pub fn addGlobalAssumeCapacity(self: *Builder, name: StrtabString, global: Globa if (name == .empty) { id = self.next_unnamed_global; assert(id != self.next_replaced_global); - self.next_unnamed_global = @enumFromInt(@intFromEnum(id) + 1); + self.next_unnamed_global = @fromBackingInt(@intCast(@backingInt(id) + 1)); } while (true) { const global_gop = self.globals.getOrPutAssumeCapacity(id); if (!global_gop.found_existing) { global_gop.value_ptr.* = global; - const global_index: Global.Index = @enumFromInt(global_gop.index); + const global_index: Global.Index = @fromBackingInt(@intCast(global_gop.index)); global_index.updateDsoLocal(self); return global_index; } @@ -9140,7 +9140,7 @@ pub fn addGlobalAssumeCapacity(self: *Builder, name: StrtabString, global: Globa } pub fn getGlobal(self: *const Builder, name: StrtabString) ?Global.Index { - return @enumFromInt(self.globals.getIndex(name) orelse return null); + return @fromBackingInt(@intCast(self.globals.getIndex(name) orelse return null)); } pub fn addAlias( @@ -9164,7 +9164,7 @@ pub fn addAliasAssumeCapacity( addr_space: AddrSpace, aliasee: Constant, ) Alias.Index { - const alias_index: Alias.Index = @enumFromInt(self.aliases.items.len); + const alias_index: Alias.Index = @fromBackingInt(@intCast(self.aliases.items.len)); self.aliases.appendAssumeCapacity(.{ .global = self.addGlobalAssumeCapacity(name, .{ .addr_space = addr_space, .type = ty, @@ -9192,7 +9192,7 @@ pub fn addVariableAssumeCapacity( name: StrtabString, addr_space: AddrSpace, ) Variable.Index { - const variable_index: Variable.Index = @enumFromInt(self.variables.items.len); + const variable_index: Variable.Index = @fromBackingInt(@intCast(self.variables.items.len)); self.variables.appendAssumeCapacity(.{ .global = self.addGlobalAssumeCapacity(name, .{ .addr_space = addr_space, .type = ty, @@ -9221,7 +9221,7 @@ pub fn addFunctionAssumeCapacity( addr_space: AddrSpace, ) Function.Index { assert(ty.isFunction(self)); - const function_index: Function.Index = @enumFromInt(self.functions.items.len); + const function_index: Function.Index = @fromBackingInt(@intCast(self.functions.items.len)); self.functions.appendAssumeCapacity(.{ .global = self.addGlobalAssumeCapacity(name, .{ .addr_space = addr_space, @@ -9331,7 +9331,7 @@ pub fn getIntrinsic( pub fn intConst(self: *Builder, ty: Type, value: anytype) Allocator.Error!Constant { const int_value = switch (@typeInfo(@TypeOf(value))) { .int, .comptime_int => value, - .@"enum" => @intFromEnum(value), + .@"enum" => @backingInt(value), else => @compileError("intConst expected an integral value, got " ++ @typeName(@TypeOf(value))), }; var limbs: [ @@ -9750,7 +9750,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void for (self.variables.items, 0..) |variable, variable_i| { // Skip the variable if its global has been repurposed for something else. switch (variable.global.ptrConst(self).kind) { - .variable => |v| if (@intFromEnum(v) != variable_i) continue, + .variable => |v| if (@backingInt(v) != variable_i) continue, else => continue, } const global = variable.global.ptrConst(self); @@ -9792,7 +9792,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void for (self.aliases.items, 0..) |alias, alias_i| { // Skip the alias if its global has been repurposed for something else. switch (alias.global.ptrConst(self).kind) { - .alias => |a| if (@intFromEnum(a) != alias_i) continue, + .alias => |a| if (@backingInt(a) != alias_i) continue, else => continue, } const global = alias.global.ptrConst(self); @@ -9822,11 +9822,11 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void for (0.., self.functions.items) |function_i, function| { // Skip the function if its global has been repurposed for something else. switch (function.global.ptrConst(self).kind) { - .function => |f| if (@intFromEnum(f) != function_i) continue, + .function => |f| if (@backingInt(f) != function_i) continue, else => continue, } if (need_newline) try w.writeByte('\n') else need_newline = true; - const function_index: Function.Index = @enumFromInt(function_i); + const function_index: Function.Index = @fromBackingInt(@intCast(function_i)); const global = function.global.ptrConst(self); const params_len = global.type.functionParameters(self).len; const function_attributes = function.attributes.func(self); @@ -9887,8 +9887,8 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void try w.writeAll(" {\n"); var maybe_dbg_index: ?u32 = null; for (params_len..function.instructions.len) |instruction_i| { - const instruction_index: Function.Instruction.Index = @enumFromInt(instruction_i); - const instruction = function.instructions.get(@intFromEnum(instruction_index)); + const instruction_index: Function.Instruction.Index = @fromBackingInt(@intCast(instruction_i)); + const instruction = function.instructions.get(@backingInt(instruction_index)); if (function.debug_locations.get(instruction_index)) |debug_location| switch (debug_location) { .no_location => maybe_dbg_index = null, .location => |location| { @@ -10052,13 +10052,13 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void .block => { block_incoming_len = instruction.data; const name = instruction_index.name(&function); - if (@intFromEnum(instruction_index) > params_len) + if (@backingInt(instruction_index) > params_len) try w.writeByte('\n'); try w.print("{f}:\n", .{name.fmt(self)}); continue; }, .br => |tag| { - const target: Function.Block.Index = @enumFromInt(instruction.data); + const target: Function.Block.Index = @fromBackingInt(@intCast(instruction.data)); try w.print(" {s} {f}", .{ @tagName(tag), target.toInst(&function).fmt(function_index, self, .{ .percent = true }), }); @@ -10187,7 +10187,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void .fneg, .@"fneg fast", => |tag| { - const val: Value = @enumFromInt(instruction.data); + const val: Value = @fromBackingInt(@intCast(instruction.data)); try w.print(" %{f} = {s} {f}", .{ instruction_index.name(&function).fmt(self), @tagName(tag), @@ -10288,7 +10288,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void } }, .ret => |tag| { - const val: Value = @enumFromInt(instruction.data); + const val: Value = @fromBackingInt(@intCast(instruction.data)); try w.print(" {s} {f}", .{ @tagName(tag), val.fmt(function_index, self, .{ .percent = true }), @@ -10498,7 +10498,7 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void .thisAdjustment = null, .flags = extra.di_flags, .spFlags = @as(Metadata.Subprogram.DISPFlags, @bitCast(@as(u32, @as(u3, @intCast( - @intFromEnum(kind) - @intFromEnum(Metadata.Tag.subprogram), + @backingInt(kind) - @backingInt(Metadata.Tag.subprogram), ))) << 2)), .unit = extra.compile_unit, .templateParams = null, @@ -10818,7 +10818,7 @@ fn fnTypeAssumeCapacity( const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { - var hasher = std.hash.Wyhash.init(comptime std.hash.int(@intFromEnum(tag))); + var hasher = std.hash.Wyhash.init(comptime std.hash.int(@backingInt(tag))); hasher.update(std.mem.asBytes(&key.ret)); hasher.update(std.mem.sliceAsBytes(key.params)); return @truncate(hasher.final()); @@ -10847,7 +10847,7 @@ fn fnTypeAssumeCapacity( }); self.type_extra.appendSliceAssumeCapacity(@ptrCast(params)); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn intTypeAssumeCapacity(self: *Builder, bits: u24) Type { @@ -10858,7 +10858,7 @@ fn intTypeAssumeCapacity(self: *Builder, bits: u24) Type { fn ptrTypeAssumeCapacity(self: *Builder, addr_space: AddrSpace) Type { const result = self.getOrPutTypeNoExtraAssumeCapacity( - .{ .tag = .pointer, .data = @intFromEnum(addr_space) }, + .{ .tag = .pointer, .data = @backingInt(addr_space) }, ); return result.type; } @@ -10878,7 +10878,7 @@ fn vectorTypeAssumeCapacity( builder: *const Builder, pub fn hash(_: @This(), key: Type.Vector) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(tag)), + comptime std.hash.int(@backingInt(tag)), std.mem.asBytes(&key), )); } @@ -10898,7 +10898,7 @@ fn vectorTypeAssumeCapacity( .data = self.addTypeExtraAssumeCapacity(data), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type { @@ -10907,7 +10907,7 @@ fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type { builder: *const Builder, pub fn hash(_: @This(), key: Type.Vector) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Type.Tag.small_array)), + comptime std.hash.int(@backingInt(Type.Tag.small_array)), std.mem.asBytes(&key), )); } @@ -10927,13 +10927,13 @@ fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type { .data = self.addTypeExtraAssumeCapacity(data), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } else { const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Type.Array) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Type.Tag.array)), + comptime std.hash.int(@backingInt(Type.Tag.array)), std.mem.asBytes(&key), )); } @@ -10957,7 +10957,7 @@ fn arrayTypeAssumeCapacity(self: *Builder, len: u64, child: Type) Type { .data = self.addTypeExtraAssumeCapacity(data), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } } @@ -10974,7 +10974,7 @@ fn structTypeAssumeCapacity( builder: *const Builder, pub fn hash(_: @This(), key: []const Type) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(tag)), + comptime std.hash.int(@backingInt(tag)), std.mem.sliceAsBytes(key), )); } @@ -10998,7 +10998,7 @@ fn structTypeAssumeCapacity( }); self.type_extra.appendSliceAssumeCapacity(@ptrCast(fields)); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type { @@ -11006,7 +11006,7 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type { builder: *const Builder, pub fn hash(_: @This(), key: String) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Type.Tag.named_structure)), + comptime std.hash.int(@backingInt(Type.Tag.named_structure)), std.mem.asBytes(&key), )); } @@ -11020,7 +11020,7 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type { if (name == .empty) { id = self.next_unnamed_type; assert(id != .none); - self.next_unnamed_type = @enumFromInt(@intFromEnum(id) + 1); + self.next_unnamed_type = @fromBackingInt(@intCast(@backingInt(id) + 1)); } else assert(!name.isAnon()); while (true) { const type_gop = self.types.getOrPutAssumeCapacity(id); @@ -11036,7 +11036,7 @@ fn opaqueTypeAssumeCapacity(self: *Builder, name: String) Type { .body = .none, }), }); - const result: Type = @enumFromInt(gop.index); + const result: Type = @fromBackingInt(@intCast(gop.index)); type_gop.value_ptr.* = result; return result; } @@ -11067,7 +11067,7 @@ fn getOrPutTypeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { n builder: *const Builder, pub fn hash(_: @This(), key: Type.Item) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Type.Tag.simple)), + comptime std.hash.int(@backingInt(Type.Tag.simple)), std.mem.asBytes(&key), )); } @@ -11083,7 +11083,7 @@ fn getOrPutTypeNoExtraAssumeCapacity(self: *Builder, item: Type.Item) struct { n gop.value_ptr.* = {}; self.type_items.appendAssumeCapacity(item); } - return .{ .new = !gop.found_existing, .type = @enumFromInt(gop.index) }; + return .{ .new = !gop.found_existing, .type = @fromBackingInt(@intCast(gop.index)) }; } fn addTypeExtraAssumeCapacity(self: *Builder, extra: anytype) Type.Item.ExtraIndex { @@ -11093,7 +11093,7 @@ fn addTypeExtraAssumeCapacity(self: *Builder, extra: anytype) Type.Item.ExtraInd const value = @field(extra, field_name); self.type_extra.appendAssumeCapacity(switch (field_type) { u32 => value, - String, Type => @intFromEnum(value), + String, Type => @backingInt(value), else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)), }); } @@ -11135,7 +11135,7 @@ fn typeExtraDataTrail( ) |field_name, field_type, value| @field(result, field_name) = switch (field_type) { u32 => value, - String, Type => @enumFromInt(value), + String, Type => @fromBackingInt(@intCast(value)), else => @compileError("bad field type: " ++ @typeName(field_type)), }; return .{ @@ -11177,7 +11177,7 @@ fn bigIntConstAssumeCapacity( ty: Type, value: std.math.big.int.Const, ) Allocator.Error!Constant { - const type_item = self.type_items.items[@intFromEnum(ty)]; + const type_item = self.type_items.items[@backingInt(ty)]; assert(type_item.tag == .integer); const bits = type_item.data; @@ -11206,7 +11206,7 @@ fn bigIntConstAssumeCapacity( const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { - var hasher = std.hash.Wyhash.init(std.hash.int(@intFromEnum(key.tag))); + var hasher = std.hash.Wyhash.init(std.hash.int(@backingInt(key.tag))); hasher.update(std.mem.asBytes(&key.type)); hasher.update(std.mem.sliceAsBytes(key.limbs)); return @truncate(hasher.final()); @@ -11239,7 +11239,7 @@ fn bigIntConstAssumeCapacity( extra.* = .{ .type = ty, .limbs_len = @intCast(canonical_value.limbs.len) }; self.constant_limbs.appendSliceAssumeCapacity(canonical_value.limbs); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn halfConstAssumeCapacity(self: *Builder, val: f16) Constant { @@ -11269,7 +11269,7 @@ fn doubleConstAssumeCapacity(self: *Builder, val: f64) Constant { builder: *const Builder, pub fn hash(_: @This(), key: f64) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Constant.Tag.double)), + comptime std.hash.int(@backingInt(Constant.Tag.double)), std.mem.asBytes(&key), )); } @@ -11292,7 +11292,7 @@ fn doubleConstAssumeCapacity(self: *Builder, val: f64) Constant { }), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn fp128ConstAssumeCapacity(self: *Builder, val: f128) Constant { @@ -11300,7 +11300,7 @@ fn fp128ConstAssumeCapacity(self: *Builder, val: f128) Constant { builder: *const Builder, pub fn hash(_: @This(), key: f128) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Constant.Tag.fp128)), + comptime std.hash.int(@backingInt(Constant.Tag.fp128)), std.mem.asBytes(&key), )); } @@ -11326,7 +11326,7 @@ fn fp128ConstAssumeCapacity(self: *Builder, val: f128) Constant { }), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn x86_fp80ConstAssumeCapacity(self: *Builder, val: f80) Constant { @@ -11334,7 +11334,7 @@ fn x86_fp80ConstAssumeCapacity(self: *Builder, val: f80) Constant { builder: *const Builder, pub fn hash(_: @This(), key: f80) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Constant.Tag.x86_fp80)), + comptime std.hash.int(@backingInt(Constant.Tag.x86_fp80)), std.mem.asBytes(&key)[0..10], )); } @@ -11359,7 +11359,7 @@ fn x86_fp80ConstAssumeCapacity(self: *Builder, val: f80) Constant { }), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn ppc_fp128ConstAssumeCapacity(self: *Builder, val: [2]f64) Constant { @@ -11367,7 +11367,7 @@ fn ppc_fp128ConstAssumeCapacity(self: *Builder, val: [2]f64) Constant { builder: *const Builder, pub fn hash(_: @This(), key: [2]f64) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Constant.Tag.ppc_fp128)), + comptime std.hash.int(@backingInt(Constant.Tag.ppc_fp128)), std.mem.asBytes(&key), )); } @@ -11393,13 +11393,13 @@ fn ppc_fp128ConstAssumeCapacity(self: *Builder, val: [2]f64) Constant { }), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn nullConstAssumeCapacity(self: *Builder, ty: Type) Constant { - assert(self.type_items.items[@intFromEnum(ty)].tag == .pointer); + assert(self.type_items.items[@backingInt(ty)].tag == .pointer); const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .null, .data = @intFromEnum(ty) }, + .{ .tag = .null, .data = @backingInt(ty) }, ); return result.constant; } @@ -11407,18 +11407,18 @@ fn nullConstAssumeCapacity(self: *Builder, ty: Type) Constant { fn noneConstAssumeCapacity(self: *Builder, ty: Type) Constant { assert(ty == .token); const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .none, .data = @intFromEnum(ty) }, + .{ .tag = .none, .data = @backingInt(ty) }, ); return result.constant; } fn structConstAssumeCapacity(self: *Builder, ty: Type, vals: []const Constant) Constant { - const type_item = self.type_items.items[@intFromEnum(ty)]; + const type_item = self.type_items.items[@backingInt(ty)]; var extra = self.typeExtraDataTrail(Type.Structure, switch (type_item.tag) { .structure, .packed_structure => type_item.data, .named_structure => data: { const body_ty = self.typeExtraData(Type.NamedStructure, type_item.data).body; - const body_item = self.type_items.items[@intFromEnum(body_ty)]; + const body_item = self.type_items.items[@backingInt(body_ty)]; switch (body_item.tag) { .structure, .packed_structure => break :data body_item.data, else => unreachable, @@ -11443,7 +11443,7 @@ fn structConstAssumeCapacity(self: *Builder, ty: Type, vals: []const Constant) C } fn arrayConstAssumeCapacity(self: *Builder, ty: Type, vals: []const Constant) Constant { - const type_item = self.type_items.items[@intFromEnum(ty)]; + const type_item = self.type_items.items[@backingInt(ty)]; const type_extra: struct { len: u64, child: Type } = switch (type_item.tag) { inline .small_array, .array => |kind| extra: { const extra = self.typeExtraData(switch (kind) { @@ -11471,7 +11471,7 @@ fn stringConstAssumeCapacity(self: *Builder, val: String) Constant { const ty = self.arrayTypeAssumeCapacity(slice.len, .i8); if (std.mem.allEqual(u8, slice, 0)) return self.zeroInitConstAssumeCapacity(ty); const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .string, .data = @intFromEnum(val) }, + .{ .tag = .string, .data = @backingInt(val) }, ); return result.constant; } @@ -11502,7 +11502,7 @@ fn splatConstAssumeCapacity(self: *Builder, ty: Type, val: Constant) Constant { builder: *const Builder, pub fn hash(_: @This(), key: Constant.Splat) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Constant.Tag.splat)), + comptime std.hash.int(@backingInt(Constant.Tag.splat)), std.mem.asBytes(&key), )); } @@ -11523,7 +11523,7 @@ fn splatConstAssumeCapacity(self: *Builder, ty: Type, val: Constant) Constant { .data = self.addConstantExtraAssumeCapacity(data), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn zeroInitConstAssumeCapacity(self: *Builder, ty: Type) Constant { @@ -11538,7 +11538,7 @@ fn zeroInitConstAssumeCapacity(self: *Builder, ty: Type) Constant { .ppc_fp128 => return self.ppc_fp128ConstAssumeCapacity(.{ 0.0, 0.0 }), .token => return .none, .i1 => return .false, - else => switch (self.type_items.items[@intFromEnum(ty)].tag) { + else => switch (self.type_items.items[@backingInt(ty)].tag) { .simple, .function, .vararg_function, @@ -11561,13 +11561,13 @@ fn zeroInitConstAssumeCapacity(self: *Builder, ty: Type) Constant { }, } const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .zeroinitializer, .data = @intFromEnum(ty) }, + .{ .tag = .zeroinitializer, .data = @backingInt(ty) }, ); return result.constant; } fn undefConstAssumeCapacity(self: *Builder, ty: Type) Constant { - switch (self.type_items.items[@intFromEnum(ty)].tag) { + switch (self.type_items.items[@backingInt(ty)].tag) { .simple => switch (ty) { .void, .label => unreachable, else => {}, @@ -11576,13 +11576,13 @@ fn undefConstAssumeCapacity(self: *Builder, ty: Type) Constant { else => {}, } const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .undef, .data = @intFromEnum(ty) }, + .{ .tag = .undef, .data = @backingInt(ty) }, ); return result.constant; } fn poisonConstAssumeCapacity(self: *Builder, ty: Type) Constant { - switch (self.type_items.items[@intFromEnum(ty)].tag) { + switch (self.type_items.items[@backingInt(ty)].tag) { .simple => switch (ty) { .void, .label => unreachable, else => {}, @@ -11591,7 +11591,7 @@ fn poisonConstAssumeCapacity(self: *Builder, ty: Type) Constant { else => {}, } const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .poison, .data = @intFromEnum(ty) }, + .{ .tag = .poison, .data = @backingInt(ty) }, ); return result.constant; } @@ -11605,7 +11605,7 @@ fn blockAddrConstAssumeCapacity( builder: *const Builder, pub fn hash(_: @This(), key: Constant.BlockAddress) u32 { return @truncate(std.hash.Wyhash.hash( - comptime std.hash.int(@intFromEnum(Constant.Tag.blockaddress)), + comptime std.hash.int(@backingInt(Constant.Tag.blockaddress)), std.mem.asBytes(&key), )); } @@ -11626,19 +11626,19 @@ fn blockAddrConstAssumeCapacity( .data = self.addConstantExtraAssumeCapacity(data), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn dsoLocalEquivalentConstAssumeCapacity(self: *Builder, function: Function.Index) Constant { const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .dso_local_equivalent, .data = @intFromEnum(function) }, + .{ .tag = .dso_local_equivalent, .data = @backingInt(function) }, ); return result.constant; } fn noCfiConstAssumeCapacity(self: *Builder, function: Function.Index) Constant { const result = self.getOrPutConstantNoExtraAssumeCapacity( - .{ .tag = .no_cfi, .data = @intFromEnum(function) }, + .{ .tag = .no_cfi, .data = @backingInt(function) }, ); return result.constant; } @@ -11735,7 +11735,7 @@ fn castConstAssumeCapacity(self: *Builder, tag: Constant.Tag, val: Constant, ty: builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { return @truncate(std.hash.Wyhash.hash( - std.hash.int(@intFromEnum(key.tag)), + std.hash.int(@backingInt(key.tag)), std.mem.asBytes(&key.cast), )); } @@ -11756,7 +11756,7 @@ fn castConstAssumeCapacity(self: *Builder, tag: Constant.Tag, val: Constant, ty: .data = self.addConstantExtraAssumeCapacity(data.cast), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn gepConstAssumeCapacity( @@ -11810,7 +11810,7 @@ fn gepConstAssumeCapacity( const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { - var hasher = std.hash.Wyhash.init(comptime std.hash.int(@intFromEnum(tag))); + var hasher = std.hash.Wyhash.init(comptime std.hash.int(@backingInt(tag))); hasher.update(std.mem.asBytes(&key.type)); hasher.update(std.mem.asBytes(&key.base)); hasher.update(std.mem.asBytes(&key.inrange)); @@ -11831,7 +11831,7 @@ fn gepConstAssumeCapacity( const data = Key{ .type = ty, .base = base, - .inrange = if (inrange) |index| @enumFromInt(index) else .none, + .inrange = if (inrange) |index| @fromBackingInt(@intCast(index)) else .none, .indices = indices, }; const gop = self.constant_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self }); @@ -11848,7 +11848,7 @@ fn gepConstAssumeCapacity( }); self.constant_extra.appendSliceAssumeCapacity(@ptrCast(indices)); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn binConstAssumeCapacity( @@ -11874,7 +11874,7 @@ fn binConstAssumeCapacity( builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { return @truncate(std.hash.Wyhash.hash( - std.hash.int(@intFromEnum(key.tag)), + std.hash.int(@backingInt(key.tag)), std.mem.asBytes(&key.extra), )); } @@ -11895,7 +11895,7 @@ fn binConstAssumeCapacity( .data = self.addConstantExtraAssumeCapacity(data.extra), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn asmConstAssumeCapacity( @@ -11912,7 +11912,7 @@ fn asmConstAssumeCapacity( builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { return @truncate(std.hash.Wyhash.hash( - std.hash.int(@intFromEnum(key.tag)), + std.hash.int(@backingInt(key.tag)), std.mem.asBytes(&key.extra), )); } @@ -11925,7 +11925,7 @@ fn asmConstAssumeCapacity( }; const data = Key{ - .tag = @enumFromInt(@intFromEnum(Constant.Tag.@"asm") + @as(u4, @bitCast(info))), + .tag = @fromBackingInt(@intCast(@backingInt(Constant.Tag.@"asm") + @as(u4, @bitCast(info)))), .extra = .{ .type = ty, .assembly = assembly, .constraints = constraints }, }; const gop = self.constant_map.getOrPutAssumeCapacityAdapted(data, Adapter{ .builder = self }); @@ -11937,7 +11937,7 @@ fn asmConstAssumeCapacity( .data = self.addConstantExtraAssumeCapacity(data.extra), }); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn ensureUnusedConstantCapacity( @@ -11962,7 +11962,7 @@ fn getOrPutConstantNoExtraAssumeCapacity( builder: *const Builder, pub fn hash(_: @This(), key: Constant.Item) u32 { return @truncate(std.hash.Wyhash.hash( - std.hash.int(@intFromEnum(key.tag)), + std.hash.int(@backingInt(key.tag)), std.mem.asBytes(&key.data), )); } @@ -11976,7 +11976,7 @@ fn getOrPutConstantNoExtraAssumeCapacity( gop.value_ptr.* = {}; self.constant_items.appendAssumeCapacity(item); } - return .{ .new = !gop.found_existing, .constant = @enumFromInt(gop.index) }; + return .{ .new = !gop.found_existing, .constant = @fromBackingInt(@intCast(gop.index)) }; } fn getOrPutConstantAggregateAssumeCapacity( @@ -11993,7 +11993,7 @@ fn getOrPutConstantAggregateAssumeCapacity( const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { - var hasher = std.hash.Wyhash.init(std.hash.int(@intFromEnum(key.tag))); + var hasher = std.hash.Wyhash.init(std.hash.int(@backingInt(key.tag))); hasher.update(std.mem.asBytes(&key.type)); hasher.update(std.mem.sliceAsBytes(key.vals)); return @truncate(hasher.final()); @@ -12020,7 +12020,7 @@ fn getOrPutConstantAggregateAssumeCapacity( }); self.constant_extra.appendSliceAssumeCapacity(@ptrCast(vals)); } - return .{ .new = !gop.found_existing, .constant = @enumFromInt(gop.index) }; + return .{ .new = !gop.found_existing, .constant = @fromBackingInt(@intCast(gop.index)) }; } fn addConstantExtraAssumeCapacity(self: *Builder, extra: anytype) Constant.Item.ExtraIndex { @@ -12030,7 +12030,7 @@ fn addConstantExtraAssumeCapacity(self: *Builder, extra: anytype) Constant.Item. const value = @field(extra, field_name); self.constant_extra.appendAssumeCapacity(switch (field_type) { u32 => value, - String, Type, Constant, Function.Index, Function.Block.Index => @intFromEnum(value), + String, Type, Constant, Function.Index, Function.Block.Index => @backingInt(value), Constant.GetElementPtr.Info => @bitCast(value), else => @compileError("bad field type: " ++ @typeName(field_type)), }); @@ -12073,7 +12073,7 @@ fn constantExtraDataTrail( ) |field_name, field_type, value| @field(result, field_name) = switch (field_type) { u32 => value, - String, Type, Constant, Function.Index, Function.Block.Index => @enumFromInt(value), + String, Type, Constant, Function.Index, Function.Block.Index => @fromBackingInt(@intCast(value)), Constant.GetElementPtr.Info => @bitCast(value), else => @compileError("bad field type: " ++ @typeName(field_type)), }; @@ -12108,7 +12108,7 @@ fn addMetadataExtraAssumeCapacity(self: *Builder, extra: anytype) Metadata.Item. const value = @field(extra, field_name); self.metadata_extra.appendAssumeCapacity(switch (field_type) { u32 => value, - Metadata.String, Metadata.String.Optional, Variable.Index, Value => @intFromEnum(value), + Metadata.String, Metadata.String.Optional, Variable.Index, Value => @backingInt(value), Metadata, Metadata.Optional, Metadata.DIFlags => @bitCast(value), else => @compileError("bad field type: " ++ @typeName(field_type)), }); @@ -12151,7 +12151,7 @@ fn metadataExtraDataTrail( ) |field_name, field_type, value| @field(result, field_name) = switch (field_type) { u32 => value, - Metadata.String, Metadata.String.Optional, Variable.Index, Value => @enumFromInt(value), + Metadata.String, Metadata.String.Optional, Variable.Index, Value => @fromBackingInt(@intCast(value)), Metadata, Metadata.Optional, Metadata.DIFlags => @bitCast(value), else => @compileError("bad field type: " ++ @typeName(field_type)), }; @@ -12181,7 +12181,7 @@ pub fn metadataString(self: *Builder, bytes: []const u8) Allocator.Error!Metadat @intCast(self.metadata_string_bytes.items.len), ); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn metadataStringFromStrtabString( @@ -12230,7 +12230,7 @@ pub fn trailingMetadataStringAssumeCapacity(self: *Builder) Metadata.String { } else { self.metadata_string_indices.appendAssumeCapacity(@intCast(self.metadata_string_bytes.items.len)); } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn addNamedMetadata(self: *Builder, name: String, operands: []const Metadata) Allocator.Error!void { @@ -12662,7 +12662,7 @@ fn metadataSimpleAssumeCapacity(self: *Builder, tag: Metadata.Tag, value: anytyp const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { - var hasher = std.hash.Wyhash.init(std.hash.int(@intFromEnum(key.tag))); + var hasher = std.hash.Wyhash.init(std.hash.int(@backingInt(key.tag))); inline for (comptime std.meta.fieldNames(@TypeOf(value))) |field_name| { hasher.update(std.mem.asBytes(&@field(key.value, field_name))); } @@ -12759,8 +12759,8 @@ fn debugSubprogramAssumeCapacity( compile_unit: ?Metadata, ) Metadata { assert(!self.strip); - const tag: Metadata.Tag = @enumFromInt(@intFromEnum(Metadata.Tag.subprogram) + - @as(u3, @truncate(@as(u32, @bitCast(options.sp_flags)) >> 2))); + const tag: Metadata.Tag = @fromBackingInt(@intCast(@backingInt(Metadata.Tag.subprogram) + + @as(u3, @truncate(@as(u32, @bitCast(options.sp_flags)) >> 2)))); return self.metadataDistinctAssumeCapacity(tag, Metadata.Subprogram{ .file = .wrap(file), .name = .wrap(name), @@ -13105,7 +13105,7 @@ fn debugEnumeratorAssumeCapacity( const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { - var hasher = std.hash.Wyhash.init(std.hash.int(@intFromEnum(key.tag))); + var hasher = std.hash.Wyhash.init(std.hash.int(@backingInt(key.tag))); hasher.update(std.mem.asBytes(&key.name)); hasher.update(std.mem.asBytes(&key.bit_width)); hasher.update(std.mem.sliceAsBytes(key.value.limbs)); @@ -13178,7 +13178,7 @@ fn debugExpressionAssumeCapacity(self: *Builder, elements: []const u32) Metadata builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { var hasher = - comptime std.hash.Wyhash.init(std.hash.int(@intFromEnum(Metadata.Tag.expression))); + comptime std.hash.Wyhash.init(std.hash.int(@backingInt(Metadata.Tag.expression))); hasher.update(std.mem.sliceAsBytes(key.elements)); return @truncate(hasher.final()); } @@ -13222,7 +13222,7 @@ fn metadataTupleOptionalsAssumeCapacity(self: *Builder, elements: []const Metada const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Key) u32 { - var hasher = comptime std.hash.Wyhash.init(std.hash.int(@intFromEnum(Metadata.Tag.tuple))); + var hasher = comptime std.hash.Wyhash.init(std.hash.int(@backingInt(Metadata.Tag.tuple))); hasher.update(std.mem.sliceAsBytes(key.elements)); return @truncate(hasher.final()); } @@ -13338,14 +13338,14 @@ fn metadataConstantAssumeCapacity(self: *Builder, constant: Constant) Metadata { const Adapter = struct { builder: *const Builder, pub fn hash(_: @This(), key: Constant) u32 { - var hasher = comptime std.hash.Wyhash.init(std.hash.int(@intFromEnum(Metadata.Tag.constant))); + var hasher = comptime std.hash.Wyhash.init(std.hash.int(@backingInt(Metadata.Tag.constant))); hasher.update(std.mem.asBytes(&key)); return @truncate(hasher.final()); } pub fn eql(ctx: @This(), lhs_key: Constant, _: void, rhs_index: usize) bool { if (Metadata.Tag.constant != ctx.builder.metadata_items.items(.tag)[rhs_index]) return false; - const rhs_data: Constant = @enumFromInt(ctx.builder.metadata_items.items(.data)[rhs_index]); + const rhs_data: Constant = @fromBackingInt(@intCast(ctx.builder.metadata_items.items(.data)[rhs_index])); return rhs_data == lhs_key; } }; @@ -13360,7 +13360,7 @@ fn metadataConstantAssumeCapacity(self: *Builder, constant: Constant) Metadata { gop.value_ptr.* = {}; self.metadata_items.appendAssumeCapacity(.{ .tag = .constant, - .data = @intFromEnum(constant), + .data = @backingInt(constant), }); } return .{ .index = @intCast(gop.index), .kind = .node }; @@ -13447,10 +13447,10 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco try type_block.writeAbbrev(TypeBlock.NumEntry{ .num = @intCast(self.type_items.items.len) }); for (self.type_items.items, 0..) |item, i| { - const ty: Type = @enumFromInt(i); + const ty: Type = @fromBackingInt(@intCast(i)); switch (item.tag) { - .simple => try type_block.writeAbbrev(TypeBlock.Simple{ .code = @enumFromInt(item.data) }), + .simple => try type_block.writeAbbrev(TypeBlock.Simple{ .code = @fromBackingInt(@intCast(item.data)) }), .integer => try type_block.writeAbbrev(TypeBlock.Integer{ .width = item.data }), .structure, .packed_structure, @@ -13475,7 +13475,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco switch (extra.body) { .none => try type_block.writeAbbrev(TypeBlock.Opaque{}), else => { - const real_struct = self.type_items.items[@intFromEnum(extra.body)]; + const real_struct = self.type_items.items[@backingInt(extra.body)]; const is_packed: bool = switch (real_struct.tag) { .structure => false, .packed_structure => true, @@ -13648,7 +13648,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco => { try record.ensureUnusedCapacity(self.gpa, 2); record.appendAssumeCapacity(0); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); }, .byval, .byref, @@ -13659,15 +13659,15 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco => |ty| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(6); - record.appendAssumeCapacity(@intFromEnum(kind)); - record.appendAssumeCapacity(@intFromEnum(ty)); + record.appendAssumeCapacity(@backingInt(kind)); + record.appendAssumeCapacity(@backingInt(ty)); }, .@"align", .alignstack, => |alignment| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); record.appendAssumeCapacity(alignment.resolve(self).toByteUnits() orelse 0); }, .dereferenceable, @@ -13675,44 +13675,44 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco => |size| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); record.appendAssumeCapacity(size); }, .nofpclass => |fpclass| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); record.appendAssumeCapacity(@as(u32, @bitCast(fpclass))); }, .allockind => |allockind| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); record.appendAssumeCapacity(@as(u32, @bitCast(allockind))); }, .allocsize => |allocsize| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); record.appendAssumeCapacity(@bitCast(allocsize.toLlvm())); }, .memory => |memory| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); record.appendAssumeCapacity(@as(u32, @bitCast(memory))); }, .uwtable => |uwtable| if (uwtable != .none) { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); - record.appendAssumeCapacity(@intFromEnum(uwtable)); + record.appendAssumeCapacity(@backingInt(kind)); + record.appendAssumeCapacity(@backingInt(uwtable)); }, .vscale_range => |vscale_range| { try record.ensureUnusedCapacity(self.gpa, 3); record.appendAssumeCapacity(1); - record.appendAssumeCapacity(@intFromEnum(kind)); + record.appendAssumeCapacity(@backingInt(kind)); record.appendAssumeCapacity(@bitCast(vscale_range.toLlvm())); }, .string => |string_attr| { @@ -13787,7 +13787,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (self.variables.items, 0..) |variable, variable_i| { // Skip the variable if its global has been repurposed for something else. switch (variable.global.ptrConst(self).kind) { - .variable => |v| if (@intFromEnum(v) != variable_i) continue, + .variable => |v| if (@backingInt(v) != variable_i) continue, else => continue, } @@ -13797,7 +13797,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (self.functions.items, 0..) |function, function_i| { // Skip the function if its global has been repurposed for something else. switch (function.global.ptrConst(self).kind) { - .function => |f| if (@intFromEnum(f) != function_i) continue, + .function => |f| if (@backingInt(f) != function_i) continue, else => continue, } @@ -13807,7 +13807,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (self.aliases.items, 0..) |alias, alias_i| { // Skip the alias if its global has been repurposed for something else. switch (alias.global.ptrConst(self).kind) { - .alias => |a| if (@intFromEnum(a) != alias_i) continue, + .alias => |a| if (@backingInt(a) != alias_i) continue, else => continue, } @@ -13854,7 +13854,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (self.variables.items, 0..) |variable, variable_i| { // Skip the variable if its global has been repurposed for something else. switch (variable.global.ptrConst(self).kind) { - .variable => |v| if (@intFromEnum(v) != variable_i) continue, + .variable => |v| if (@backingInt(v) != variable_i) continue, else => continue, } @@ -13905,7 +13905,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (self.functions.items, 0..) |func, func_i| { // Skip the function if its global has been repurposed for something else. switch (func.global.ptrConst(self).kind) { - .function => |f| if (@intFromEnum(f) != func_i) continue, + .function => |f| if (@backingInt(f) != func_i) continue, else => continue, } @@ -13950,7 +13950,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (self.aliases.items, 0..) |alias, alias_i| { // Skip the alias if its global has been repurposed for something else. switch (alias.global.ptrConst(self).kind) { - .alias => |a| if (@intFromEnum(a) != alias_i) continue, + .alias => |a| if (@backingInt(a) != alias_i) continue, else => continue, } @@ -13983,7 +13983,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco const datas = self.constant_items.items(.data); for (0..self.constant_items.len) |index| { record.clearRetainingCapacity(); - const constant: Constant = @enumFromInt(index); + const constant: Constant = @fromBackingInt(@intCast(index)); const constant_type = constant.typeOf(self); if (constant_type != current_type) { try constants_block.writeAbbrev(ConstantsBlock.SetType{ .type_id = constant_type }); @@ -14096,7 +14096,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco } }, .string => { - const str: String = @enumFromInt(data); + const str: String = @fromBackingInt(@intCast(data)); if (str == .none) { try constants_block.writeAbbrev(ConstantsBlock.Null{}); } else { @@ -14143,13 +14143,13 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco const indices = extra.trail.next(extra.data.info.indices_len, Constant, self); try record.ensureUnusedCapacity(self.gpa, 1 + 2 + 2 * indices.len); - record.appendAssumeCapacity(@intFromEnum(extra.data.type)); + record.appendAssumeCapacity(@backingInt(extra.data.type)); - record.appendAssumeCapacity(@intFromEnum(extra.data.base.typeOf(self))); + record.appendAssumeCapacity(@backingInt(extra.data.base.typeOf(self))); record.appendAssumeCapacity(constant_adapter.getConstantIndex(extra.data.base)); for (indices) |i| { - record.appendAssumeCapacity(@intFromEnum(i.typeOf(self))); + record.appendAssumeCapacity(@backingInt(i.typeOf(self))); record.appendAssumeCapacity(constant_adapter.getConstantIndex(i)); } @@ -14183,7 +14183,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco try record.ensureUnusedCapacity(self.gpa, 4 + assembly_slice.len + constraints_slice.len); - record.appendAssumeCapacity(@intFromEnum(extra.type)); + record.appendAssumeCapacity(@backingInt(extra.type)); record.appendAssumeCapacity(switch (tag) { .@"asm" => 0, .@"asm sideeffect" => 0b0001, @@ -14217,13 +14217,13 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco try constants_block.writeAbbrev(ConstantsBlock.BlockAddress{ .type_id = extra.function.typeOf(self), .function = constant_adapter.getConstantIndex(extra.function.toConst(self)), - .block = @intFromEnum(extra.block), + .block = @backingInt(extra.block), }); }, .dso_local_equivalent, .no_cfi, => |tag| { - const function: Function.Index = @enumFromInt(data); + const function: Function.Index = @fromBackingInt(@intCast(data)); try constants_block.writeAbbrev(ConstantsBlock.DsoLocalEquivalentOrNoCfi{ .code = switch (tag) { .dso_local_equivalent => .DSO_LOCAL_EQUIVALENT, @@ -14384,7 +14384,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco .ty = extra.ty, .scope_line = extra.scope_line, .sp_flags = @bitCast(@as(u32, @as(u3, @intCast( - @intFromEnum(kind) - @intFromEnum(Metadata.Tag.subprogram), + @backingInt(kind) - @backingInt(Metadata.Tag.subprogram), ))) << 2), .flags = extra.di_flags, .compile_unit = extra.compile_unit, @@ -14528,7 +14528,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco else -%val << 1 | 1); } - try metadata_block.writeUnabbrev(@intFromEnum(MetadataBlock.Code.ENUMERATOR), record.items); + try metadata_block.writeUnabbrev(@backingInt(MetadataBlock.Code.ENUMERATOR), record.items); continue; }; try metadata_block.writeAbbrevAdapted(MetadataBlock.Enumerator{ @@ -14606,7 +14606,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco }, metadata_adapter); }, .constant => { - const constant: Constant = @enumFromInt(data); + const constant: Constant = @fromBackingInt(@intCast(data)); try metadata_block.writeAbbrevAdapted(MetadataBlock.Constant{ .ty = constant.typeOf(self), .constant = constant, @@ -14663,28 +14663,28 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco var block_info_block = try module_block.enterSubBlock(BlockInfoBlock, true); try block_info_block.writeUnabbrev(BlockInfoBlock.set_block_id, &.{ - @intFromEnum(ir.ModuleBlock.FunctionBlock.id), + @backingInt(ir.ModuleBlock.FunctionBlock.id), }); inline for (ir.ModuleBlock.FunctionBlock.abbrevs) |abbrev| { try block_info_block.defineAbbrev(&abbrev.ops); } try block_info_block.writeUnabbrev(BlockInfoBlock.set_block_id, &.{ - @intFromEnum(ir.ModuleBlock.FunctionBlock.ValueSymtabBlock.id), + @backingInt(ir.ModuleBlock.FunctionBlock.ValueSymtabBlock.id), }); inline for (ir.ModuleBlock.FunctionBlock.ValueSymtabBlock.abbrevs) |abbrev| { try block_info_block.defineAbbrev(&abbrev.ops); } try block_info_block.writeUnabbrev(BlockInfoBlock.set_block_id, &.{ - @intFromEnum(ir.ModuleBlock.FunctionBlock.MetadataBlock.id), + @backingInt(ir.ModuleBlock.FunctionBlock.MetadataBlock.id), }); inline for (ir.ModuleBlock.FunctionBlock.MetadataBlock.abbrevs) |abbrev| { try block_info_block.defineAbbrev(&abbrev.ops); } try block_info_block.writeUnabbrev(BlockInfoBlock.set_block_id, &.{ - @intFromEnum(ir.ModuleBlock.FunctionBlock.MetadataAttachmentBlock.id), + @backingInt(ir.ModuleBlock.FunctionBlock.MetadataAttachmentBlock.id), }); inline for (ir.ModuleBlock.FunctionBlock.MetadataAttachmentBlock.abbrevs) |abbrev| { try block_info_block.defineAbbrev(&abbrev.ops); @@ -14760,7 +14760,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (self.functions.items, 0..) |func, func_index| { // Skip the function if its global has been repurposed for something else. switch (func.global.ptrConst(self).kind) { - .function => |f| if (@intFromEnum(f) != func_index) continue, + .function => |f| if (@backingInt(f) != func_index) continue, else => continue, } @@ -14775,7 +14775,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco var adapter: FunctionAdapter = .{ .metadata_adapter = metadata_adapter, .func = &func, - .instruction_index = @enumFromInt(0), + .instruction_index = @fromBackingInt(@intCast(0)), }; // Emit function level metadata block @@ -14785,8 +14785,8 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco for (func.debug_values) |value| { try metadata_block.writeAbbrev(MetadataBlock.Value{ - .ty = value.typeOf(@enumFromInt(func_index), self), - .value = @enumFromInt(adapter.getValueIndex(value.toValue())), + .ty = value.typeOf(@fromBackingInt(@intCast(func_index)), self), + .value = @fromBackingInt(@intCast(adapter.getValueIndex(value.toValue()))), }); } @@ -14800,7 +14800,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco var block_incoming_len: u32 = undefined; for (tags, datas, 0..) |tag, data, instr_index| { - adapter.instruction_index = @enumFromInt(instr_index); + adapter.instruction_index = @fromBackingInt(@intCast(instr_index)); record.clearRetainingCapacity(); switch (tag) { @@ -14962,7 +14962,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco const alignment = extra.info.alignment.toLlvm(); try function_block.writeAbbrev(FunctionBlock.Alloca{ .inst_type = extra.type, - .len_type = extra.len.typeOf(@enumFromInt(func_index), self), + .len_type = extra.len.typeOf(@fromBackingInt(@intCast(func_index)), self), .len_value = adapter.getValueIndex(extra.len), .flags = .{ .align_lower = @truncate(alignment), @@ -15068,10 +15068,10 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco }); }, .fneg => try function_block.writeAbbrev(FunctionBlock.FNeg{ - .val = adapter.getOffsetValueIndex(@enumFromInt(data)), + .val = adapter.getOffsetValueIndex(@fromBackingInt(@intCast(data))), }), .@"fneg fast" => try function_block.writeAbbrev(FunctionBlock.FNegFast{ - .val = adapter.getOffsetValueIndex(@enumFromInt(data)), + .val = adapter.getOffsetValueIndex(@fromBackingInt(@intCast(data))), .fast_math = FastMath.fast, }), .extractvalue => { @@ -15096,7 +15096,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco extra.trail.next(extra.data.targets_len, Function.Block.Index, &func); try function_block.writeAbbrevAdapted( FunctionBlock.IndirectBr{ - .ty = extra.data.addr.typeOf(@enumFromInt(func_index), self), + .ty = extra.data.addr.typeOf(@fromBackingInt(@intCast(func_index)), self), .addr = extra.data.addr, .targets = targets, }, @@ -15208,8 +15208,8 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco .br_cond => { const extra = func.extraData(Function.Instruction.BrCond, data); try function_block.writeAbbrev(FunctionBlock.BrConditional{ - .then_block = @intFromEnum(extra.then), - .else_block = @intFromEnum(extra.@"else"), + .then_block = @backingInt(extra.then), + .else_block = @backingInt(extra.@"else"), .condition = adapter.getOffsetValueIndex(extra.cond), }); }, @@ -15219,19 +15219,19 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco try record.ensureUnusedCapacity(self.gpa, 3 + extra.data.cases_len * 2); // Conditional type - record.appendAssumeCapacity(@intFromEnum(extra.data.val.typeOf(@enumFromInt(func_index), self))); + record.appendAssumeCapacity(@backingInt(extra.data.val.typeOf(@fromBackingInt(@intCast(func_index)), self))); // Conditional record.appendAssumeCapacity(adapter.getOffsetValueIndex(extra.data.val)); // Default block - record.appendAssumeCapacity(@intFromEnum(extra.data.default)); + record.appendAssumeCapacity(@backingInt(extra.data.default)); const vals = extra.trail.next(extra.data.cases_len, Constant, &func); const blocks = extra.trail.next(extra.data.cases_len, Function.Block.Index, &func); for (vals, blocks) |val, block| { record.appendAssumeCapacity(adapter.metadata_adapter.constant_adapter.getConstantIndex(val)); - record.appendAssumeCapacity(@intFromEnum(block)); + record.appendAssumeCapacity(@backingInt(block)); } try function_block.writeUnabbrev(12, record.items); @@ -15239,7 +15239,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco .va_arg => { const extra = func.extraData(Function.Instruction.VaArg, data); try function_block.writeAbbrev(FunctionBlock.VaArg{ - .list_type = extra.list.typeOf(@enumFromInt(func_index), self), + .list_type = extra.list.typeOf(@fromBackingInt(@intCast(func_index)), self), .list = adapter.getOffsetValueIndex(extra.list), .type = extra.type, }); @@ -15256,14 +15256,14 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco 1 + block_incoming_len * 2 + @intFromBool(kind == .@"phi fast"), ); - record.appendAssumeCapacity(@intFromEnum(extra.data.type)); + record.appendAssumeCapacity(@backingInt(extra.data.type)); for (vals, blocks) |val, block| { const offset_value = adapter.getOffsetValueSignedIndex(val); const abs_value: u32 = @intCast(@abs(offset_value)); const signed_vbr = if (offset_value > 0) abs_value << 1 else ((abs_value << 1) | 1); record.appendAssumeCapacity(signed_vbr); - record.appendAssumeCapacity(@intFromEnum(block)); + record.appendAssumeCapacity(@backingInt(block)); } if (kind == .@"phi fast") record.appendAssumeCapacity(@as(u8, @bitCast(FastMath{}))); @@ -15271,7 +15271,7 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco try function_block.writeUnabbrev(16, record.items); }, .ret => try function_block.writeAbbrev(FunctionBlock.Ret{ - .val = adapter.getOffsetValueIndex(@enumFromInt(data)), + .val = adapter.getOffsetValueIndex(@fromBackingInt(@intCast(data))), }), .@"ret void" => try function_block.writeAbbrev(FunctionBlock.RetVoid{}), .atomicrmw => { diff --git a/lib/std/zig/llvm/bitcode_writer.zig b/lib/std/zig/llvm/bitcode_writer.zig index b0f24065b9e13815b963f61631fd088341570d3e..98c8489172ee3960ab4502bd9ccbb360ed519735 100644 --- a/lib/std/zig/llvm/bitcode_writer.zig +++ b/lib/std/zig/llvm/bitcode_writer.zig @@ -423,7 +423,7 @@ fn BufType(comptime T: type, comptime min_len: usize) type { fn bufValue(value: anytype, comptime min_len: usize) BufType(@TypeOf(value), min_len) { return switch (@typeInfo(@TypeOf(value))) { .comptime_int, .int => @intCast(value), - .@"enum" => @intFromEnum(value), + .@"enum" => @backingInt(value), .bool => @intFromBool(value), .@"struct" => @intCast(@as(@Int(.unsigned, @bitSizeOf(@TypeOf(value))), @bitCast(value))), else => unreachable, diff --git a/lib/std/zig/llvm/ir.zig b/lib/std/zig/llvm/ir.zig index 397ea34b87041fa8223ff8723cb03c87c5a94b6f..dd5d658df72f713707a23045fc5ec9304500468e 100644 --- a/lib/std/zig/llvm/ir.zig +++ b/lib/std/zig/llvm/ir.zig @@ -189,7 +189,7 @@ pub const ModuleBlock = struct { pub const Version = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.Code.VERSION) }, + .{ .literal = @backingInt(ModuleBlock.Code.VERSION) }, .{ .literal = 2 }, }; }; @@ -211,7 +211,7 @@ pub const ModuleBlock = struct { }; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.Code.GLOBALVAR) }, // Code + .{ .literal = @backingInt(ModuleBlock.Code.GLOBALVAR) }, // Code .{ .vbr = 16 }, // strtab_offset .{ .vbr = 16 }, // strtab_size .{ .fixed_runtime = Builder.Type }, @@ -247,7 +247,7 @@ pub const ModuleBlock = struct { pub const Function = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.Code.FUNCTION) }, // Code + .{ .literal = @backingInt(ModuleBlock.Code.FUNCTION) }, // Code .{ .vbr = 16 }, // strtab_offset .{ .vbr = 16 }, // strtab_size .{ .fixed_runtime = Builder.Type }, @@ -286,7 +286,7 @@ pub const ModuleBlock = struct { pub const Alias = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.Code.ALIAS) }, // Code + .{ .literal = @backingInt(ModuleBlock.Code.ALIAS) }, // Code .{ .vbr = 16 }, // strtab_offset .{ .vbr = 16 }, // strtab_size .{ .fixed_runtime = Builder.Type }, @@ -330,7 +330,7 @@ pub const ModuleBlock = struct { pub const Entry = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ParamattrBlock.Code.ENTRY) }, + .{ .literal = @backingInt(ModuleBlock.ParamattrBlock.Code.ENTRY) }, .{ .array_vbr = 8 }, }; group_indices: []const u64, @@ -451,7 +451,7 @@ pub const ModuleBlock = struct { pub const SetType = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.SETTYPE) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.SETTYPE) }, .{ .fixed_runtime = Builder.Type }, }; type_id: Builder.Type, @@ -459,25 +459,25 @@ pub const ModuleBlock = struct { pub const Null = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.NULL) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.NULL) }, }; }; pub const Undef = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.UNDEF) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.UNDEF) }, }; }; pub const Poison = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.POISON) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.POISON) }, }; }; pub const Integer = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.INTEGER) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.INTEGER) }, .{ .vbr = 16 }, }; value: u64, @@ -485,7 +485,7 @@ pub const ModuleBlock = struct { pub const Half = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.FLOAT) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.FLOAT) }, .{ .fixed = 16 }, }; value: u16, @@ -493,7 +493,7 @@ pub const ModuleBlock = struct { pub const Float = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.FLOAT) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.FLOAT) }, .{ .fixed = 32 }, }; value: u32, @@ -501,7 +501,7 @@ pub const ModuleBlock = struct { pub const Double = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.FLOAT) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.FLOAT) }, .{ .vbr = 6 }, }; value: u64, @@ -509,7 +509,7 @@ pub const ModuleBlock = struct { pub const Fp80 = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.FLOAT) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.FLOAT) }, .{ .vbr = 6 }, .{ .vbr = 6 }, }; @@ -519,7 +519,7 @@ pub const ModuleBlock = struct { pub const Fp128 = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.FLOAT) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.FLOAT) }, .{ .vbr = 6 }, .{ .vbr = 6 }, }; @@ -529,7 +529,7 @@ pub const ModuleBlock = struct { pub const Aggregate = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.AGGREGATE) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.AGGREGATE) }, .{ .array_fixed = 32 }, }; values: []const Builder.Constant, @@ -537,7 +537,7 @@ pub const ModuleBlock = struct { pub const String = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.STRING) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.STRING) }, .{ .array_fixed = 8 }, }; string: []const u8, @@ -545,7 +545,7 @@ pub const ModuleBlock = struct { pub const CString = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CSTRING) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CSTRING) }, .{ .array_fixed = 8 }, }; string: []const u8, @@ -554,7 +554,7 @@ pub const ModuleBlock = struct { pub const Cast = struct { const CastOpcode = Builder.CastOpcode; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CE_CAST) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CE_CAST) }, .{ .fixed = @bitSizeOf(CastOpcode) }, .{ .fixed_runtime = Builder.Type }, ConstantAbbrev, @@ -568,7 +568,7 @@ pub const ModuleBlock = struct { pub const Binary = struct { const BinaryOpcode = Builder.BinaryOpcode; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CE_BINOP) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CE_BINOP) }, .{ .fixed = @bitSizeOf(BinaryOpcode) }, ConstantAbbrev, ConstantAbbrev, @@ -581,7 +581,7 @@ pub const ModuleBlock = struct { pub const Cmp = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CE_CMP) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CE_CMP) }, .{ .fixed_runtime = Builder.Type }, ConstantAbbrev, ConstantAbbrev, @@ -596,7 +596,7 @@ pub const ModuleBlock = struct { pub const ExtractElement = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CE_EXTRACTELT) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CE_EXTRACTELT) }, .{ .fixed_runtime = Builder.Type }, ConstantAbbrev, .{ .fixed_runtime = Builder.Type }, @@ -611,7 +611,7 @@ pub const ModuleBlock = struct { pub const InsertElement = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CE_INSERTELT) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CE_INSERTELT) }, ConstantAbbrev, ConstantAbbrev, .{ .fixed_runtime = Builder.Type }, @@ -626,7 +626,7 @@ pub const ModuleBlock = struct { pub const ShuffleVector = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CE_SHUFFLEVEC) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CE_SHUFFLEVEC) }, ValueAbbrev, ValueAbbrev, ValueAbbrev, @@ -639,7 +639,7 @@ pub const ModuleBlock = struct { pub const ShuffleVectorEx = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.CE_SHUFVEC_EX) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.CE_SHUFVEC_EX) }, .{ .fixed_runtime = Builder.Type }, ValueAbbrev, ValueAbbrev, @@ -654,7 +654,7 @@ pub const ModuleBlock = struct { pub const BlockAddress = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.ConstantsBlock.Code.BLOCKADDRESS) }, + .{ .literal = @backingInt(ModuleBlock.ConstantsBlock.Code.BLOCKADDRESS) }, .{ .fixed_runtime = Builder.Type }, ConstantAbbrev, BlockAbbrev, @@ -867,7 +867,7 @@ pub const ModuleBlock = struct { pub const DeclareBlocks = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.DECLAREBLOCKS) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.DECLAREBLOCKS) }, .{ .vbr = 8 }, }; num_blocks: usize, @@ -884,7 +884,7 @@ pub const ModuleBlock = struct { no_tail: bool = false, }; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_CALL) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_CALL) }, .{ .fixed_runtime = Builder.FunctionAttributes }, .{ .fixed = @bitSizeOf(CallType) }, .{ .fixed_runtime = Builder.Type }, @@ -912,7 +912,7 @@ pub const ModuleBlock = struct { }; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_CALL) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_CALL) }, .{ .fixed_runtime = Builder.FunctionAttributes }, .{ .fixed = @bitSizeOf(CallType) }, .{ .fixed = @bitSizeOf(Builder.FastMath) }, @@ -931,7 +931,7 @@ pub const ModuleBlock = struct { pub const FNeg = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_UNOP) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_UNOP) }, ValueAbbrev, .{ .literal = 0 }, }; @@ -941,7 +941,7 @@ pub const ModuleBlock = struct { pub const FNegFast = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_UNOP) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_UNOP) }, ValueAbbrev, .{ .literal = 0 }, .{ .fixed = @bitSizeOf(Builder.FastMath) }, @@ -954,7 +954,7 @@ pub const ModuleBlock = struct { pub const Binary = struct { const BinaryOpcode = Builder.BinaryOpcode; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(BinaryOpcode) }, @@ -968,7 +968,7 @@ pub const ModuleBlock = struct { pub const BinaryNoWrap = struct { const BinaryOpcode = Builder.BinaryOpcode; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(BinaryOpcode) }, @@ -987,7 +987,7 @@ pub const ModuleBlock = struct { pub const BinaryExact = struct { const BinaryOpcode = Builder.BinaryOpcode; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(BinaryOpcode) }, @@ -1002,7 +1002,7 @@ pub const ModuleBlock = struct { pub const BinaryFast = struct { const BinaryOpcode = Builder.BinaryOpcode; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_BINOP) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(BinaryOpcode) }, @@ -1018,7 +1018,7 @@ pub const ModuleBlock = struct { pub const Cmp = struct { const CmpPredicate = Builder.CmpPredicate; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_CMP2) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_CMP2) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(CmpPredicate) }, @@ -1032,7 +1032,7 @@ pub const ModuleBlock = struct { pub const CmpFast = struct { const CmpPredicate = Builder.CmpPredicate; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_CMP2) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_CMP2) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(CmpPredicate) }, @@ -1047,7 +1047,7 @@ pub const ModuleBlock = struct { pub const Select = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_VSELECT) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_VSELECT) }, ValueAbbrev, ValueAbbrev, ValueAbbrev, @@ -1060,7 +1060,7 @@ pub const ModuleBlock = struct { pub const SelectFast = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_VSELECT) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_VSELECT) }, ValueAbbrev, ValueAbbrev, ValueAbbrev, @@ -1076,7 +1076,7 @@ pub const ModuleBlock = struct { pub const Cast = struct { const CastOpcode = Builder.CastOpcode; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_CAST) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_CAST) }, ValueAbbrev, .{ .fixed_runtime = Builder.Type }, .{ .fixed = @bitSizeOf(CastOpcode) }, @@ -1093,10 +1093,10 @@ pub const ModuleBlock = struct { no_signed_wrap: bool, }; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_CAST) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_CAST) }, ValueAbbrev, .{ .fixed_runtime = Builder.Type }, - .{ .literal = @intFromEnum(Builder.CastOpcode.trunc) }, + .{ .literal = @backingInt(Builder.CastOpcode.trunc) }, .{ .fixed = @bitSizeOf(Flags) }, }; @@ -1114,7 +1114,7 @@ pub const ModuleBlock = struct { align_upper: u3, }; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_ALLOCA) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_ALLOCA) }, .{ .fixed_runtime = Builder.Type }, .{ .fixed_runtime = Builder.Type }, ValueAbbrev, @@ -1129,13 +1129,13 @@ pub const ModuleBlock = struct { pub const RetVoid = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_RET) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_RET) }, }; }; pub const Ret = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_RET) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_RET) }, ValueAbbrev, }; val: u32, @@ -1143,7 +1143,7 @@ pub const ModuleBlock = struct { pub const GetElementPtr = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_GEP) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_GEP) }, .{ .fixed = 1 }, .{ .fixed_runtime = Builder.Type }, ValueAbbrev, @@ -1158,7 +1158,7 @@ pub const ModuleBlock = struct { pub const ExtractValue = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_EXTRACTVAL) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_EXTRACTVAL) }, ValueAbbrev, ValueArrayAbbrev, }; @@ -1169,7 +1169,7 @@ pub const ModuleBlock = struct { pub const InsertValue = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_INSERTVAL) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_INSERTVAL) }, ValueAbbrev, ValueAbbrev, ValueArrayAbbrev, @@ -1182,7 +1182,7 @@ pub const ModuleBlock = struct { pub const ExtractElement = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_EXTRACTELT) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_EXTRACTELT) }, ValueAbbrev, ValueAbbrev, }; @@ -1193,7 +1193,7 @@ pub const ModuleBlock = struct { pub const InsertElement = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_INSERTELT) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_INSERTELT) }, ValueAbbrev, ValueAbbrev, ValueAbbrev, @@ -1206,7 +1206,7 @@ pub const ModuleBlock = struct { pub const ShuffleVector = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_SHUFFLEVEC) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_SHUFFLEVEC) }, ValueAbbrev, ValueAbbrev, ValueAbbrev, @@ -1219,13 +1219,13 @@ pub const ModuleBlock = struct { pub const Unreachable = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_UNREACHABLE) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_UNREACHABLE) }, }; }; pub const Load = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_LOAD) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_LOAD) }, ValueAbbrev, .{ .fixed_runtime = Builder.Type }, .{ .fixed = @bitSizeOf(Builder.Alignment) }, @@ -1239,7 +1239,7 @@ pub const ModuleBlock = struct { pub const LoadAtomic = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_LOADATOMIC) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_LOADATOMIC) }, ValueAbbrev, .{ .fixed_runtime = Builder.Type }, .{ .fixed = @bitSizeOf(Builder.Alignment) }, @@ -1257,7 +1257,7 @@ pub const ModuleBlock = struct { pub const Store = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_STORE) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_STORE) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(Builder.Alignment) }, @@ -1271,7 +1271,7 @@ pub const ModuleBlock = struct { pub const StoreAtomic = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_STOREATOMIC) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_STOREATOMIC) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(Builder.Alignment) }, @@ -1289,7 +1289,7 @@ pub const ModuleBlock = struct { pub const BrUnconditional = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_BR) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_BR) }, BlockAbbrev, }; block: u32, @@ -1297,7 +1297,7 @@ pub const ModuleBlock = struct { pub const BrConditional = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_BR) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_BR) }, BlockAbbrev, BlockAbbrev, BlockAbbrev, @@ -1309,7 +1309,7 @@ pub const ModuleBlock = struct { pub const VaArg = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_VAARG) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_VAARG) }, .{ .fixed_runtime = Builder.Type }, ValueAbbrev, .{ .fixed_runtime = Builder.Type }, @@ -1321,7 +1321,7 @@ pub const ModuleBlock = struct { pub const AtomicRmw = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_ATOMICRMW) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_ATOMICRMW) }, ValueAbbrev, ValueAbbrev, .{ .fixed = @bitSizeOf(Builder.Function.Instruction.AtomicRmw.Operation) }, @@ -1341,7 +1341,7 @@ pub const ModuleBlock = struct { pub const CmpXchg = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_CMPXCHG) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_CMPXCHG) }, ValueAbbrev, ValueAbbrev, ValueAbbrev, @@ -1365,7 +1365,7 @@ pub const ModuleBlock = struct { pub const Fence = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_FENCE) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_FENCE) }, .{ .fixed = @bitSizeOf(Builder.AtomicOrdering) }, .{ .fixed = @bitSizeOf(Builder.SyncScope) }, }; @@ -1375,7 +1375,7 @@ pub const ModuleBlock = struct { pub const DebugLoc = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.DEBUG_LOC) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.DEBUG_LOC) }, LineAbbrev, ColumnAbbrev, MetadataAbbrev, @@ -1390,20 +1390,20 @@ pub const ModuleBlock = struct { pub const DebugLocAgain = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.DEBUG_LOC_AGAIN) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.DEBUG_LOC_AGAIN) }, }; }; pub const ColdOperandBundle = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.OPERAND_BUNDLE) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.OPERAND_BUNDLE) }, .{ .literal = 0 }, }; }; pub const IndirectBr = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.Code.INST_INDIRECTBR) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.Code.INST_INDIRECTBR) }, .{ .fixed_runtime = Builder.Type }, ValueAbbrev, BlockArrayAbbrev, @@ -1434,7 +1434,7 @@ pub const ModuleBlock = struct { pub const BlockEntry = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.FunctionBlock.ValueSymtabBlock.Code.BBENTRY) }, + .{ .literal = @backingInt(ModuleBlock.FunctionBlock.ValueSymtabBlock.Code.BBENTRY) }, ValueAbbrev, .{ .array_fixed = 8 }, }; @@ -1452,7 +1452,7 @@ pub const ModuleBlock = struct { pub const Value = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.VALUE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.VALUE) }, .{ .fixed = 32 }, // variable .{ .fixed = 32 }, // expression }; @@ -1472,7 +1472,7 @@ pub const ModuleBlock = struct { pub const AttachmentGlobalSingle = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.ATTACHMENT) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.ATTACHMENT) }, .{ .fixed = 1 }, MetadataAbbrev, }; @@ -1482,7 +1482,7 @@ pub const ModuleBlock = struct { pub const AttachmentInstructionSingle = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.ATTACHMENT) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.ATTACHMENT) }, ValueAbbrev, .{ .fixed = 5 }, MetadataAbbrev, @@ -1617,7 +1617,7 @@ pub const ModuleBlock = struct { pub const Strings = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.STRINGS) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.STRINGS) }, .{ .vbr = 6 }, .{ .vbr = 6 }, .blob, @@ -1629,7 +1629,7 @@ pub const ModuleBlock = struct { pub const File = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.FILE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.FILE) }, .{ .literal = 0 }, // is distinct MetadataAbbrev, // filename MetadataAbbrev, // directory @@ -1643,7 +1643,7 @@ pub const ModuleBlock = struct { pub const CompileUnit = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.COMPILE_UNIT) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.COMPILE_UNIT) }, .{ .literal = 1 }, // is distinct .{ .literal = std.dwarf.LANG.C99 }, // source language MetadataAbbrev, // file @@ -1677,7 +1677,7 @@ pub const ModuleBlock = struct { pub const Subprogram = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.SUBPROGRAM) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.SUBPROGRAM) }, .{ .literal = 0b111 }, // is distinct | has sp flags | has flags MetadataAbbrev, // scope MetadataAbbrev, // name @@ -1714,7 +1714,7 @@ pub const ModuleBlock = struct { pub const LexicalBlock = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.LEXICAL_BLOCK) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.LEXICAL_BLOCK) }, .{ .literal = 0 }, // is distinct MetadataAbbrev, // scope MetadataAbbrev, // file @@ -1730,7 +1730,7 @@ pub const ModuleBlock = struct { pub const Location = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.LOCATION) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.LOCATION) }, .{ .literal = 0 }, // is distinct LineAbbrev, // line ColumnAbbrev, // column @@ -1747,7 +1747,7 @@ pub const ModuleBlock = struct { pub const BasicType = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.BASIC_TYPE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.BASIC_TYPE) }, .{ .literal = 0 }, // is distinct .{ .literal = std.dwarf.TAG.base_type }, // tag MetadataAbbrev, // name @@ -1764,7 +1764,7 @@ pub const ModuleBlock = struct { pub const CompositeType = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.COMPOSITE_TYPE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.COMPOSITE_TYPE) }, .{ .literal = 0 | 0x2 }, // is distinct | is not used in old type ref .{ .fixed = 32 }, // tag MetadataAbbrev, // name @@ -1803,7 +1803,7 @@ pub const ModuleBlock = struct { pub const DerivedType = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.DERIVED_TYPE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.DERIVED_TYPE) }, .{ .literal = 0 }, // is distinct .{ .fixed = 32 }, // tag MetadataAbbrev, // name @@ -1831,7 +1831,7 @@ pub const ModuleBlock = struct { pub const SubroutineType = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.SUBROUTINE_TYPE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.SUBROUTINE_TYPE) }, .{ .literal = 0 | 0x2 }, // is distinct | has no old type refs .{ .literal = 0 }, // flags MetadataAbbrev, // types @@ -1849,7 +1849,7 @@ pub const ModuleBlock = struct { }; pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.ENUMERATOR) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.ENUMERATOR) }, .{ .fixed = @bitSizeOf(Flags) }, // flags .{ .vbr = 6 }, // bit width MetadataAbbrev, // name @@ -1864,7 +1864,7 @@ pub const ModuleBlock = struct { pub const Subrange = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.SUBRANGE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.SUBRANGE) }, .{ .literal = 0 | (2 << 1) }, // is distinct | version MetadataAbbrev, // count MetadataAbbrev, // lower bound @@ -1878,7 +1878,7 @@ pub const ModuleBlock = struct { pub const Expression = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.EXPRESSION) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.EXPRESSION) }, .{ .literal = 0 | (3 << 1) }, // is distinct | version MetadataArrayAbbrev, // elements }; @@ -1888,7 +1888,7 @@ pub const ModuleBlock = struct { pub const Node = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.NODE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.NODE) }, MetadataArrayAbbrev, // elements }; @@ -1897,7 +1897,7 @@ pub const ModuleBlock = struct { pub const LocalVar = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.LOCAL_VAR) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.LOCAL_VAR) }, .{ .literal = 0b10 }, // is distinct | has alignment MetadataAbbrev, // scope MetadataAbbrev, // name @@ -1919,7 +1919,7 @@ pub const ModuleBlock = struct { pub const Parameter = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.LOCAL_VAR) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.LOCAL_VAR) }, .{ .literal = 0b10 }, // is distinct | has alignment MetadataAbbrev, // scope MetadataAbbrev, // name @@ -1942,7 +1942,7 @@ pub const ModuleBlock = struct { pub const GlobalVar = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.GLOBAL_VAR) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.GLOBAL_VAR) }, .{ .literal = 0b101 }, // is distinct | version MetadataAbbrev, // scope MetadataAbbrev, // name @@ -1969,7 +1969,7 @@ pub const ModuleBlock = struct { pub const GlobalVarExpression = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.GLOBAL_VAR_EXPR) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.GLOBAL_VAR_EXPR) }, .{ .literal = 0 }, // is distinct MetadataAbbrev, // variable MetadataAbbrev, // expression @@ -1981,7 +1981,7 @@ pub const ModuleBlock = struct { pub const Constant = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.VALUE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.VALUE) }, MetadataAbbrev, // type MetadataAbbrev, // value }; @@ -1992,7 +1992,7 @@ pub const ModuleBlock = struct { pub const Name = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.NAME) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.NAME) }, .{ .array_fixed = 8 }, // name }; @@ -2001,7 +2001,7 @@ pub const ModuleBlock = struct { pub const NamedNode = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.NAMED_NODE) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.NAMED_NODE) }, MetadataArrayAbbrev, // elements }; @@ -2010,7 +2010,7 @@ pub const ModuleBlock = struct { pub const GlobalDeclAttachment = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.GLOBAL_DECL_ATTACHMENT) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.GLOBAL_DECL_ATTACHMENT) }, ValueAbbrev, // value id .{ .fixed = 1 }, // kind MetadataAbbrev, // elements @@ -2115,7 +2115,7 @@ pub const ModuleBlock = struct { pub const NumEntry = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.NUMENTRY) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.NUMENTRY) }, .{ .fixed = 32 }, }; num: u32, @@ -2130,14 +2130,14 @@ pub const ModuleBlock = struct { pub const Opaque = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.OPAQUE) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.OPAQUE) }, .{ .literal = 0 }, }; }; pub const Integer = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.INTEGER) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.INTEGER) }, .{ .fixed = 28 }, }; width: u28, @@ -2145,7 +2145,7 @@ pub const ModuleBlock = struct { pub const StructAnon = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.STRUCT_ANON) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.STRUCT_ANON) }, .{ .fixed = 1 }, .{ .array_fixed_runtime = Builder.Type }, }; @@ -2155,7 +2155,7 @@ pub const ModuleBlock = struct { pub const StructNamed = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.STRUCT_NAMED) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.STRUCT_NAMED) }, .{ .fixed = 1 }, .{ .array_fixed_runtime = Builder.Type }, }; @@ -2165,7 +2165,7 @@ pub const ModuleBlock = struct { pub const StructName = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.STRUCT_NAME) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.STRUCT_NAME) }, .{ .array_fixed = 8 }, }; string: []const u8, @@ -2173,7 +2173,7 @@ pub const ModuleBlock = struct { pub const Array = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.ARRAY) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.ARRAY) }, .{ .vbr = 16 }, .{ .fixed_runtime = Builder.Type }, }; @@ -2183,7 +2183,7 @@ pub const ModuleBlock = struct { pub const Vector = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.VECTOR) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.VECTOR) }, .{ .vbr = 16 }, .{ .fixed_runtime = Builder.Type }, }; @@ -2193,7 +2193,7 @@ pub const ModuleBlock = struct { pub const Pointer = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.OPAQUE_POINTER) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.OPAQUE_POINTER) }, .{ .vbr = 4 }, }; addr_space: Builder.AddrSpace, @@ -2201,7 +2201,7 @@ pub const ModuleBlock = struct { pub const Target = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.TARGET_TYPE) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.TARGET_TYPE) }, .{ .vbr = 4 }, .{ .array_fixed_runtime = Builder.Type }, .{ .array_fixed = 32 }, @@ -2213,7 +2213,7 @@ pub const ModuleBlock = struct { pub const Function = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.TypeBlock.Code.FUNCTION) }, + .{ .literal = @backingInt(ModuleBlock.TypeBlock.Code.FUNCTION) }, .{ .fixed = 1 }, .{ .fixed_runtime = Builder.Type }, .{ .array_fixed_runtime = Builder.Type }, @@ -2238,7 +2238,7 @@ pub const ModuleBlock = struct { pub const OperandBundleTag = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.OperandBundleTagsBlock.Code.OPERAND_BUNDLE_TAG) }, + .{ .literal = @backingInt(ModuleBlock.OperandBundleTagsBlock.Code.OPERAND_BUNDLE_TAG) }, .array_char6, }; tag: []const u8, @@ -2254,7 +2254,7 @@ pub const ModuleBlock = struct { pub const Kind = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(ModuleBlock.MetadataBlock.Code.KIND) }, + .{ .literal = @backingInt(ModuleBlock.MetadataBlock.Code.KIND) }, .{ .vbr = 4 }, .{ .array_fixed = 8 }, }; @@ -2283,7 +2283,7 @@ pub const IdentificationBlock = struct { pub const Version = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(IdentificationBlock.Code.STRING) }, + .{ .literal = @backingInt(IdentificationBlock.Code.STRING) }, .{ .array_fixed = 8 }, }; string: []const u8, @@ -2291,7 +2291,7 @@ pub const IdentificationBlock = struct { pub const Epoch = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(IdentificationBlock.Code.EPOCH) }, + .{ .literal = @backingInt(IdentificationBlock.Code.EPOCH) }, .{ .vbr = 6 }, }; epoch: u32, @@ -2309,7 +2309,7 @@ pub const StrtabBlock = struct { pub const Blob = struct { pub const ops = [_]AbbrevOp{ - .{ .literal = @intFromEnum(StrtabBlock.Code.BLOB) }, + .{ .literal = @backingInt(StrtabBlock.Code.BLOB) }, .blob, }; blob: []const u8, diff --git a/lib/std/zig/number_literal.zig b/lib/std/zig/number_literal.zig index 45be08e0de9b63df8aff4a07661571121ac02f2f..6ffec3bb3929b190001fc10ef10745e6fb029137 100644 --- a/lib/std/zig/number_literal.zig +++ b/lib/std/zig/number_literal.zig @@ -147,7 +147,7 @@ pub fn parseNumberLiteral(bytes: []const u8) Result { 'a'...'z' => c - 'a' + 10, else => return .{ .failure = .{ .invalid_character = i } }, }; - if (digit >= base) return .{ .failure = .{ .invalid_digit = .{ .i = i, .base = @as(Base, @enumFromInt(base)) } } }; + if (digit >= base) return .{ .failure = .{ .invalid_digit = .{ .i = i, .base = @as(Base, @fromBackingInt(@intCast(base))) } } }; if (exponent and digit >= 10) return .{ .failure = .{ .invalid_digit_exponent = i } }; underscore = false; special = 0; @@ -165,8 +165,8 @@ pub fn parseNumberLiteral(bytes: []const u8) Result { if (underscore) return .{ .failure = .{ .trailing_underscore = bytes.len - 1 } }; if (special != 0) return .{ .failure = .{ .trailing_special = bytes.len - 1 } }; - if (float) return .{ .float = @as(FloatBase, @enumFromInt(base)) }; - if (overflow) return .{ .big_int = @as(Base, @enumFromInt(base)) }; + if (float) return .{ .float = @as(FloatBase, @fromBackingInt(@intCast(base))) }; + if (overflow) return .{ .big_int = @as(Base, @fromBackingInt(@intCast(base))) }; return .{ .int = x }; } diff --git a/lib/std/zig/parser_generated_oracle.zig b/lib/std/zig/parser_generated_oracle.zig index 2b24677c96cc33db44ea3871c7255e79fd9b5b82..1cd16d6ce1495e8587fd16feb019f23501c90f3d 100644 --- a/lib/std/zig/parser_generated_oracle.zig +++ b/lib/std/zig/parser_generated_oracle.zig @@ -292,7 +292,7 @@ const Parser = struct { i: usize, depths: [272]u8, pub fn parseRoot(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRoot); + const def_index = @backingInt(Def.defRoot); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -304,7 +304,7 @@ const Parser = struct { }; } pub fn parseContainerMembers(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerMembers); + const def_index = @backingInt(Def.defContainerMembers); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -323,7 +323,7 @@ const Parser = struct { }; } pub fn parseContainerMembersRest(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerMembersRest); + const def_index = @backingInt(Def.defContainerMembersRest); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -354,7 +354,7 @@ const Parser = struct { }; } pub fn parseContainerDecl(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerDecl); + const def_index = @backingInt(Def.defContainerDecl); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -370,7 +370,7 @@ const Parser = struct { }; } pub fn parseContainerDeclPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerDeclPrefix); + const def_index = @backingInt(Def.defContainerDeclPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -386,7 +386,7 @@ const Parser = struct { }; } pub fn parseTestDecl(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defTestDecl); + const def_index = @backingInt(Def.defTestDecl); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -405,7 +405,7 @@ const Parser = struct { }; } pub fn parseComptimeDecl(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defComptimeDecl); + const def_index = @backingInt(Def.defComptimeDecl); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -417,7 +417,7 @@ const Parser = struct { }; } pub fn parseDecl(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defDecl); + const def_index = @backingInt(Def.defDecl); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -456,7 +456,7 @@ const Parser = struct { }; } pub fn parseDeclPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defDeclPrefix); + const def_index = @backingInt(Def.defDeclPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -495,7 +495,7 @@ const Parser = struct { }; } pub fn parseFnProto(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defFnProto); + const def_index = @backingInt(Def.defFnProto); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -507,7 +507,7 @@ const Parser = struct { }; } pub fn parseVarDeclProto(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defVarDeclProto); + const def_index = @backingInt(Def.defVarDeclProto); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -531,7 +531,7 @@ const Parser = struct { }; } pub fn parseGlobalVarDecl(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defGlobalVarDecl); + const def_index = @backingInt(Def.defGlobalVarDecl); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -548,7 +548,7 @@ const Parser = struct { }; } pub fn parseContainerField(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerField); + const def_index = @backingInt(Def.defContainerField); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -570,7 +570,7 @@ const Parser = struct { }; } pub fn parseBlockStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBlockStatement); + const def_index = @backingInt(Def.defBlockStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -593,7 +593,7 @@ const Parser = struct { }; } pub fn parseStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defStatement); + const def_index = @backingInt(Def.defStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -620,7 +620,7 @@ const Parser = struct { }; } pub fn parseStatementPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defStatementPrefix); + const def_index = @backingInt(Def.defStatementPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -654,7 +654,7 @@ const Parser = struct { }; } pub fn parseIfStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defIfStatement); + const def_index = @backingInt(Def.defIfStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -692,7 +692,7 @@ const Parser = struct { }; } pub fn parseLabeledStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLabeledStatement); + const def_index = @backingInt(Def.defLabeledStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -713,7 +713,7 @@ const Parser = struct { }; } pub fn parseLoopStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLoopStatement); + const def_index = @backingInt(Def.defLoopStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -732,7 +732,7 @@ const Parser = struct { }; } pub fn parseForStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defForStatement); + const def_index = @backingInt(Def.defForStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -770,7 +770,7 @@ const Parser = struct { }; } pub fn parseWhileStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defWhileStatement); + const def_index = @backingInt(Def.defWhileStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -808,7 +808,7 @@ const Parser = struct { }; } pub fn parseBlockExprStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBlockExprStatement); + const def_index = @backingInt(Def.defBlockExprStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -827,7 +827,7 @@ const Parser = struct { }; } pub fn parseBlockExprPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBlockExprPrefix); + const def_index = @backingInt(Def.defBlockExprPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -839,7 +839,7 @@ const Parser = struct { }; } pub fn parseBlockExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBlockExpr); + const def_index = @backingInt(Def.defBlockExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -851,7 +851,7 @@ const Parser = struct { }; } pub fn parseVarAssignStatement(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defVarAssignStatement); + const def_index = @backingInt(Def.defVarAssignStatement); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -889,7 +889,7 @@ const Parser = struct { }; } pub fn parseAssignExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAssignExpr); + const def_index = @backingInt(Def.defAssignExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -934,7 +934,7 @@ const Parser = struct { }; } pub fn parseSingleAssignExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSingleAssignExpr); + const def_index = @backingInt(Def.defSingleAssignExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -958,7 +958,7 @@ const Parser = struct { }; } pub fn parseExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defExpr); + const def_index = @backingInt(Def.defExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -970,7 +970,7 @@ const Parser = struct { }; } pub fn parseBoolOrExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBoolOrExpr); + const def_index = @backingInt(Def.defBoolOrExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -999,7 +999,7 @@ const Parser = struct { }; } pub fn parseBoolAndExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBoolAndExpr); + const def_index = @backingInt(Def.defBoolAndExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1028,7 +1028,7 @@ const Parser = struct { }; } pub fn parseCompareExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCompareExpr); + const def_index = @backingInt(Def.defCompareExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1050,7 +1050,7 @@ const Parser = struct { }; } pub fn parseBitwiseExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBitwiseExpr); + const def_index = @backingInt(Def.defBitwiseExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1079,7 +1079,7 @@ const Parser = struct { }; } pub fn parseBitShiftExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBitShiftExpr); + const def_index = @backingInt(Def.defBitShiftExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1108,7 +1108,7 @@ const Parser = struct { }; } pub fn parseAdditionExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAdditionExpr); + const def_index = @backingInt(Def.defAdditionExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1137,7 +1137,7 @@ const Parser = struct { }; } pub fn parseMultiplyExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMultiplyExpr); + const def_index = @backingInt(Def.defMultiplyExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1166,7 +1166,7 @@ const Parser = struct { }; } pub fn parsePrefixExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPrefixExpr); + const def_index = @backingInt(Def.defPrefixExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1190,7 +1190,7 @@ const Parser = struct { }; } pub fn parsePrimaryExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPrimaryExpr); + const def_index = @backingInt(Def.defPrimaryExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1258,7 +1258,7 @@ const Parser = struct { }; } pub fn parseIfExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defIfExpr); + const def_index = @backingInt(Def.defIfExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1282,7 +1282,7 @@ const Parser = struct { }; } pub fn parseBlock(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBlock); + const def_index = @backingInt(Def.defBlock); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1301,7 +1301,7 @@ const Parser = struct { }; } pub fn parseLoopExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLoopExpr); + const def_index = @backingInt(Def.defLoopExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1320,7 +1320,7 @@ const Parser = struct { }; } pub fn parseForExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defForExpr); + const def_index = @backingInt(Def.defForExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1344,7 +1344,7 @@ const Parser = struct { }; } pub fn parseWhileExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defWhileExpr); + const def_index = @backingInt(Def.defWhileExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1361,7 +1361,7 @@ const Parser = struct { }; } pub fn parseCurlySuffixExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCurlySuffixExpr); + const def_index = @backingInt(Def.defCurlySuffixExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1385,7 +1385,7 @@ const Parser = struct { }; } pub fn parseInitList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defInitList); + const def_index = @backingInt(Def.defInitList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1425,7 +1425,7 @@ const Parser = struct { }; } pub fn parseTypeExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defTypeExpr); + const def_index = @backingInt(Def.defTypeExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1449,7 +1449,7 @@ const Parser = struct { }; } pub fn parseErrorUnionExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defErrorUnionExpr); + const def_index = @backingInt(Def.defErrorUnionExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1473,7 +1473,7 @@ const Parser = struct { }; } pub fn parseSuffixExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSuffixExpr); + const def_index = @backingInt(Def.defSuffixExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1497,7 +1497,7 @@ const Parser = struct { }; } pub fn parsePrimaryTypeExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPrimaryTypeExpr); + const def_index = @backingInt(Def.defPrimaryTypeExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1541,7 +1541,7 @@ const Parser = struct { }; } pub fn parseContainerType(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerType); + const def_index = @backingInt(Def.defContainerType); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1560,7 +1560,7 @@ const Parser = struct { }; } pub fn parseErrorSetDecl(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defErrorSetDecl); + const def_index = @backingInt(Def.defErrorSetDecl); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1572,7 +1572,7 @@ const Parser = struct { }; } pub fn parseGroupedExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defGroupedExpr); + const def_index = @backingInt(Def.defGroupedExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1584,7 +1584,7 @@ const Parser = struct { }; } pub fn parseIfTypeExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defIfTypeExpr); + const def_index = @backingInt(Def.defIfTypeExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1608,7 +1608,7 @@ const Parser = struct { }; } pub fn parseLabeledTypeExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLabeledTypeExpr); + const def_index = @backingInt(Def.defLabeledTypeExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1624,7 +1624,7 @@ const Parser = struct { }; } pub fn parseLoopTypeExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLoopTypeExpr); + const def_index = @backingInt(Def.defLoopTypeExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1643,7 +1643,7 @@ const Parser = struct { }; } pub fn parseForTypeExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defForTypeExpr); + const def_index = @backingInt(Def.defForTypeExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1667,7 +1667,7 @@ const Parser = struct { }; } pub fn parseWhileTypeExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defWhileTypeExpr); + const def_index = @backingInt(Def.defWhileTypeExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1691,7 +1691,7 @@ const Parser = struct { }; } pub fn parseSwitchExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSwitchExpr); + const def_index = @backingInt(Def.defSwitchExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1703,7 +1703,7 @@ const Parser = struct { }; } pub fn parseAsmExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmExpr); + const def_index = @backingInt(Def.defAsmExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1715,7 +1715,7 @@ const Parser = struct { }; } pub fn parseAsmOutput(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmOutput); + const def_index = @backingInt(Def.defAsmOutput); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1727,7 +1727,7 @@ const Parser = struct { }; } pub fn parseAsmOutputItem(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmOutputItem); + const def_index = @backingInt(Def.defAsmOutputItem); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1746,7 +1746,7 @@ const Parser = struct { }; } pub fn parseAsmInput(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmInput); + const def_index = @backingInt(Def.defAsmInput); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1758,7 +1758,7 @@ const Parser = struct { }; } pub fn parseAsmInputItem(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmInputItem); + const def_index = @backingInt(Def.defAsmInputItem); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1770,7 +1770,7 @@ const Parser = struct { }; } pub fn parseAsmClobbers(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmClobbers); + const def_index = @backingInt(Def.defAsmClobbers); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1782,7 +1782,7 @@ const Parser = struct { }; } pub fn parseBreakLabel(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBreakLabel); + const def_index = @backingInt(Def.defBreakLabel); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1794,7 +1794,7 @@ const Parser = struct { }; } pub fn parseBlockLabel(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBlockLabel); + const def_index = @backingInt(Def.defBlockLabel); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1806,7 +1806,7 @@ const Parser = struct { }; } pub fn parseFieldInit(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defFieldInit); + const def_index = @backingInt(Def.defFieldInit); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1818,7 +1818,7 @@ const Parser = struct { }; } pub fn parseWhileContinueExpr(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defWhileContinueExpr); + const def_index = @backingInt(Def.defWhileContinueExpr); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1830,7 +1830,7 @@ const Parser = struct { }; } pub fn parseLinkSection(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLinkSection); + const def_index = @backingInt(Def.defLinkSection); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1842,7 +1842,7 @@ const Parser = struct { }; } pub fn parseAddrSpace(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAddrSpace); + const def_index = @backingInt(Def.defAddrSpace); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1854,7 +1854,7 @@ const Parser = struct { }; } pub fn parseCallConv(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCallConv); + const def_index = @backingInt(Def.defCallConv); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1866,7 +1866,7 @@ const Parser = struct { }; } pub fn parseParamDecl(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defParamDecl); + const def_index = @backingInt(Def.defParamDecl); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1890,7 +1890,7 @@ const Parser = struct { }; } pub fn parseParamType(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defParamType); + const def_index = @backingInt(Def.defParamType); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1904,7 +1904,7 @@ const Parser = struct { }; } pub fn parseIfPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defIfPrefix); + const def_index = @backingInt(Def.defIfPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1916,7 +1916,7 @@ const Parser = struct { }; } pub fn parseWhilePrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defWhilePrefix); + const def_index = @backingInt(Def.defWhilePrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1928,7 +1928,7 @@ const Parser = struct { }; } pub fn parseForPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defForPrefix); + const def_index = @backingInt(Def.defForPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1940,7 +1940,7 @@ const Parser = struct { }; } pub fn parsePayload(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPayload); + const def_index = @backingInt(Def.defPayload); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1952,7 +1952,7 @@ const Parser = struct { }; } pub fn parsePtrPayload(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPtrPayload); + const def_index = @backingInt(Def.defPtrPayload); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1964,7 +1964,7 @@ const Parser = struct { }; } pub fn parsePtrIndexPayload(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPtrIndexPayload); + const def_index = @backingInt(Def.defPtrIndexPayload); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -1981,7 +1981,7 @@ const Parser = struct { }; } pub fn parsePtrListPayload(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPtrListPayload); + const def_index = @backingInt(Def.defPtrListPayload); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2005,7 +2005,7 @@ const Parser = struct { }; } pub fn parseSwitchProng(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSwitchProng); + const def_index = @backingInt(Def.defSwitchProng); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2017,7 +2017,7 @@ const Parser = struct { }; } pub fn parseSwitchCase(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSwitchCase); + const def_index = @backingInt(Def.defSwitchCase); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2043,7 +2043,7 @@ const Parser = struct { }; } pub fn parseSwitchItem(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSwitchItem); + const def_index = @backingInt(Def.defSwitchItem); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2060,7 +2060,7 @@ const Parser = struct { }; } pub fn parseForArgumentsList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defForArgumentsList); + const def_index = @backingInt(Def.defForArgumentsList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2084,7 +2084,7 @@ const Parser = struct { }; } pub fn parseForItem(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defForItem); + const def_index = @backingInt(Def.defForItem); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2120,7 +2120,7 @@ const Parser = struct { }; } pub fn parseAssignOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAssignOp); + const def_index = @backingInt(Def.defAssignOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2166,7 +2166,7 @@ const Parser = struct { }; } pub fn parseOrOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defOrOp); + const def_index = @backingInt(Def.defOrOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2190,7 +2190,7 @@ const Parser = struct { }; } pub fn parseAndOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAndOp); + const def_index = @backingInt(Def.defAndOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2214,7 +2214,7 @@ const Parser = struct { }; } pub fn parseCompareOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCompareOp); + const def_index = @backingInt(Def.defCompareOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2238,7 +2238,7 @@ const Parser = struct { }; } pub fn parseCompareOpTok(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCompareOpTok); + const def_index = @backingInt(Def.defCompareOpTok); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2260,7 +2260,7 @@ const Parser = struct { }; } pub fn parseBitwiseOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBitwiseOp); + const def_index = @backingInt(Def.defBitwiseOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2298,7 +2298,7 @@ const Parser = struct { }; } pub fn parseBitwiseOpTok(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBitwiseOpTok); + const def_index = @backingInt(Def.defBitwiseOpTok); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2328,7 +2328,7 @@ const Parser = struct { }; } pub fn parseBitShiftOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBitShiftOp); + const def_index = @backingInt(Def.defBitShiftOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2352,7 +2352,7 @@ const Parser = struct { }; } pub fn parseBitShiftOpTok(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBitShiftOpTok); + const def_index = @backingInt(Def.defBitShiftOpTok); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2368,7 +2368,7 @@ const Parser = struct { }; } pub fn parseAdditionOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAdditionOp); + const def_index = @backingInt(Def.defAdditionOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2392,7 +2392,7 @@ const Parser = struct { }; } pub fn parseAdditionOpTok(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAdditionOpTok); + const def_index = @backingInt(Def.defAdditionOpTok); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2416,7 +2416,7 @@ const Parser = struct { }; } pub fn parseMultiplyOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMultiplyOp); + const def_index = @backingInt(Def.defMultiplyOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2440,7 +2440,7 @@ const Parser = struct { }; } pub fn parseMultiplyOpTok(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMultiplyOpTok); + const def_index = @backingInt(Def.defMultiplyOpTok); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2462,7 +2462,7 @@ const Parser = struct { }; } pub fn parsePrefixOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPrefixOp); + const def_index = @backingInt(Def.defPrefixOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2484,7 +2484,7 @@ const Parser = struct { }; } pub fn parsePrefixTypeOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPrefixTypeOp); + const def_index = @backingInt(Def.defPrefixTypeOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2511,7 +2511,7 @@ const Parser = struct { }; } pub fn parsePtrMods(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPtrMods); + const def_index = @backingInt(Def.defPtrMods); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2577,7 +2577,7 @@ const Parser = struct { }; } pub fn parseSinglePtrMods(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSinglePtrMods); + const def_index = @backingInt(Def.defSinglePtrMods); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2643,7 +2643,7 @@ const Parser = struct { }; } pub fn parsePtrMod(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPtrMod); + const def_index = @backingInt(Def.defPtrMod); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2659,7 +2659,7 @@ const Parser = struct { }; } pub fn parsePrefixTypeOpPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPrefixTypeOpPrefix); + const def_index = @backingInt(Def.defPrefixTypeOpPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2677,7 +2677,7 @@ const Parser = struct { }; } pub fn parseSuffixOp(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSuffixOp); + const def_index = @backingInt(Def.defSuffixOp); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2719,7 +2719,7 @@ const Parser = struct { }; } pub fn parseSuffixOpPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSuffixOpPrefix); + const def_index = @backingInt(Def.defSuffixOpPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2739,7 +2739,7 @@ const Parser = struct { }; } pub fn parseFnCallArguments(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defFnCallArguments); + const def_index = @backingInt(Def.defFnCallArguments); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2751,7 +2751,7 @@ const Parser = struct { }; } pub fn parseSliceTypeStart(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSliceTypeStart); + const def_index = @backingInt(Def.defSliceTypeStart); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2768,7 +2768,7 @@ const Parser = struct { }; } pub fn parseSinglePtrTypeStart(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSinglePtrTypeStart); + const def_index = @backingInt(Def.defSinglePtrTypeStart); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2780,7 +2780,7 @@ const Parser = struct { }; } pub fn parseManyPtrTypeStart(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defManyPtrTypeStart); + const def_index = @backingInt(Def.defManyPtrTypeStart); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2799,7 +2799,7 @@ const Parser = struct { }; } pub fn parseArrayTypeStart(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defArrayTypeStart); + const def_index = @backingInt(Def.defArrayTypeStart); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2821,7 +2821,7 @@ const Parser = struct { }; } pub fn parseContainerTypeAuto(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerTypeAuto); + const def_index = @backingInt(Def.defContainerTypeAuto); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2833,7 +2833,7 @@ const Parser = struct { }; } pub fn parseContainerTypeKind(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defContainerTypeKind); + const def_index = @backingInt(Def.defContainerTypeKind); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2878,7 +2878,7 @@ const Parser = struct { }; } pub fn parseByteAlign(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defByteAlign); + const def_index = @backingInt(Def.defByteAlign); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2890,7 +2890,7 @@ const Parser = struct { }; } pub fn parseBitAlign(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBitAlign); + const def_index = @backingInt(Def.defBitAlign); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2907,7 +2907,7 @@ const Parser = struct { }; } pub fn parseIdentifierList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defIdentifierList); + const def_index = @backingInt(Def.defIdentifierList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2929,7 +2929,7 @@ const Parser = struct { }; } pub fn parseSwitchProngList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSwitchProngList); + const def_index = @backingInt(Def.defSwitchProngList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2951,7 +2951,7 @@ const Parser = struct { }; } pub fn parseAsmOutputList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmOutputList); + const def_index = @backingInt(Def.defAsmOutputList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2973,7 +2973,7 @@ const Parser = struct { }; } pub fn parseAsmInputList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAsmInputList); + const def_index = @backingInt(Def.defAsmInputList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -2995,7 +2995,7 @@ const Parser = struct { }; } pub fn parseParamDeclList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defParamDeclList); + const def_index = @backingInt(Def.defParamDeclList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3007,7 +3007,7 @@ const Parser = struct { }; } pub fn parseParamDeclListRest(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defParamDeclListRest); + const def_index = @backingInt(Def.defParamDeclListRest); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3030,7 +3030,7 @@ const Parser = struct { }; } pub fn parseExprList(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defExprList); + const def_index = @backingInt(Def.defExprList); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3054,7 +3054,7 @@ const Parser = struct { }; } pub fn parseExprPrefix(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defExprPrefix); + const def_index = @backingInt(Def.defExprPrefix); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3066,7 +3066,7 @@ const Parser = struct { }; } pub fn parsebyte_order_mark(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defbyte_order_mark); + const def_index = @backingInt(Def.defbyte_order_mark); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3084,7 +3084,7 @@ const Parser = struct { }; } pub fn parsesof(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defsof); + const def_index = @backingInt(Def.defsof); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3096,7 +3096,7 @@ const Parser = struct { }; } pub fn parseeof(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defeof); + const def_index = @backingInt(Def.defeof); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3119,7 +3119,7 @@ const Parser = struct { }; } pub fn parseox80_oxBF(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defox80_oxBF); + const def_index = @backingInt(Def.defox80_oxBF); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3138,7 +3138,7 @@ const Parser = struct { }; } pub fn parseoxF4(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxF4); + const def_index = @backingInt(Def.defoxF4); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3156,7 +3156,7 @@ const Parser = struct { }; } pub fn parseox80_ox8F(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defox80_ox8F); + const def_index = @backingInt(Def.defox80_ox8F); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3175,7 +3175,7 @@ const Parser = struct { }; } pub fn parseoxF1_oxF3(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxF1_oxF3); + const def_index = @backingInt(Def.defoxF1_oxF3); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3194,7 +3194,7 @@ const Parser = struct { }; } pub fn parseoxF0(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxF0); + const def_index = @backingInt(Def.defoxF0); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3212,7 +3212,7 @@ const Parser = struct { }; } pub fn parseox90_0xBF(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defox90_0xBF); + const def_index = @backingInt(Def.defox90_0xBF); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3231,7 +3231,7 @@ const Parser = struct { }; } pub fn parseoxEE_oxEF(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxEE_oxEF); + const def_index = @backingInt(Def.defoxEE_oxEF); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3250,7 +3250,7 @@ const Parser = struct { }; } pub fn parseoxED(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxED); + const def_index = @backingInt(Def.defoxED); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3268,7 +3268,7 @@ const Parser = struct { }; } pub fn parseox80_ox9F(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defox80_ox9F); + const def_index = @backingInt(Def.defox80_ox9F); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3287,7 +3287,7 @@ const Parser = struct { }; } pub fn parseoxE1_oxEC(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxE1_oxEC); + const def_index = @backingInt(Def.defoxE1_oxEC); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3306,7 +3306,7 @@ const Parser = struct { }; } pub fn parseoxE0(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxE0); + const def_index = @backingInt(Def.defoxE0); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3324,7 +3324,7 @@ const Parser = struct { }; } pub fn parseoxA0_oxBF(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxA0_oxBF); + const def_index = @backingInt(Def.defoxA0_oxBF); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3343,7 +3343,7 @@ const Parser = struct { }; } pub fn parseoxC2_oxDF(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defoxC2_oxDF); + const def_index = @backingInt(Def.defoxC2_oxDF); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3362,7 +3362,7 @@ const Parser = struct { }; } pub fn parsemultibyte_utf8(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defmultibyte_utf8); + const def_index = @backingInt(Def.defmultibyte_utf8); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3388,7 +3388,7 @@ const Parser = struct { }; } pub fn parsenon_control_ascii(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defnon_control_ascii); + const def_index = @backingInt(Def.defnon_control_ascii); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3407,7 +3407,7 @@ const Parser = struct { }; } pub fn parsenon_control_utf8(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defnon_control_utf8); + const def_index = @backingInt(Def.defnon_control_utf8); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3427,7 +3427,7 @@ const Parser = struct { }; } pub fn parsechar_char(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defchar_char); + const def_index = @backingInt(Def.defchar_char); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3467,7 +3467,7 @@ const Parser = struct { }; } pub fn parsestring_char(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defstring_char); + const def_index = @backingInt(Def.defstring_char); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3507,7 +3507,7 @@ const Parser = struct { }; } pub fn parsecontainer_doc_comment(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defcontainer_doc_comment); + const def_index = @backingInt(Def.defcontainer_doc_comment); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3546,7 +3546,7 @@ const Parser = struct { }; } pub fn parsedoc_comment(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defdoc_comment); + const def_index = @backingInt(Def.defdoc_comment); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3592,7 +3592,7 @@ const Parser = struct { }; } pub fn parseline_comment(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defline_comment); + const def_index = @backingInt(Def.defline_comment); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3645,7 +3645,7 @@ const Parser = struct { }; } pub fn parseline_string(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defline_string); + const def_index = @backingInt(Def.defline_string); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3670,7 +3670,7 @@ const Parser = struct { }; } pub fn parsenewline(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defnewline); + const def_index = @backingInt(Def.defnewline); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3708,7 +3708,7 @@ const Parser = struct { }; } pub fn parseskip(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defskip); + const def_index = @backingInt(Def.defskip); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3744,7 +3744,7 @@ const Parser = struct { }; } pub fn parseskip_require_newline(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defskip_require_newline); + const def_index = @backingInt(Def.defskip_require_newline); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3786,7 +3786,7 @@ const Parser = struct { }; } pub fn parsepre_op_white(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defpre_op_white); + const def_index = @backingInt(Def.defpre_op_white); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3824,7 +3824,7 @@ const Parser = struct { }; } pub fn parsepost_op_white(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defpost_op_white); + const def_index = @backingInt(Def.defpost_op_white); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3846,7 +3846,7 @@ const Parser = struct { }; } pub fn parseCHAR_LITERAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCHAR_LITERAL); + const def_index = @backingInt(Def.defCHAR_LITERAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3879,7 +3879,7 @@ const Parser = struct { }; } pub fn parsedigit(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defdigit); + const def_index = @backingInt(Def.defdigit); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3905,7 +3905,7 @@ const Parser = struct { }; } pub fn parsedigit_int(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defdigit_int); + const def_index = @backingInt(Def.defdigit_int); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3929,7 +3929,7 @@ const Parser = struct { }; } pub fn parsedigit_float(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defdigit_float); + const def_index = @backingInt(Def.defdigit_float); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -3961,7 +3961,7 @@ const Parser = struct { }; } pub fn parseNUMBERLITERAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defNUMBERLITERAL); + const def_index = @backingInt(Def.defNUMBERLITERAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4018,7 +4018,7 @@ const Parser = struct { }; } pub fn parsestring(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defstring); + const def_index = @backingInt(Def.defstring); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4051,7 +4051,7 @@ const Parser = struct { }; } pub fn parseSTRINGLITERALSINGLE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSTRINGLITERALSINGLE); + const def_index = @backingInt(Def.defSTRINGLITERALSINGLE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4063,7 +4063,7 @@ const Parser = struct { }; } pub fn parseSTRINGLITERAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSTRINGLITERAL); + const def_index = @backingInt(Def.defSTRINGLITERAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4091,7 +4091,7 @@ const Parser = struct { }; } pub fn parseIDENTIFIER(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defIDENTIFIER); + const def_index = @backingInt(Def.defIDENTIFIER); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4142,7 +4142,7 @@ const Parser = struct { }; } pub fn parseBUILTINIDENTIFIER(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defBUILTINIDENTIFIER); + const def_index = @backingInt(Def.defBUILTINIDENTIFIER); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4186,7 +4186,7 @@ const Parser = struct { }; } pub fn parseAMPERSAND(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAMPERSAND); + const def_index = @backingInt(Def.defAMPERSAND); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4216,7 +4216,7 @@ const Parser = struct { }; } pub fn parseAMPERSANDEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defAMPERSANDEQUAL); + const def_index = @backingInt(Def.defAMPERSANDEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4234,7 +4234,7 @@ const Parser = struct { }; } pub fn parseASTERISK(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defASTERISK); + const def_index = @backingInt(Def.defASTERISK); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4266,7 +4266,7 @@ const Parser = struct { }; } pub fn parseASTERISKEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defASTERISKEQUAL); + const def_index = @backingInt(Def.defASTERISKEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4284,7 +4284,7 @@ const Parser = struct { }; } pub fn parseASTERISKPERCENT(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defASTERISKPERCENT); + const def_index = @backingInt(Def.defASTERISKPERCENT); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4314,7 +4314,7 @@ const Parser = struct { }; } pub fn parseASTERISKPERCENTEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defASTERISKPERCENTEQUAL); + const def_index = @backingInt(Def.defASTERISKPERCENTEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4332,7 +4332,7 @@ const Parser = struct { }; } pub fn parseASTERISKPIPE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defASTERISKPIPE); + const def_index = @backingInt(Def.defASTERISKPIPE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4362,7 +4362,7 @@ const Parser = struct { }; } pub fn parseASTERISKPIPEEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defASTERISKPIPEEQUAL); + const def_index = @backingInt(Def.defASTERISKPIPEEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4380,7 +4380,7 @@ const Parser = struct { }; } pub fn parseCARET(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCARET); + const def_index = @backingInt(Def.defCARET); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4410,7 +4410,7 @@ const Parser = struct { }; } pub fn parseCARETEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCARETEQUAL); + const def_index = @backingInt(Def.defCARETEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4428,7 +4428,7 @@ const Parser = struct { }; } pub fn parseCOLON(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCOLON); + const def_index = @backingInt(Def.defCOLON); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4446,7 +4446,7 @@ const Parser = struct { }; } pub fn parseCOMMA(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defCOMMA); + const def_index = @backingInt(Def.defCOMMA); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4464,7 +4464,7 @@ const Parser = struct { }; } pub fn parseDOT(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defDOT); + const def_index = @backingInt(Def.defDOT); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4495,7 +4495,7 @@ const Parser = struct { }; } pub fn parseDOT2(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defDOT2); + const def_index = @backingInt(Def.defDOT2); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4525,7 +4525,7 @@ const Parser = struct { }; } pub fn parseDOT3(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defDOT3); + const def_index = @backingInt(Def.defDOT3); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4543,7 +4543,7 @@ const Parser = struct { }; } pub fn parseDOTASTERISK(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defDOTASTERISK); + const def_index = @backingInt(Def.defDOTASTERISK); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4561,7 +4561,7 @@ const Parser = struct { }; } pub fn parseEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defEQUAL); + const def_index = @backingInt(Def.defEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4592,7 +4592,7 @@ const Parser = struct { }; } pub fn parseEQUALEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defEQUALEQUAL); + const def_index = @backingInt(Def.defEQUALEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4610,7 +4610,7 @@ const Parser = struct { }; } pub fn parseEQUALRARROW(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defEQUALRARROW); + const def_index = @backingInt(Def.defEQUALRARROW); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4628,7 +4628,7 @@ const Parser = struct { }; } pub fn parseEXCLAMATIONMARK(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defEXCLAMATIONMARK); + const def_index = @backingInt(Def.defEXCLAMATIONMARK); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4658,7 +4658,7 @@ const Parser = struct { }; } pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defEXCLAMATIONMARKEQUAL); + const def_index = @backingInt(Def.defEXCLAMATIONMARKEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4676,7 +4676,7 @@ const Parser = struct { }; } pub fn parseLARROW(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLARROW); + const def_index = @backingInt(Def.defLARROW); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4707,7 +4707,7 @@ const Parser = struct { }; } pub fn parseLARROW2(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLARROW2); + const def_index = @backingInt(Def.defLARROW2); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4738,7 +4738,7 @@ const Parser = struct { }; } pub fn parseLARROW2EQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLARROW2EQUAL); + const def_index = @backingInt(Def.defLARROW2EQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4756,7 +4756,7 @@ const Parser = struct { }; } pub fn parseLARROW2PIPE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLARROW2PIPE); + const def_index = @backingInt(Def.defLARROW2PIPE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4786,7 +4786,7 @@ const Parser = struct { }; } pub fn parseLARROW2PIPEEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLARROW2PIPEEQUAL); + const def_index = @backingInt(Def.defLARROW2PIPEEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4804,7 +4804,7 @@ const Parser = struct { }; } pub fn parseLARROWEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLARROWEQUAL); + const def_index = @backingInt(Def.defLARROWEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4822,7 +4822,7 @@ const Parser = struct { }; } pub fn parseLBRACE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLBRACE); + const def_index = @backingInt(Def.defLBRACE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4840,7 +4840,7 @@ const Parser = struct { }; } pub fn parseLBRACKET(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLBRACKET); + const def_index = @backingInt(Def.defLBRACKET); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4858,7 +4858,7 @@ const Parser = struct { }; } pub fn parseLPAREN(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLPAREN); + const def_index = @backingInt(Def.defLPAREN); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4876,7 +4876,7 @@ const Parser = struct { }; } pub fn parseMINUS(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMINUS); + const def_index = @backingInt(Def.defMINUS); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4909,7 +4909,7 @@ const Parser = struct { }; } pub fn parseMINUSEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMINUSEQUAL); + const def_index = @backingInt(Def.defMINUSEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4927,7 +4927,7 @@ const Parser = struct { }; } pub fn parseMINUSPERCENT(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMINUSPERCENT); + const def_index = @backingInt(Def.defMINUSPERCENT); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4957,7 +4957,7 @@ const Parser = struct { }; } pub fn parseMINUSPERCENTEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMINUSPERCENTEQUAL); + const def_index = @backingInt(Def.defMINUSPERCENTEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -4975,7 +4975,7 @@ const Parser = struct { }; } pub fn parseMINUSPIPE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMINUSPIPE); + const def_index = @backingInt(Def.defMINUSPIPE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5005,7 +5005,7 @@ const Parser = struct { }; } pub fn parseMINUSPIPEEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMINUSPIPEEQUAL); + const def_index = @backingInt(Def.defMINUSPIPEEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5023,7 +5023,7 @@ const Parser = struct { }; } pub fn parseMINUSRARROW(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defMINUSRARROW); + const def_index = @backingInt(Def.defMINUSRARROW); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5041,7 +5041,7 @@ const Parser = struct { }; } pub fn parsePERCENT(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPERCENT); + const def_index = @backingInt(Def.defPERCENT); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5071,7 +5071,7 @@ const Parser = struct { }; } pub fn parsePERCENTEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPERCENTEQUAL); + const def_index = @backingInt(Def.defPERCENTEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5089,7 +5089,7 @@ const Parser = struct { }; } pub fn parsePIPE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPIPE); + const def_index = @backingInt(Def.defPIPE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5120,7 +5120,7 @@ const Parser = struct { }; } pub fn parsePIPE2(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPIPE2); + const def_index = @backingInt(Def.defPIPE2); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5138,7 +5138,7 @@ const Parser = struct { }; } pub fn parsePIPEEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPIPEEQUAL); + const def_index = @backingInt(Def.defPIPEEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5156,7 +5156,7 @@ const Parser = struct { }; } pub fn parsePLUS(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPLUS); + const def_index = @backingInt(Def.defPLUS); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5189,7 +5189,7 @@ const Parser = struct { }; } pub fn parsePLUS2(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPLUS2); + const def_index = @backingInt(Def.defPLUS2); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5207,7 +5207,7 @@ const Parser = struct { }; } pub fn parsePLUSEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPLUSEQUAL); + const def_index = @backingInt(Def.defPLUSEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5225,7 +5225,7 @@ const Parser = struct { }; } pub fn parsePLUSPERCENT(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPLUSPERCENT); + const def_index = @backingInt(Def.defPLUSPERCENT); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5255,7 +5255,7 @@ const Parser = struct { }; } pub fn parsePLUSPERCENTEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPLUSPERCENTEQUAL); + const def_index = @backingInt(Def.defPLUSPERCENTEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5273,7 +5273,7 @@ const Parser = struct { }; } pub fn parsePLUSPIPE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPLUSPIPE); + const def_index = @backingInt(Def.defPLUSPIPE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5303,7 +5303,7 @@ const Parser = struct { }; } pub fn parsePLUSPIPEEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defPLUSPIPEEQUAL); + const def_index = @backingInt(Def.defPLUSPIPEEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5321,7 +5321,7 @@ const Parser = struct { }; } pub fn parseLETTERC(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defLETTERC); + const def_index = @backingInt(Def.defLETTERC); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5339,7 +5339,7 @@ const Parser = struct { }; } pub fn parseQUESTIONMARK(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defQUESTIONMARK); + const def_index = @backingInt(Def.defQUESTIONMARK); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5357,7 +5357,7 @@ const Parser = struct { }; } pub fn parseRARROW(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRARROW); + const def_index = @backingInt(Def.defRARROW); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5388,7 +5388,7 @@ const Parser = struct { }; } pub fn parseRARROW2(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRARROW2); + const def_index = @backingInt(Def.defRARROW2); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5418,7 +5418,7 @@ const Parser = struct { }; } pub fn parseRARROW2EQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRARROW2EQUAL); + const def_index = @backingInt(Def.defRARROW2EQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5436,7 +5436,7 @@ const Parser = struct { }; } pub fn parseRARROWEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRARROWEQUAL); + const def_index = @backingInt(Def.defRARROWEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5454,7 +5454,7 @@ const Parser = struct { }; } pub fn parseRBRACE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRBRACE); + const def_index = @backingInt(Def.defRBRACE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5472,7 +5472,7 @@ const Parser = struct { }; } pub fn parseRBRACKET(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRBRACKET); + const def_index = @backingInt(Def.defRBRACKET); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5490,7 +5490,7 @@ const Parser = struct { }; } pub fn parseRPAREN(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defRPAREN); + const def_index = @backingInt(Def.defRPAREN); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5508,7 +5508,7 @@ const Parser = struct { }; } pub fn parseSEMICOLON(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSEMICOLON); + const def_index = @backingInt(Def.defSEMICOLON); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5526,7 +5526,7 @@ const Parser = struct { }; } pub fn parseSLASH(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSLASH); + const def_index = @backingInt(Def.defSLASH); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5557,7 +5557,7 @@ const Parser = struct { }; } pub fn parseSLASHEQUAL(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defSLASHEQUAL); + const def_index = @backingInt(Def.defSLASHEQUAL); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5575,7 +5575,7 @@ const Parser = struct { }; } pub fn parseTILDE(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defTILDE); + const def_index = @backingInt(Def.defTILDE); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5593,7 +5593,7 @@ const Parser = struct { }; } pub fn parseend_of_word(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defend_of_word); + const def_index = @backingInt(Def.defend_of_word); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5620,7 +5620,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_addrspace(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_addrspace); + const def_index = @backingInt(Def.defKEYWORD_addrspace); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5638,7 +5638,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_align(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_align); + const def_index = @backingInt(Def.defKEYWORD_align); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5656,7 +5656,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_allowzero(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_allowzero); + const def_index = @backingInt(Def.defKEYWORD_allowzero); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5674,7 +5674,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_and(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_and); + const def_index = @backingInt(Def.defKEYWORD_and); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5692,7 +5692,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_anyframe(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_anyframe); + const def_index = @backingInt(Def.defKEYWORD_anyframe); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5710,7 +5710,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_anytype(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_anytype); + const def_index = @backingInt(Def.defKEYWORD_anytype); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5728,7 +5728,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_asm(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_asm); + const def_index = @backingInt(Def.defKEYWORD_asm); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5746,7 +5746,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_break(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_break); + const def_index = @backingInt(Def.defKEYWORD_break); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5764,7 +5764,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_callconv(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_callconv); + const def_index = @backingInt(Def.defKEYWORD_callconv); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5782,7 +5782,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_catch(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_catch); + const def_index = @backingInt(Def.defKEYWORD_catch); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5800,7 +5800,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_comptime(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_comptime); + const def_index = @backingInt(Def.defKEYWORD_comptime); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5818,7 +5818,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_const(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_const); + const def_index = @backingInt(Def.defKEYWORD_const); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5836,7 +5836,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_continue(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_continue); + const def_index = @backingInt(Def.defKEYWORD_continue); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5854,7 +5854,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_defer(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_defer); + const def_index = @backingInt(Def.defKEYWORD_defer); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5872,7 +5872,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_else(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_else); + const def_index = @backingInt(Def.defKEYWORD_else); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5890,7 +5890,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_enum(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_enum); + const def_index = @backingInt(Def.defKEYWORD_enum); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5908,7 +5908,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_errdefer(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_errdefer); + const def_index = @backingInt(Def.defKEYWORD_errdefer); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5926,7 +5926,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_error(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_error); + const def_index = @backingInt(Def.defKEYWORD_error); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5944,7 +5944,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_export(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_export); + const def_index = @backingInt(Def.defKEYWORD_export); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5962,7 +5962,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_extern(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_extern); + const def_index = @backingInt(Def.defKEYWORD_extern); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5980,7 +5980,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_fn(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_fn); + const def_index = @backingInt(Def.defKEYWORD_fn); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -5998,7 +5998,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_for(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_for); + const def_index = @backingInt(Def.defKEYWORD_for); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6016,7 +6016,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_if(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_if); + const def_index = @backingInt(Def.defKEYWORD_if); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6034,7 +6034,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_inline(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_inline); + const def_index = @backingInt(Def.defKEYWORD_inline); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6052,7 +6052,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_noalias(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_noalias); + const def_index = @backingInt(Def.defKEYWORD_noalias); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6070,7 +6070,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_nosuspend(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_nosuspend); + const def_index = @backingInt(Def.defKEYWORD_nosuspend); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6088,7 +6088,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_noinline(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_noinline); + const def_index = @backingInt(Def.defKEYWORD_noinline); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6106,7 +6106,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_opaque(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_opaque); + const def_index = @backingInt(Def.defKEYWORD_opaque); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6124,7 +6124,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_or(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_or); + const def_index = @backingInt(Def.defKEYWORD_or); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6142,7 +6142,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_orelse(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_orelse); + const def_index = @backingInt(Def.defKEYWORD_orelse); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6160,7 +6160,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_packed(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_packed); + const def_index = @backingInt(Def.defKEYWORD_packed); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6178,7 +6178,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_pub(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_pub); + const def_index = @backingInt(Def.defKEYWORD_pub); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6196,7 +6196,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_resume(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_resume); + const def_index = @backingInt(Def.defKEYWORD_resume); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6214,7 +6214,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_return(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_return); + const def_index = @backingInt(Def.defKEYWORD_return); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6232,7 +6232,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_linksection(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_linksection); + const def_index = @backingInt(Def.defKEYWORD_linksection); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6250,7 +6250,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_struct(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_struct); + const def_index = @backingInt(Def.defKEYWORD_struct); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6268,7 +6268,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_suspend(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_suspend); + const def_index = @backingInt(Def.defKEYWORD_suspend); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6286,7 +6286,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_switch(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_switch); + const def_index = @backingInt(Def.defKEYWORD_switch); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6304,7 +6304,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_test(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_test); + const def_index = @backingInt(Def.defKEYWORD_test); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6322,7 +6322,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_threadlocal(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_threadlocal); + const def_index = @backingInt(Def.defKEYWORD_threadlocal); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6340,7 +6340,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_try(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_try); + const def_index = @backingInt(Def.defKEYWORD_try); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6358,7 +6358,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_union(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_union); + const def_index = @backingInt(Def.defKEYWORD_union); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6376,7 +6376,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_unreachable(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_unreachable); + const def_index = @backingInt(Def.defKEYWORD_unreachable); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6394,7 +6394,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_var(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_var); + const def_index = @backingInt(Def.defKEYWORD_var); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6412,7 +6412,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_volatile(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_volatile); + const def_index = @backingInt(Def.defKEYWORD_volatile); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6430,7 +6430,7 @@ const Parser = struct { }; } pub fn parseKEYWORD_while(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defKEYWORD_while); + const def_index = @backingInt(Def.defKEYWORD_while); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; @@ -6448,7 +6448,7 @@ const Parser = struct { }; } pub fn parsekeyword(p: *Parser) Error!bool { - const def_index = @intFromEnum(Def.defkeyword); + const def_index = @backingInt(Def.defkeyword); if (p.depths[def_index] > max_depth) return error.MaxDepth; p.depths[def_index] += 1; defer p.depths[def_index] -= 1; diff --git a/lib/std/zig/system.zig b/lib/std/zig/system.zig index d40d442ce88198297f183a00e586aba3991d09e7..060fd1d97643beac4e5724a12ea26427e7500a31 100644 --- a/lib/std/zig/system.zig +++ b/lib/std/zig/system.zig @@ -390,13 +390,13 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target { // sets one of them, that takes precedence. switch (query_cpu_arch) { .x86_16 => { - cpu.features.addFeature(@intFromEnum(Target.x86.Feature.@"16bit_mode")); + cpu.features.addFeature(@backingInt(Target.x86.Feature.@"16bit_mode")); }, .x86 => { if (!Target.x86.featureSetHasAny(query.cpu_features_add, .{ .@"16bit_mode", .@"32bit_mode", })) { - cpu.features.addFeature(@intFromEnum(Target.x86.Feature.@"32bit_mode")); + cpu.features.addFeature(@backingInt(Target.x86.Feature.@"32bit_mode")); } }, .arm, .armeb => { @@ -404,7 +404,7 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target { // What do we do if the user specifies +thumb_mode? }, .thumb, .thumbeb => { - cpu.features.addFeature(@intFromEnum(Target.arm.Feature.thumb_mode)); + cpu.features.addFeature(@backingInt(Target.arm.Feature.thumb_mode)); }, else => {}, } @@ -452,16 +452,16 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target { // `-G ` to Clang...) We can't do the `-gpsize` hack because we can have multiple // concurrent LLVM emit jobs, and command line options in LLVM are shared globally. So // just force this feature off. Lovely stuff. - result.cpu.features.removeFeature(@intFromEnum(Target.hexagon.Feature.small_data)); + result.cpu.features.removeFeature(@backingInt(Target.hexagon.Feature.small_data)); } // https://github.com/llvm/llvm-project/issues/105978 if (result.cpu.arch.isArm() and result.abi.float() == .soft) { - result.cpu.features.removeFeature(@intFromEnum(Target.arm.Feature.vfp2)); + result.cpu.features.removeFeature(@backingInt(Target.arm.Feature.vfp2)); } if (result.cpu.arch.isXtensa() and result.abi == .call0) { - result.cpu.features.removeFeature(@intFromEnum(Target.xtensa.Feature.windowed)); + result.cpu.features.removeFeature(@backingInt(Target.xtensa.Feature.windowed)); } } @@ -972,7 +972,7 @@ fn detectAbiAndDynamicLinker(io: Io, cpu: Target.Cpu, os: Target.Os, query: Targ // and supported by Zig. But that means that we must detect the system ABI here rather than // relying on `builtin.target`. const all_abis = comptime blk: { - assert(@intFromEnum(Target.Abi.none) == 0); + assert(@backingInt(Target.Abi.none) == 0); const field_names = std.meta.fieldNames(Target.Abi)[1..]; var array: [field_names.len]Target.Abi = undefined; for (field_names, 0..) |field_name, i| { diff --git a/lib/std/zig/system/arm.zig b/lib/std/zig/system/arm.zig index 461edb2e19af218c802d6adc20d1294425708a3e..c597ada2079b972ab5ccb847bca0807107a45edd 100644 --- a/lib/std/zig/system/arm.zig +++ b/lib/std/zig/system/arm.zig @@ -233,7 +233,7 @@ pub const cpu_models = struct { pub const aarch64 = struct { fn setFeature(cpu: *Target.Cpu, feature: Target.aarch64.Feature, enabled: bool) void { - const idx = @as(Target.Cpu.Feature.Set.Index, @intFromEnum(feature)); + const idx = @as(Target.Cpu.Feature.Set.Index, @backingInt(feature)); if (enabled) cpu.features.addFeature(idx) else cpu.features.removeFeature(idx); } diff --git a/lib/std/zig/system/loongarch.zig b/lib/std/zig/system/loongarch.zig index eae8ac31df8f77c5acc66d31752d31ad6bbe3108..eee112462d9de7e17466c34578069c3a6058d4f3 100644 --- a/lib/std/zig/system/loongarch.zig +++ b/lib/std/zig/system/loongarch.zig @@ -13,7 +13,7 @@ inline fn bit(input: u32, offset: u5) bool { } fn setFeature(cpu: *std.Target.Cpu, feature: std.Target.loongarch.Feature, enabled: bool) void { - const idx = @as(std.Target.Cpu.Feature.Set.Index, @intFromEnum(feature)); + const idx = @as(std.Target.Cpu.Feature.Set.Index, @backingInt(feature)); if (enabled) cpu.features.addFeature(idx) else cpu.features.removeFeature(idx); } @@ -26,7 +26,7 @@ pub fn detectNativeCpuAndFeatures( _ = os; _ = query; - const variant: Variant = @enumFromInt(cpucfg(1) & 0b11); + const variant: Variant = @fromBackingInt(@intCast(cpucfg(1) & 0b11)); var cpu: std.Target.Cpu = .{ .arch = arch, diff --git a/lib/std/zig/system/windows.zig b/lib/std/zig/system/windows.zig index 0e9b8ec1d717ded76174a97e2fab99d60a4114ec..3f05ebb461f572271ec8312a9e66a3a1680d1f0c 100644 --- a/lib/std/zig/system/windows.zig +++ b/lib/std/zig/system/windows.zig @@ -43,7 +43,7 @@ pub fn detectRuntimeVersion() WindowsVersion { const version: u32 = @as(u32, os_ver) << 16 | @as(u16, sp_ver) << 8 | sub_ver; - return @as(WindowsVersion, @enumFromInt(version)); + return @as(WindowsVersion, @fromBackingInt(@intCast(version))); } // Technically, a registry value can be as long as 1MB. However, MS recommends storing @@ -188,7 +188,7 @@ fn getCpuInfoFromRegistry(core: usize, args: anytype) !void { } fn setFeature(comptime Feature: type, cpu: *Target.Cpu, feature: Feature, enabled: bool) void { - const idx = @as(Target.Cpu.Feature.Set.Index, @intFromEnum(feature)); + const idx = @as(Target.Cpu.Feature.Set.Index, @backingInt(feature)); if (enabled) cpu.features.addFeature(idx) else cpu.features.removeFeature(idx); } diff --git a/lib/std/zig/system/x86.zig b/lib/std/zig/system/x86.zig index eb09923ade6251266e1465dcf72fd36fdc5c2e1c..dd3abde589992dbddbafda4ee8c3a2676dd14e7c 100644 --- a/lib/std/zig/system/x86.zig +++ b/lib/std/zig/system/x86.zig @@ -28,7 +28,7 @@ const Xcr0 = packed struct(u32) { }; fn setFeature(cpu: *Target.Cpu, feature: Target.x86.Feature, enabled: bool) void { - const idx = @as(Target.Cpu.Feature.Set.Index, @intFromEnum(feature)); + const idx = @as(Target.Cpu.Feature.Set.Index, @backingInt(feature)); if (enabled) cpu.features.addFeature(idx) else cpu.features.removeFeature(idx); } diff --git a/lib/std/zip.zig b/lib/std/zip.zig index 3784605d0227653b8424dbc5345ff55a481878b0..a42a9f395c694c7df04d78e7ca63baafae3b6cfd 100644 --- a/lib/std/zip.zig +++ b/lib/std/zip.zig @@ -377,7 +377,7 @@ pub const Iterator = struct { if (end > extra.len) return error.ZipBadExtraFieldSize; const data = extra[extra_offset + 4 .. end]; - switch (@as(ExtraHeader, @enumFromInt(header_id))) { + switch (@as(ExtraHeader, @fromBackingInt(@intCast(header_id)))) { .zip64_info => try readZip64FileExtents(CentralDirectoryFileHeader, header, &extents, data), else => {}, // ignore } @@ -485,7 +485,7 @@ pub const Iterator = struct { if (end > local_header.extra_len) return error.ZipBadExtraFieldSize; const data = extra[extra_offset + 4 .. end]; - switch (@as(ExtraHeader, @enumFromInt(header_id))) { + switch (@as(ExtraHeader, @fromBackingInt(@intCast(header_id)))) { .zip64_info => try readZip64FileExtents(LocalFileHeader, local_header, &extents, data), else => {}, // ignore } diff --git a/lib/std/zon/parse.zig b/lib/std/zon/parse.zig index f7a3f6a59d05c8ca91cadea9967ed8acb0039d11..b22de08eacccf9c75e24a6f32e85ce7d795e12a8 100644 --- a/lib/std/zon/parse.zig +++ b/lib/std/zon/parse.zig @@ -183,7 +183,7 @@ pub const Error = union(enum) { location.column += node_or_offset; return location; } else { - const ast_node: Ast.Node.Index = @enumFromInt(node_or_offset); + const ast_node: Ast.Node.Index = @fromBackingInt(@intCast(node_or_offset)); const token = ast.nodeMainToken(ast_node); return ast.tokenLocation(0, token); } @@ -672,7 +672,7 @@ const Parser = struct { const enum_info = @typeInfo(T).@"enum"; comptime var kvs_list: [enum_info.field_names.len]struct { []const u8, T } = undefined; inline for (enum_info.field_names, enum_info.field_values, 0..) |enum_field_name, enum_field_value, i| { - kvs_list[i] = .{ enum_field_name, @enumFromInt(enum_field_value) }; + kvs_list[i] = .{ enum_field_name, @fromBackingInt(@intCast(enum_field_value)) }; } const enum_tags = std.StaticStringMap(T).initComptime(kvs_list); diff --git a/src/Air.zig b/src/Air.zig index 141ed8da170572cc6e27d7cd5bd6f5111c756b2e..fbaa370132a6044191d71a7b68d79915584fd979 100644 --- a/src/Air.zig +++ b/src/Air.zig @@ -1052,9 +1052,9 @@ pub const Inst = struct { _, pub fn unwrap(index: Index) union(enum) { ref: Inst.Ref, target: u31 } { - const low_index: u31 = @truncate(@intFromEnum(index)); - return switch (@as(u1, @intCast(@intFromEnum(index) >> 31))) { - 0 => .{ .ref = @enumFromInt(@as(u32, 1 << 31) | low_index) }, + const low_index: u31 = @truncate(@backingInt(index)); + return switch (@as(u1, @intCast(@backingInt(index) >> 31))) { + 0 => .{ .ref = @fromBackingInt(@intCast(@as(u32, 1 << 31) | low_index)) }, 1 => .{ .target = low_index }, }; } @@ -1064,7 +1064,7 @@ pub const Inst = struct { } pub fn fromTargetIndex(index: u31) Index { - return @enumFromInt((1 << 31) | @as(u32, index)); + return @fromBackingInt(@intCast((1 << 31) | @as(u32, index))); } pub fn toTargetIndex(index: Index) u31 { @@ -1077,7 +1077,7 @@ pub const Inst = struct { .ref => {}, .target => try w.writeByte('t'), } - try w.print("{d}", .{@as(u31, @truncate(@intFromEnum(index)))}); + try w.print("{d}", .{@as(u31, @truncate(@backingInt(index)))}); } }; @@ -1087,138 +1087,138 @@ pub const Inst = struct { /// /// The ref `none` is an exception: it has the tag bit set but refers to the InternPool. pub const Ref = enum(u32) { - u0_type = @intFromEnum(InternPool.Index.u0_type), - u1_type = @intFromEnum(InternPool.Index.u1_type), - u8_type = @intFromEnum(InternPool.Index.u8_type), - i8_type = @intFromEnum(InternPool.Index.i8_type), - u16_type = @intFromEnum(InternPool.Index.u16_type), - i16_type = @intFromEnum(InternPool.Index.i16_type), - u29_type = @intFromEnum(InternPool.Index.u29_type), - u32_type = @intFromEnum(InternPool.Index.u32_type), - i32_type = @intFromEnum(InternPool.Index.i32_type), - u64_type = @intFromEnum(InternPool.Index.u64_type), - i64_type = @intFromEnum(InternPool.Index.i64_type), - u80_type = @intFromEnum(InternPool.Index.u80_type), - u128_type = @intFromEnum(InternPool.Index.u128_type), - i128_type = @intFromEnum(InternPool.Index.i128_type), - u256_type = @intFromEnum(InternPool.Index.u256_type), - usize_type = @intFromEnum(InternPool.Index.usize_type), - isize_type = @intFromEnum(InternPool.Index.isize_type), - c_char_type = @intFromEnum(InternPool.Index.c_char_type), - c_short_type = @intFromEnum(InternPool.Index.c_short_type), - c_ushort_type = @intFromEnum(InternPool.Index.c_ushort_type), - c_int_type = @intFromEnum(InternPool.Index.c_int_type), - c_uint_type = @intFromEnum(InternPool.Index.c_uint_type), - c_long_type = @intFromEnum(InternPool.Index.c_long_type), - c_ulong_type = @intFromEnum(InternPool.Index.c_ulong_type), - c_longlong_type = @intFromEnum(InternPool.Index.c_longlong_type), - c_ulonglong_type = @intFromEnum(InternPool.Index.c_ulonglong_type), - c_longdouble_type = @intFromEnum(InternPool.Index.c_longdouble_type), - f16_type = @intFromEnum(InternPool.Index.f16_type), - f32_type = @intFromEnum(InternPool.Index.f32_type), - f64_type = @intFromEnum(InternPool.Index.f64_type), - f80_type = @intFromEnum(InternPool.Index.f80_type), - f128_type = @intFromEnum(InternPool.Index.f128_type), - anyopaque_type = @intFromEnum(InternPool.Index.anyopaque_type), - bool_type = @intFromEnum(InternPool.Index.bool_type), - void_type = @intFromEnum(InternPool.Index.void_type), - type_type = @intFromEnum(InternPool.Index.type_type), - anyerror_type = @intFromEnum(InternPool.Index.anyerror_type), - comptime_int_type = @intFromEnum(InternPool.Index.comptime_int_type), - comptime_float_type = @intFromEnum(InternPool.Index.comptime_float_type), - noreturn_type = @intFromEnum(InternPool.Index.noreturn_type), - anyframe_type = @intFromEnum(InternPool.Index.anyframe_type), - null_type = @intFromEnum(InternPool.Index.null_type), - undefined_type = @intFromEnum(InternPool.Index.undefined_type), - enum_literal_type = @intFromEnum(InternPool.Index.enum_literal_type), - ptr_usize_type = @intFromEnum(InternPool.Index.ptr_usize_type), - ptr_const_comptime_int_type = @intFromEnum(InternPool.Index.ptr_const_comptime_int_type), - manyptr_u8_type = @intFromEnum(InternPool.Index.manyptr_u8_type), - manyptr_const_u8_type = @intFromEnum(InternPool.Index.manyptr_const_u8_type), - manyptr_const_u8_sentinel_0_type = @intFromEnum(InternPool.Index.manyptr_const_u8_sentinel_0_type), - slice_const_u8_type = @intFromEnum(InternPool.Index.slice_const_u8_type), - slice_const_u8_sentinel_0_type = @intFromEnum(InternPool.Index.slice_const_u8_sentinel_0_type), - manyptr_const_slice_const_u8_type = @intFromEnum(InternPool.Index.manyptr_const_slice_const_u8_type), - slice_const_slice_const_u8_type = @intFromEnum(InternPool.Index.slice_const_slice_const_u8_type), - optional_type_type = @intFromEnum(InternPool.Index.optional_type_type), - manyptr_const_type_type = @intFromEnum(InternPool.Index.manyptr_const_type_type), - slice_const_type_type = @intFromEnum(InternPool.Index.slice_const_type_type), - vector_8_i8_type = @intFromEnum(InternPool.Index.vector_8_i8_type), - vector_16_i8_type = @intFromEnum(InternPool.Index.vector_16_i8_type), - vector_32_i8_type = @intFromEnum(InternPool.Index.vector_32_i8_type), - vector_64_i8_type = @intFromEnum(InternPool.Index.vector_64_i8_type), - vector_1_u8_type = @intFromEnum(InternPool.Index.vector_1_u8_type), - vector_2_u8_type = @intFromEnum(InternPool.Index.vector_2_u8_type), - vector_4_u8_type = @intFromEnum(InternPool.Index.vector_4_u8_type), - vector_8_u8_type = @intFromEnum(InternPool.Index.vector_8_u8_type), - vector_16_u8_type = @intFromEnum(InternPool.Index.vector_16_u8_type), - vector_32_u8_type = @intFromEnum(InternPool.Index.vector_32_u8_type), - vector_64_u8_type = @intFromEnum(InternPool.Index.vector_64_u8_type), - vector_2_i16_type = @intFromEnum(InternPool.Index.vector_2_i16_type), - vector_4_i16_type = @intFromEnum(InternPool.Index.vector_4_i16_type), - vector_8_i16_type = @intFromEnum(InternPool.Index.vector_8_i16_type), - vector_16_i16_type = @intFromEnum(InternPool.Index.vector_16_i16_type), - vector_32_i16_type = @intFromEnum(InternPool.Index.vector_32_i16_type), - vector_4_u16_type = @intFromEnum(InternPool.Index.vector_4_u16_type), - vector_8_u16_type = @intFromEnum(InternPool.Index.vector_8_u16_type), - vector_16_u16_type = @intFromEnum(InternPool.Index.vector_16_u16_type), - vector_32_u16_type = @intFromEnum(InternPool.Index.vector_32_u16_type), - vector_2_i32_type = @intFromEnum(InternPool.Index.vector_2_i32_type), - vector_4_i32_type = @intFromEnum(InternPool.Index.vector_4_i32_type), - vector_8_i32_type = @intFromEnum(InternPool.Index.vector_8_i32_type), - vector_16_i32_type = @intFromEnum(InternPool.Index.vector_16_i32_type), - vector_4_u32_type = @intFromEnum(InternPool.Index.vector_4_u32_type), - vector_8_u32_type = @intFromEnum(InternPool.Index.vector_8_u32_type), - vector_16_u32_type = @intFromEnum(InternPool.Index.vector_16_u32_type), - vector_2_i64_type = @intFromEnum(InternPool.Index.vector_2_i64_type), - vector_4_i64_type = @intFromEnum(InternPool.Index.vector_4_i64_type), - vector_8_i64_type = @intFromEnum(InternPool.Index.vector_8_i64_type), - vector_2_u64_type = @intFromEnum(InternPool.Index.vector_2_u64_type), - vector_4_u64_type = @intFromEnum(InternPool.Index.vector_4_u64_type), - vector_8_u64_type = @intFromEnum(InternPool.Index.vector_8_u64_type), - vector_1_u128_type = @intFromEnum(InternPool.Index.vector_1_u128_type), - vector_2_u128_type = @intFromEnum(InternPool.Index.vector_2_u128_type), - vector_1_u256_type = @intFromEnum(InternPool.Index.vector_1_u256_type), - vector_4_f16_type = @intFromEnum(InternPool.Index.vector_4_f16_type), - vector_8_f16_type = @intFromEnum(InternPool.Index.vector_8_f16_type), - vector_16_f16_type = @intFromEnum(InternPool.Index.vector_16_f16_type), - vector_32_f16_type = @intFromEnum(InternPool.Index.vector_32_f16_type), - vector_2_f32_type = @intFromEnum(InternPool.Index.vector_2_f32_type), - vector_4_f32_type = @intFromEnum(InternPool.Index.vector_4_f32_type), - vector_8_f32_type = @intFromEnum(InternPool.Index.vector_8_f32_type), - vector_16_f32_type = @intFromEnum(InternPool.Index.vector_16_f32_type), - vector_2_f64_type = @intFromEnum(InternPool.Index.vector_2_f64_type), - vector_4_f64_type = @intFromEnum(InternPool.Index.vector_4_f64_type), - vector_8_f64_type = @intFromEnum(InternPool.Index.vector_8_f64_type), - optional_noreturn_type = @intFromEnum(InternPool.Index.optional_noreturn_type), - anyerror_void_error_union_type = @intFromEnum(InternPool.Index.anyerror_void_error_union_type), - adhoc_inferred_error_set_type = @intFromEnum(InternPool.Index.adhoc_inferred_error_set_type), - generic_poison_type = @intFromEnum(InternPool.Index.generic_poison_type), - empty_tuple_type = @intFromEnum(InternPool.Index.empty_tuple_type), - undef = @intFromEnum(InternPool.Index.undef), - undef_bool = @intFromEnum(InternPool.Index.undef_bool), - undef_usize = @intFromEnum(InternPool.Index.undef_usize), - undef_u1 = @intFromEnum(InternPool.Index.undef_u1), - zero = @intFromEnum(InternPool.Index.zero), - zero_usize = @intFromEnum(InternPool.Index.zero_usize), - zero_u1 = @intFromEnum(InternPool.Index.zero_u1), - zero_u8 = @intFromEnum(InternPool.Index.zero_u8), - one = @intFromEnum(InternPool.Index.one), - one_usize = @intFromEnum(InternPool.Index.one_usize), - one_u1 = @intFromEnum(InternPool.Index.one_u1), - one_u8 = @intFromEnum(InternPool.Index.one_u8), - four_u8 = @intFromEnum(InternPool.Index.four_u8), - negative_one = @intFromEnum(InternPool.Index.negative_one), - void_value = @intFromEnum(InternPool.Index.void_value), - unreachable_value = @intFromEnum(InternPool.Index.unreachable_value), - null_value = @intFromEnum(InternPool.Index.null_value), - bool_true = @intFromEnum(InternPool.Index.bool_true), - bool_false = @intFromEnum(InternPool.Index.bool_false), - empty_tuple = @intFromEnum(InternPool.Index.empty_tuple), + u0_type = @backingInt(InternPool.Index.u0_type), + u1_type = @backingInt(InternPool.Index.u1_type), + u8_type = @backingInt(InternPool.Index.u8_type), + i8_type = @backingInt(InternPool.Index.i8_type), + u16_type = @backingInt(InternPool.Index.u16_type), + i16_type = @backingInt(InternPool.Index.i16_type), + u29_type = @backingInt(InternPool.Index.u29_type), + u32_type = @backingInt(InternPool.Index.u32_type), + i32_type = @backingInt(InternPool.Index.i32_type), + u64_type = @backingInt(InternPool.Index.u64_type), + i64_type = @backingInt(InternPool.Index.i64_type), + u80_type = @backingInt(InternPool.Index.u80_type), + u128_type = @backingInt(InternPool.Index.u128_type), + i128_type = @backingInt(InternPool.Index.i128_type), + u256_type = @backingInt(InternPool.Index.u256_type), + usize_type = @backingInt(InternPool.Index.usize_type), + isize_type = @backingInt(InternPool.Index.isize_type), + c_char_type = @backingInt(InternPool.Index.c_char_type), + c_short_type = @backingInt(InternPool.Index.c_short_type), + c_ushort_type = @backingInt(InternPool.Index.c_ushort_type), + c_int_type = @backingInt(InternPool.Index.c_int_type), + c_uint_type = @backingInt(InternPool.Index.c_uint_type), + c_long_type = @backingInt(InternPool.Index.c_long_type), + c_ulong_type = @backingInt(InternPool.Index.c_ulong_type), + c_longlong_type = @backingInt(InternPool.Index.c_longlong_type), + c_ulonglong_type = @backingInt(InternPool.Index.c_ulonglong_type), + c_longdouble_type = @backingInt(InternPool.Index.c_longdouble_type), + f16_type = @backingInt(InternPool.Index.f16_type), + f32_type = @backingInt(InternPool.Index.f32_type), + f64_type = @backingInt(InternPool.Index.f64_type), + f80_type = @backingInt(InternPool.Index.f80_type), + f128_type = @backingInt(InternPool.Index.f128_type), + anyopaque_type = @backingInt(InternPool.Index.anyopaque_type), + bool_type = @backingInt(InternPool.Index.bool_type), + void_type = @backingInt(InternPool.Index.void_type), + type_type = @backingInt(InternPool.Index.type_type), + anyerror_type = @backingInt(InternPool.Index.anyerror_type), + comptime_int_type = @backingInt(InternPool.Index.comptime_int_type), + comptime_float_type = @backingInt(InternPool.Index.comptime_float_type), + noreturn_type = @backingInt(InternPool.Index.noreturn_type), + anyframe_type = @backingInt(InternPool.Index.anyframe_type), + null_type = @backingInt(InternPool.Index.null_type), + undefined_type = @backingInt(InternPool.Index.undefined_type), + enum_literal_type = @backingInt(InternPool.Index.enum_literal_type), + ptr_usize_type = @backingInt(InternPool.Index.ptr_usize_type), + ptr_const_comptime_int_type = @backingInt(InternPool.Index.ptr_const_comptime_int_type), + manyptr_u8_type = @backingInt(InternPool.Index.manyptr_u8_type), + manyptr_const_u8_type = @backingInt(InternPool.Index.manyptr_const_u8_type), + manyptr_const_u8_sentinel_0_type = @backingInt(InternPool.Index.manyptr_const_u8_sentinel_0_type), + slice_const_u8_type = @backingInt(InternPool.Index.slice_const_u8_type), + slice_const_u8_sentinel_0_type = @backingInt(InternPool.Index.slice_const_u8_sentinel_0_type), + manyptr_const_slice_const_u8_type = @backingInt(InternPool.Index.manyptr_const_slice_const_u8_type), + slice_const_slice_const_u8_type = @backingInt(InternPool.Index.slice_const_slice_const_u8_type), + optional_type_type = @backingInt(InternPool.Index.optional_type_type), + manyptr_const_type_type = @backingInt(InternPool.Index.manyptr_const_type_type), + slice_const_type_type = @backingInt(InternPool.Index.slice_const_type_type), + vector_8_i8_type = @backingInt(InternPool.Index.vector_8_i8_type), + vector_16_i8_type = @backingInt(InternPool.Index.vector_16_i8_type), + vector_32_i8_type = @backingInt(InternPool.Index.vector_32_i8_type), + vector_64_i8_type = @backingInt(InternPool.Index.vector_64_i8_type), + vector_1_u8_type = @backingInt(InternPool.Index.vector_1_u8_type), + vector_2_u8_type = @backingInt(InternPool.Index.vector_2_u8_type), + vector_4_u8_type = @backingInt(InternPool.Index.vector_4_u8_type), + vector_8_u8_type = @backingInt(InternPool.Index.vector_8_u8_type), + vector_16_u8_type = @backingInt(InternPool.Index.vector_16_u8_type), + vector_32_u8_type = @backingInt(InternPool.Index.vector_32_u8_type), + vector_64_u8_type = @backingInt(InternPool.Index.vector_64_u8_type), + vector_2_i16_type = @backingInt(InternPool.Index.vector_2_i16_type), + vector_4_i16_type = @backingInt(InternPool.Index.vector_4_i16_type), + vector_8_i16_type = @backingInt(InternPool.Index.vector_8_i16_type), + vector_16_i16_type = @backingInt(InternPool.Index.vector_16_i16_type), + vector_32_i16_type = @backingInt(InternPool.Index.vector_32_i16_type), + vector_4_u16_type = @backingInt(InternPool.Index.vector_4_u16_type), + vector_8_u16_type = @backingInt(InternPool.Index.vector_8_u16_type), + vector_16_u16_type = @backingInt(InternPool.Index.vector_16_u16_type), + vector_32_u16_type = @backingInt(InternPool.Index.vector_32_u16_type), + vector_2_i32_type = @backingInt(InternPool.Index.vector_2_i32_type), + vector_4_i32_type = @backingInt(InternPool.Index.vector_4_i32_type), + vector_8_i32_type = @backingInt(InternPool.Index.vector_8_i32_type), + vector_16_i32_type = @backingInt(InternPool.Index.vector_16_i32_type), + vector_4_u32_type = @backingInt(InternPool.Index.vector_4_u32_type), + vector_8_u32_type = @backingInt(InternPool.Index.vector_8_u32_type), + vector_16_u32_type = @backingInt(InternPool.Index.vector_16_u32_type), + vector_2_i64_type = @backingInt(InternPool.Index.vector_2_i64_type), + vector_4_i64_type = @backingInt(InternPool.Index.vector_4_i64_type), + vector_8_i64_type = @backingInt(InternPool.Index.vector_8_i64_type), + vector_2_u64_type = @backingInt(InternPool.Index.vector_2_u64_type), + vector_4_u64_type = @backingInt(InternPool.Index.vector_4_u64_type), + vector_8_u64_type = @backingInt(InternPool.Index.vector_8_u64_type), + vector_1_u128_type = @backingInt(InternPool.Index.vector_1_u128_type), + vector_2_u128_type = @backingInt(InternPool.Index.vector_2_u128_type), + vector_1_u256_type = @backingInt(InternPool.Index.vector_1_u256_type), + vector_4_f16_type = @backingInt(InternPool.Index.vector_4_f16_type), + vector_8_f16_type = @backingInt(InternPool.Index.vector_8_f16_type), + vector_16_f16_type = @backingInt(InternPool.Index.vector_16_f16_type), + vector_32_f16_type = @backingInt(InternPool.Index.vector_32_f16_type), + vector_2_f32_type = @backingInt(InternPool.Index.vector_2_f32_type), + vector_4_f32_type = @backingInt(InternPool.Index.vector_4_f32_type), + vector_8_f32_type = @backingInt(InternPool.Index.vector_8_f32_type), + vector_16_f32_type = @backingInt(InternPool.Index.vector_16_f32_type), + vector_2_f64_type = @backingInt(InternPool.Index.vector_2_f64_type), + vector_4_f64_type = @backingInt(InternPool.Index.vector_4_f64_type), + vector_8_f64_type = @backingInt(InternPool.Index.vector_8_f64_type), + optional_noreturn_type = @backingInt(InternPool.Index.optional_noreturn_type), + anyerror_void_error_union_type = @backingInt(InternPool.Index.anyerror_void_error_union_type), + adhoc_inferred_error_set_type = @backingInt(InternPool.Index.adhoc_inferred_error_set_type), + generic_poison_type = @backingInt(InternPool.Index.generic_poison_type), + empty_tuple_type = @backingInt(InternPool.Index.empty_tuple_type), + undef = @backingInt(InternPool.Index.undef), + undef_bool = @backingInt(InternPool.Index.undef_bool), + undef_usize = @backingInt(InternPool.Index.undef_usize), + undef_u1 = @backingInt(InternPool.Index.undef_u1), + zero = @backingInt(InternPool.Index.zero), + zero_usize = @backingInt(InternPool.Index.zero_usize), + zero_u1 = @backingInt(InternPool.Index.zero_u1), + zero_u8 = @backingInt(InternPool.Index.zero_u8), + one = @backingInt(InternPool.Index.one), + one_usize = @backingInt(InternPool.Index.one_usize), + one_u1 = @backingInt(InternPool.Index.one_u1), + one_u8 = @backingInt(InternPool.Index.one_u8), + four_u8 = @backingInt(InternPool.Index.four_u8), + negative_one = @backingInt(InternPool.Index.negative_one), + void_value = @backingInt(InternPool.Index.void_value), + unreachable_value = @backingInt(InternPool.Index.unreachable_value), + null_value = @backingInt(InternPool.Index.null_value), + bool_true = @backingInt(InternPool.Index.bool_true), + bool_false = @backingInt(InternPool.Index.bool_false), + empty_tuple = @backingInt(InternPool.Index.empty_tuple), /// This Ref does not correspond to any AIR instruction or constant /// value and may instead be used as a sentinel to indicate null. - none = @intFromEnum(InternPool.Index.none), + none = @backingInt(InternPool.Index.none), _, pub fn toInterned(ref: Ref) ?InternPool.Index { @@ -1229,8 +1229,8 @@ pub const Inst = struct { pub fn toInternedAllowNone(ref: Ref) ?InternPool.Index { return switch (ref) { .none => .none, - else => if (@intFromEnum(ref) >> 31 == 0) - @enumFromInt(@as(u31, @truncate(@intFromEnum(ref)))) + else => if (@backingInt(ref) >> 31 == 0) + @fromBackingInt(@intCast(@as(u31, @truncate(@backingInt(ref))))) else null, }; @@ -1244,8 +1244,8 @@ pub const Inst = struct { pub fn toIndexAllowNone(ref: Ref) ?Index { return switch (ref) { .none => null, - else => if (@intFromEnum(ref) >> 31 != 0) - @enumFromInt(@as(u31, @truncate(@intFromEnum(ref)))) + else => if (@backingInt(ref) >> 31 != 0) + @fromBackingInt(@intCast(@as(u31, @truncate(@backingInt(ref))))) else null, }; @@ -1259,8 +1259,8 @@ pub const Inst = struct { return switch (ip_index) { .none => .none, else => { - assert(@intFromEnum(ip_index) >> 31 == 0); - return @enumFromInt(@as(u31, @intCast(@intFromEnum(ip_index)))); + assert(@backingInt(ip_index) >> 31 == 0); + return @fromBackingInt(@intCast(@as(u31, @intCast(@backingInt(ip_index))))); }, }; } @@ -1452,11 +1452,11 @@ pub const VectorCmp = struct { op: u32, pub fn compareOperator(self: VectorCmp) std.math.CompareOperator { - return @enumFromInt(@as(u3, @intCast(self.op))); + return @fromBackingInt(@intCast(@as(u3, @intCast(self.op)))); } pub fn encodeOp(compare_operator: std.math.CompareOperator) u32 { - return @intFromEnum(compare_operator); + return @backingInt(compare_operator); } }; @@ -1469,7 +1469,7 @@ pub const ShuffleOneMask = packed struct(u32) { return .{ .index = @intCast(idx), .kind = .elem }; } pub fn value(val: Value) ShuffleOneMask { - return .{ .index = @intCast(@intFromEnum(val.toIntern())), .kind = .value }; + return .{ .index = @intCast(@backingInt(val.toIntern())), .kind = .value }; } pub const Unwrapped = union(enum) { /// The resulting element is this index into the runtime vector. @@ -1481,7 +1481,7 @@ pub const ShuffleOneMask = packed struct(u32) { pub fn unwrap(raw: ShuffleOneMask) Unwrapped { return switch (raw.kind) { .elem => .{ .elem = raw.index }, - .value => .{ .value = @enumFromInt(raw.index) }, + .value => .{ .value = @fromBackingInt(@intCast(raw.index)) }, }; } }; @@ -1492,10 +1492,10 @@ pub const ShuffleTwoMask = enum(u32) { undef = std.math.maxInt(u32), _, pub fn aElem(idx: u32) ShuffleTwoMask { - return @enumFromInt(idx << 1); + return @fromBackingInt(@intCast(idx << 1)); } pub fn bElem(idx: u32) ShuffleTwoMask { - return @enumFromInt(idx << 1 | 1); + return @fromBackingInt(@intCast(idx << 1 | 1)); } pub const Unwrapped = union(enum) { /// The resulting element is this index into the first runtime vector. @@ -1510,7 +1510,7 @@ pub const ShuffleTwoMask = enum(u32) { .undef => return .undef, _ => {}, } - const x = @intFromEnum(raw); + const x = @backingInt(raw); return switch (@as(u1, @truncate(x))) { 0 => .{ .a_elem = x >> 1 }, 1 => .{ .b_elem = x >> 1 }, @@ -1556,11 +1556,11 @@ pub const Cmpxchg = struct { flags: u32, pub fn successOrder(self: Cmpxchg) std.lang.AtomicOrder { - return @enumFromInt(@as(u3, @truncate(self.flags))); + return @fromBackingInt(@intCast(@as(u3, @truncate(self.flags)))); } pub fn failureOrder(self: Cmpxchg) std.lang.AtomicOrder { - return @enumFromInt(@as(u3, @intCast(self.flags >> 3))); + return @fromBackingInt(@intCast(@as(u3, @intCast(self.flags >> 3)))); } }; @@ -1571,11 +1571,11 @@ pub const AtomicRmw = struct { flags: u32, pub fn ordering(self: AtomicRmw) std.lang.AtomicOrder { - return @enumFromInt(@as(u3, @truncate(self.flags))); + return @fromBackingInt(@intCast(@as(u3, @truncate(self.flags)))); } pub fn op(self: AtomicRmw) std.lang.AtomicRmwOp { - return @enumFromInt(@as(u4, @intCast(self.flags >> 3))); + return @fromBackingInt(@intCast(@as(u4, @intCast(self.flags >> 3)))); } }; @@ -1585,7 +1585,7 @@ pub const UnionInit = struct { }; pub fn getMainBody(air: Air) []const Air.Inst.Index { - const body_index = air.extra.items[@intFromEnum(ExtraIndex.main_block)]; + const body_index = air.extra.items[@backingInt(ExtraIndex.main_block)]; const extra = air.extraData(Block, body_index); return @ptrCast(air.extra.items[extra.end..][0..extra.data.body_len]); } @@ -1600,7 +1600,7 @@ pub fn typeOf(air: *const Air, inst: Air.Inst.Ref, ip: *const InternPool) Type { pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) Type { const datas = air.instructions.items(.data); - switch (air.instructions.items(.tag)[@intFromEnum(inst)]) { + switch (air.instructions.items(.tag)[@backingInt(inst)]) { .add, .add_safe, .add_wrap, @@ -1640,7 +1640,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) .div_exact_optimized, .rem_optimized, .mod_optimized, - => return air.typeOf(datas[@intFromEnum(inst)].bin_op.lhs, ip), + => return air.typeOf(datas[@backingInt(inst)].bin_op.lhs, ip), .sqrt, .sin, @@ -1657,7 +1657,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) .trunc_float, .neg, .neg_optimized, - => return air.typeOf(datas[@intFromEnum(inst)].un_op, ip), + => return air.typeOf(datas[@backingInt(inst)].un_op, ip), .cmp_lt, .cmp_lte, @@ -1688,9 +1688,9 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) .ret_ptr, .err_return_trace, .c_va_start, - => return datas[@intFromEnum(inst)].ty, + => return datas[@backingInt(inst)].ty, - .arg => return datas[@intFromEnum(inst)].arg.ty.toType(), + .arg => return datas[@backingInt(inst)].arg.ty.toType(), .assembly, .block, @@ -1717,7 +1717,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) .try_ptr_cold, .shuffle_one, .shuffle_two, - => return datas[@intFromEnum(inst)].ty_pl.ty.toType(), + => return datas[@backingInt(inst)].ty_pl.ty.toType(), .not, .bit_cast, @@ -1770,7 +1770,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) .c_va_arg, .c_va_copy, .abs, - => return datas[@intFromEnum(inst)].ty_op.ty.toType(), + => return datas[@backingInt(inst)].ty_op.ty.toType(), .loop, .repeat, @@ -1821,40 +1821,40 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) .tag_name, .error_name => return .slice_const_u8_sentinel_0, .call, .call_always_tail, .call_never_tail, .call_never_inline => { - const callee_ty = air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip); + const callee_ty = air.typeOf(datas[@backingInt(inst)].pl_op.operand, ip); return .fromInterned(ip.funcTypeReturnType(callee_ty.toIntern())); }, .slice_elem_val, .ptr_elem_val, .array_elem_val, .legalize_vec_elem_val => { - const ptr_ty = air.typeOf(datas[@intFromEnum(inst)].bin_op.lhs, ip); + const ptr_ty = air.typeOf(datas[@backingInt(inst)].bin_op.lhs, ip); return ptr_ty.childTypeIp(ip); }, .atomic_load => { - const ptr_ty = air.typeOf(datas[@intFromEnum(inst)].atomic_load.ptr, ip); + const ptr_ty = air.typeOf(datas[@backingInt(inst)].atomic_load.ptr, ip); return ptr_ty.childTypeIp(ip); }, .atomic_rmw => { - const ptr_ty = air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip); + const ptr_ty = air.typeOf(datas[@backingInt(inst)].pl_op.operand, ip); return ptr_ty.childTypeIp(ip); }, .reduce, .reduce_optimized => { - const operand_ty = air.typeOf(datas[@intFromEnum(inst)].reduce.operand, ip); + const operand_ty = air.typeOf(datas[@backingInt(inst)].reduce.operand, ip); return .fromInterned(ip.indexToKey(operand_ty.ip_index).vector_type.child); }, - .mul_add => return air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip), + .mul_add => return air.typeOf(datas[@backingInt(inst)].pl_op.operand, ip), .select => { - const extra = air.extraData(Air.Bin, datas[@intFromEnum(inst)].pl_op.payload).data; + const extra = air.extraData(Air.Bin, datas[@backingInt(inst)].pl_op.payload).data; return air.typeOf(extra.lhs, ip); }, .@"try", .try_cold => { - const err_union_ty = air.typeOf(datas[@intFromEnum(inst)].pl_op.operand, ip); + const err_union_ty = air.typeOf(datas[@backingInt(inst)].pl_op.operand, ip); return .fromInterned(ip.indexToKey(err_union_ty.ip_index).error_union_type.payload_type); }, - .runtime_nav_ptr => return .fromInterned(datas[@intFromEnum(inst)].ty_nav.ty), + .runtime_nav_ptr => return .fromInterned(datas[@backingInt(inst)].ty_nav.ty), .work_item_id, .work_group_size, @@ -1862,7 +1862,7 @@ pub fn typeOfIndex(air: *const Air, inst: Air.Inst.Index, ip: *const InternPool) .spirv_runtime_array_len, => return .u32, - .legalize_compiler_rt_call => return datas[@intFromEnum(inst)].legalize_compiler_rt_call.func.returnType(), + .legalize_compiler_rt_call => return datas[@backingInt(inst)].legalize_compiler_rt_call.func.returnType(), .inferred_alloc => unreachable, .inferred_alloc_comptime => unreachable, @@ -1878,7 +1878,7 @@ pub fn extraData(air: Air, comptime T: type, index: usize) struct { data: T, end inline for (info.field_names, info.field_types) |field_name, field_type| { @field(result, field_name) = switch (field_type) { u32 => air.extra.items[i], - InternPool.Index, Inst.Ref => @enumFromInt(air.extra.items[i]), + InternPool.Index, Inst.Ref => @fromBackingInt(@intCast(air.extra.items[i])), i32, CondBr.BranchHints, Asm.Flags => @bitCast(air.extra.items[i]), else => @compileError("bad field type: " ++ @typeName(field_type)), }; @@ -1906,7 +1906,7 @@ pub const NullTerminatedString = enum(u32) { pub fn toSlice(nts: NullTerminatedString, air: Air) [:0]const u8 { if (nts == .none) return ""; - const bytes = std.mem.sliceAsBytes(air.extra.items[@intFromEnum(nts)..]); + const bytes = std.mem.sliceAsBytes(air.extra.items[@backingInt(nts)..]); return bytes[0..std.mem.indexOfScalar(u8, bytes, 0).? :0]; } }; @@ -1916,8 +1916,8 @@ pub const NullTerminatedString = enum(u32) { /// lowered, and Liveness determines its result is unused, backends should /// avoid lowering it. pub fn mustLower(air: Air, inst: Air.Inst.Index, ip: *const InternPool) bool { - const data = air.instructions.items(.data)[@intFromEnum(inst)]; - return switch (air.instructions.items(.tag)[@intFromEnum(inst)]) { + const data = air.instructions.items(.data)[@backingInt(inst)]; + return switch (air.instructions.items(.tag)[@backingInt(inst)]) { .arg, .assembly, .block, @@ -2165,7 +2165,7 @@ pub const UnwrappedSwitch = struct { fn getHintInner(us: UnwrappedSwitch, idx: u32) std.lang.BranchHint { const bag = us.air.extra.items[us.branch_hints_start..][idx / 10]; const bits: u3 = @truncate(bag >> @intCast(3 * (idx % 10))); - return @enumFromInt(bits); + return @fromBackingInt(@intCast(bits)); } pub fn iterateCases(us: UnwrappedSwitch) CaseIterator { @@ -2224,7 +2224,7 @@ pub const UnwrappedSwitch = struct { }; pub fn unwrapSwitch(air: *const Air, switch_inst: Inst.Index) UnwrappedSwitch { - const inst = air.instructions.get(@intFromEnum(switch_inst)); + const inst = air.instructions.get(@backingInt(switch_inst)); switch (inst.tag) { .switch_br, .loop_switch_br => {}, else => unreachable, // assertion failure @@ -2249,8 +2249,8 @@ pub const UnwrappedDbgInlineBlock = struct { }; pub fn unwrapDbgBlock(air: *const Air, inst_index: Inst.Index) UnwrappedDbgInlineBlock { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; assert(tag == .dbg_inline_block); const payload = data.ty_pl.payload; const extra = air.extraData(Air.DbgInlineBlock, payload); @@ -2267,8 +2267,8 @@ pub const UnwrappedBlock = struct { }; pub fn unwrapBlock(air: *const Air, inst_index: Inst.Index) UnwrappedBlock { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; const payload = switch (tag) { .block, .loop => data.ty_pl.payload, else => unreachable, @@ -2286,8 +2286,8 @@ pub const UnwrappedCall = struct { }; pub fn unwrapCall(air: *const Air, inst_index: Inst.Index) UnwrappedCall { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; const payload = switch (tag) { .call, .call_always_tail, .call_never_tail, .call_never_inline => data.pl_op.payload, else => unreachable, @@ -2305,8 +2305,8 @@ pub const UnwrappedCompilerRtCall = struct { }; pub fn unwrapCompilerRtCall(air: *const Air, inst_index: Inst.Index) UnwrappedCompilerRtCall { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; assert(tag == .legalize_compiler_rt_call); const payload = data.legalize_compiler_rt_call.payload; const extra = air.extraData(Air.Call, payload); @@ -2324,8 +2324,8 @@ pub const UnwrappedCondBr = struct { }; pub fn unwrapCondBr(air: *const Air, inst_index: Inst.Index) UnwrappedCondBr { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; assert(tag == .cond_br); const payload = data.pl_op.payload; const extra = air.extraData(Air.CondBr, payload); @@ -2343,8 +2343,8 @@ pub const UnwrappedTry = struct { }; pub fn unwrapTry(air: *const Air, inst_index: Inst.Index) UnwrappedTry { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; assert(tag == .@"try" or tag == .try_cold); const payload = data.pl_op.payload; const extra = air.extraData(Air.Try, payload); @@ -2361,8 +2361,8 @@ pub const UnwrappedTryPtr = struct { }; pub fn unwrapTryPtr(air: *const Air, inst_index: Inst.Index) UnwrappedTryPtr { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; assert(tag == .try_ptr or tag == .try_ptr_cold); const payload = data.ty_pl.payload; const extra = air.extraData(Air.TryPtr, payload); @@ -2430,8 +2430,8 @@ pub const UnwrappedAsm = struct { }; pub fn unwrapAsm(air: *const Air, inst_index: Inst.Index) UnwrappedAsm { - const data = air.instructions.items(.data)[@intFromEnum(inst_index)]; - const tag = air.instructions.items(.tag)[@intFromEnum(inst_index)]; + const data = air.instructions.items(.data)[@backingInt(inst_index)]; + const tag = air.instructions.items(.tag)[@backingInt(inst_index)]; assert(tag == .assembly); const payload = data.ty_pl.payload; const extra = air.extraData(Air.Asm, payload); @@ -2465,7 +2465,7 @@ pub const UnwrappedShuffleOne = struct { }; pub fn unwrapShuffleOne(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index) UnwrappedShuffleOne { - const inst = air.instructions.get(@intFromEnum(inst_index)); + const inst = air.instructions.get(@backingInt(inst_index)); switch (inst.tag) { .shuffle_one => {}, else => unreachable, // assertion failure @@ -2475,7 +2475,7 @@ pub fn unwrapShuffleOne(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index const extra_idx = inst.data.ty_pl.payload; return .{ .result_ty = result_ty, - .operand = @enumFromInt(air.extra.items[extra_idx + mask_len]), + .operand = @fromBackingInt(@intCast(air.extra.items[extra_idx + mask_len])), .mask = @ptrCast(air.extra.items[extra_idx..][0..mask_len]), }; } @@ -2488,7 +2488,7 @@ pub const UnwrappedShuffleTwo = struct { }; pub fn unwrapShuffleTwo(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index) UnwrappedShuffleTwo { - const inst = air.instructions.get(@intFromEnum(inst_index)); + const inst = air.instructions.get(@backingInt(inst_index)); switch (inst.tag) { .shuffle_two => {}, else => unreachable, // assertion failure @@ -2498,8 +2498,8 @@ pub fn unwrapShuffleTwo(air: *const Air, zcu: *const Zcu, inst_index: Inst.Index const extra_idx = inst.data.ty_pl.payload; return .{ .result_ty = result_ty, - .operand_a = @enumFromInt(air.extra.items[extra_idx + mask_len + 0]), - .operand_b = @enumFromInt(air.extra.items[extra_idx + mask_len + 1]), + .operand_a = @fromBackingInt(@intCast(air.extra.items[extra_idx + mask_len + 0])), + .operand_b = @fromBackingInt(@intCast(air.extra.items[extra_idx + mask_len + 1])), .mask = @ptrCast(air.extra.items[extra_idx..][0..mask_len]), }; } diff --git a/src/Air/Legalize.zig b/src/Air/Legalize.zig index 0feca2b747ac0203bb340ac1475e6c37d5afa9ec..535d9394654a130ef856342f3390473d6664cf93 100644 --- a/src/Air/Legalize.zig +++ b/src/Air/Legalize.zig @@ -328,7 +328,7 @@ pub fn legalize(air: *Air, pt: Zcu.PerThread, features: *const Features) Error!v .features = .init(features), }; defer air.* = l.getTmpAir(); - const main_extra = l.extraData(Air.Block, l.air_extra.items[@intFromEnum(Air.ExtraIndex.main_block)]); + const main_extra = l.extraData(Air.Block, l.air_extra.items[@backingInt(Air.ExtraIndex.main_block)]); try l.legalizeBody(main_extra.end, main_extra.data.body_len); } @@ -359,8 +359,8 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { const zcu = l.pt.zcu; const ip = &zcu.intern_pool; for (0..body_len) |body_index| { - const inst: Air.Inst.Index = @enumFromInt(l.air_extra.items[body_start + body_index]); - inst: switch (l.air_instructions.items(.tag)[@intFromEnum(inst)]) { + const inst: Air.Inst.Index = @fromBackingInt(@intCast(l.air_extra.items[body_start + body_index])); + inst: switch (l.air_instructions.items(.tag)[@backingInt(inst)]) { .arg => {}, inline .add, .add_optimized, @@ -377,7 +377,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .min, .max, => |air_tag| { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; const ty = l.typeOf(bin_op.lhs); switch (l.wantScalarizeOrSoftFloat(air_tag, ty)) { .none => {}, @@ -395,7 +395,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .div_floor, .div_floor_optimized, => |air_tag| { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; switch (l.wantScalarizeOrSoftFloat(air_tag, l.typeOf(bin_op.lhs))) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .bin_op)), @@ -408,7 +408,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, inline .mod, .mod_optimized => |air_tag| { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; switch (l.wantScalarizeOrSoftFloat(air_tag, l.typeOf(bin_op.lhs))) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .bin_op)), @@ -429,7 +429,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .bit_or, .xor, => |air_tag| if (l.features.has(comptime .scalarize(air_tag))) { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; if (l.typeOf(bin_op.lhs).isVector(zcu)) { continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .bin_op)); } @@ -438,7 +438,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { assert(!l.features.has(.scalarize_add_safe)); // it doesn't make sense to do both continue :inst l.replaceInst(inst, .block, try l.safeArithmeticBlockPayload(inst, .add_with_overflow)); } else if (l.features.has(.scalarize_add_safe)) { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; if (l.typeOf(bin_op.lhs).isVector(zcu)) { continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .bin_op)); } @@ -447,7 +447,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { assert(!l.features.has(.scalarize_sub_safe)); // it doesn't make sense to do both continue :inst l.replaceInst(inst, .block, try l.safeArithmeticBlockPayload(inst, .sub_with_overflow)); } else if (l.features.has(.scalarize_sub_safe)) { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; if (l.typeOf(bin_op.lhs).isVector(zcu)) { continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .bin_op)); } @@ -456,7 +456,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { assert(!l.features.has(.scalarize_mul_safe)); // it doesn't make sense to do both continue :inst l.replaceInst(inst, .block, try l.safeArithmeticBlockPayload(inst, .mul_with_overflow)); } else if (l.features.has(.scalarize_mul_safe)) { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; if (l.typeOf(bin_op.lhs).isVector(zcu)) { continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .bin_op)); } @@ -467,7 +467,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .mul_with_overflow, .shl_with_overflow, => |air_tag| if (l.features.has(comptime .scalarize(air_tag))) { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; if (ty_pl.ty.toType().fieldType(0, zcu).isVector(zcu)) { continue :inst l.replaceInst(inst, .block, try l.scalarizeOverflowBlockPayload(inst)); } @@ -484,7 +484,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .unsplat_shift_rhs, .scalarize(air_tag), })) { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; if (l.typeOf(bin_op.rhs).isVector(zcu)) { if (l.features.has(.unsplat_shift_rhs)) { if (bin_op.rhs.toInterned()) |rhs_ip_index| switch (ip.indexToKey(rhs_ip_index)) { @@ -498,11 +498,11 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { }, } else { const rhs_inst = bin_op.rhs.toIndex().?; - switch (l.air_instructions.items(.tag)[@intFromEnum(rhs_inst)]) { + switch (l.air_instructions.items(.tag)[@backingInt(rhs_inst)]) { else => {}, .splat => continue :inst l.replaceInst(inst, air_tag, .{ .bin_op = .{ .lhs = bin_op.lhs, - .rhs = l.air_instructions.items(.data)[@intFromEnum(rhs_inst)].ty_op.operand, + .rhs = l.air_instructions.items(.data)[@backingInt(rhs_inst)].ty_op.operand, } }), } } @@ -524,13 +524,13 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .int_from_ptr, .trunc, => |air_tag| if (l.features.has(comptime .scalarize(air_tag))) { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; if (ty_op.ty.toType().isVector(zcu)) { continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .ty_op)); } }, .abs => { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; switch (l.wantScalarizeOrSoftFloat(.abs, ty_op.ty.toType())) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .ty_op)), @@ -543,7 +543,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .fptrunc => { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; const src_ty = l.typeOf(ty_op.operand); const dest_ty = ty_op.ty.toType(); if (src_ty.zigTypeTag(zcu) == .vector) { @@ -558,7 +558,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .fpext => { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; const src_ty = l.typeOf(ty_op.operand); const dest_ty = ty_op.ty.toType(); if (src_ty.zigTypeTag(zcu) == .vector) { @@ -573,7 +573,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, inline .int_from_float, .int_from_float_optimized => |air_tag| { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; switch (l.wantScalarizeOrSoftFloat(air_tag, l.typeOf(ty_op.operand))) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .ty_op)), @@ -584,7 +584,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .float_from_int => { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; const dest_ty = ty_op.ty.toType(); switch (l.wantScalarizeOrSoftFloat(.float_from_int, dest_ty)) { .none => {}, @@ -608,7 +608,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { if (try l.safeBitcastBlockPayload(inst)) |payload| { continue :inst l.replaceInst(inst, .block, payload); } - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; continue :inst l.replaceInst(inst, .bit_cast, .{ .ty_op = ty_op }); } else if (l.features.hasAny(&.{ .scalarize_bit_cast_array, @@ -624,10 +624,10 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { if (try l.safeIntcastBlockPayload(inst)) |payload| { continue :inst l.replaceInst(inst, .block, payload); } - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; continue :inst l.replaceInst(inst, .int_cast, .{ .ty_op = ty_op }); } else if (l.features.has(.scalarize_int_cast_safe)) { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; if (ty_op.ty.toType().isVector(zcu)) { continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .ty_op)); } @@ -643,7 +643,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { assert(!l.features.has(.scalarize(air_tag))); // it doesn't make sense to do both continue :inst l.replaceInst(inst, .block, try l.divCeilBlockPayload(inst, air_tag)); } else { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; switch (l.wantScalarizeOrSoftFloat(air_tag, l.typeOf(bin_op.lhs))) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .bin_op)), @@ -669,7 +669,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { assert(!l.features.has(.scalarize(air_tag))); continue :inst l.replaceInst(inst, .block, try l.safeIntFromFloatBlockPayload(inst, optimized)); } - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; switch (l.wantScalarizeOrSoftFloat(air_tag, l.typeOf(ty_op.operand))) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .ty_op)), @@ -678,7 +678,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .block, .loop => { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = l.extraData(Air.Block, ty_pl.payload); try l.legalizeBody(extra.end, extra.data.body_len); }, @@ -707,7 +707,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .round, .trunc_float, => |air_tag| { - const operand = l.air_instructions.items(.data)[@intFromEnum(inst)].un_op; + const operand = l.air_instructions.items(.data)[@backingInt(inst)].un_op; const ty = l.typeOf(operand); switch (l.wantScalarizeOrSoftFloat(air_tag, ty)) { .none => {}, @@ -721,7 +721,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, inline .neg, .neg_optimized => |air_tag| { - const operand = l.air_instructions.items(.data)[@intFromEnum(inst)].un_op; + const operand = l.air_instructions.items(.data)[@backingInt(inst)].un_op; switch (l.wantScalarizeOrSoftFloat(air_tag, l.typeOf(operand))) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeBlockPayload(inst, .un_op)), @@ -741,7 +741,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .cmp_neq, .cmp_neq_optimized, => |air_tag| { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; const ty = l.typeOf(bin_op.lhs); if (l.wantSoftFloatScalar(ty)) { continue :inst l.replaceInst( @@ -752,7 +752,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, inline .cmp_vector, .cmp_vector_optimized => |air_tag| { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; const payload = l.extraData(Air.VectorCmp, ty_pl.payload).data; switch (l.wantScalarizeOrSoftFloat(air_tag, l.typeOf(payload.lhs))) { .none => {}, @@ -761,13 +761,13 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .cond_br => { - const pl_op = l.air_instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = l.air_instructions.items(.data)[@backingInt(inst)].pl_op; const extra = l.extraData(Air.CondBr, pl_op.payload); try l.legalizeBody(extra.end, extra.data.then_body_len); try l.legalizeBody(extra.end + extra.data.then_body_len, extra.data.else_body_len); }, .switch_br, .loop_switch_br => { - const pl_op = l.air_instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = l.air_instructions.items(.data)[@backingInt(inst)].pl_op; const extra = l.extraData(Air.SwitchBr, pl_op.payload); const hint_bag_count = @divCeil(extra.data.cases_len + 1, 10); var extra_index = extra.end + hint_bag_count; @@ -781,18 +781,18 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { }, .switch_dispatch => {}, .@"try", .try_cold => { - const pl_op = l.air_instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = l.air_instructions.items(.data)[@backingInt(inst)].pl_op; const extra = l.extraData(Air.Try, pl_op.payload); try l.legalizeBody(extra.end, extra.data.body_len); }, .try_ptr, .try_ptr_cold => { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = l.extraData(Air.TryPtr, ty_pl.payload); try l.legalizeBody(extra.end, extra.data.body_len); }, .dbg_stmt, .dbg_empty_stmt => {}, .dbg_inline_block => { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = l.extraData(Air.DbgInlineBlock, ty_pl.payload); try l.legalizeBody(extra.end, extra.data.body_len); }, @@ -809,7 +809,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .is_non_err_ptr, => {}, .load => if (l.features.has(.expand_packed_load)) { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; const ptr_info = l.typeOf(ty_op.operand).ptrInfo(zcu); if (ptr_info.packed_offset.host_size > 0 and ptr_info.flags.vector_index == .none) { continue :inst l.replaceInst(inst, .block, try l.packedLoadBlockPayload(inst)); @@ -817,7 +817,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { }, .ret, .ret_safe, .ret_load => {}, .store, .store_safe => if (l.features.has(.expand_packed_store)) { - const bin_op = l.air_instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_info = l.typeOf(bin_op.lhs).ptrInfo(zcu); if (ptr_info.packed_offset.host_size > 0 and ptr_info.flags.vector_index == .none) { continue :inst l.replaceInst(inst, .block, try l.packedStoreBlockPayload(inst)); @@ -842,7 +842,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .struct_field_ptr_index_3, => {}, .agg_field_val => if (l.features.has(.expand_packed_agg_field_val)) { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = l.extraData(Air.StructField, ty_pl.payload).data; switch (l.typeOf(extra.struct_operand).containerLayout(zcu)) { .auto, .@"extern" => {}, @@ -864,7 +864,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .array_to_slice, => {}, inline .reduce, .reduce_optimized => |air_tag| { - const reduce = l.air_instructions.items(.data)[@intFromEnum(inst)].reduce; + const reduce = l.air_instructions.items(.data)[@backingInt(inst)].reduce; const vector_ty = l.typeOf(reduce.operand); if (l.features.has(.reduce_one_elem_to_bit_cast)) { switch (vector_ty.vectorLen(zcu)) { @@ -887,7 +887,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .splat => if (l.features.has(.splat_one_elem_to_bit_cast)) { - const ty_op = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(inst)].ty_op; switch (ty_op.ty.toType().vectorLen(zcu)) { 0 => unreachable, 1 => continue :inst l.replaceInst(inst, .bit_cast, .{ .ty_op = .{ @@ -898,7 +898,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .shuffle_one => { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; switch (l.wantScalarizeOrSoftFloat(.shuffle_one, ty_pl.ty.toType())) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeShuffleOneBlockPayload(inst)), @@ -906,7 +906,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .shuffle_two => { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; switch (l.wantScalarizeOrSoftFloat(.shuffle_two, ty_pl.ty.toType())) { .none => {}, .scalarize => continue :inst l.replaceInst(inst, .block, try l.scalarizeShuffleTwoBlockPayload(inst)), @@ -914,7 +914,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { } }, .select => { - const pl_op = l.air_instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = l.air_instructions.items(.data)[@backingInt(inst)].pl_op; const bin = l.extraData(Air.Bin, pl_op.payload).data; switch (l.wantScalarizeOrSoftFloat(.select, l.typeOf(bin.lhs))) { .none => {}, @@ -940,7 +940,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { .error_set_has_value, => {}, .aggregate_init => if (l.features.has(.expand_packed_aggregate_init)) { - const ty_pl = l.air_instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = l.air_instructions.items(.data)[@backingInt(inst)].ty_pl; const agg_ty = ty_pl.ty.toType(); switch (agg_ty.zigTypeTag(zcu)) { else => {}, @@ -958,7 +958,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { // Just bitcast this field. continue :inst l.replaceInst(inst, .bit_cast, .{ .ty_op = .{ .ty = .fromType(agg_ty), - .operand = @enumFromInt(l.air_extra.items[ty_pl.payload + field_index]), + .operand = @fromBackingInt(@intCast(l.air_extra.items[ty_pl.payload + field_index])), } }); } } @@ -971,7 +971,7 @@ fn legalizeBody(l: *Legalize, body_start: usize, body_len: usize) Error!void { }, .union_init, .prefetch => {}, .mul_add => { - const pl_op = l.air_instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = l.air_instructions.items(.data)[@backingInt(inst)].pl_op; const ty = l.typeOf(pl_op.operand); switch (l.wantScalarizeOrSoftFloat(.mul_add, ty)) { .none => {}, @@ -1017,7 +1017,7 @@ fn scalarizeBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, form: Scalariz const pt = l.pt; const zcu = pt.zcu; - const orig = l.air_instructions.get(@intFromEnum(orig_inst)); + const orig = l.air_instructions.get(@backingInt(orig_inst)); const res_ty = l.typeOfIndex(orig_inst); const result_is_array = switch (res_ty.zigTypeTag(zcu)) { .vector => false, @@ -1167,7 +1167,7 @@ fn scalarizeBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, form: Scalariz try condbr.finish(l); const inst_data = l.air_instructions.items(.data); - inst_data[@intFromEnum(elem_block_inst)].ty_pl.payload = try l.addBlockBody(elem_block.body()); + inst_data[@backingInt(elem_block_inst)].ty_pl.payload = try l.addBlockBody(elem_block.body()); break :elem elem_block_inst.toRef(); }, @@ -1519,13 +1519,13 @@ fn addScalarizedShuffle( try loop.finish(l); const inst_data = l.air_instructions.items(.data); - inst_data[@intFromEnum(main_block_inst)].ty_pl.payload = try l.addBlockBody(main_block.body()); + inst_data[@backingInt(main_block_inst)].ty_pl.payload = try l.addBlockBody(main_block.body()); } fn scalarizeBitcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!?Air.Inst.Data { const pt = l.pt; const zcu = pt.zcu; - const ty_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_op; const dest_ty = ty_op.ty.toType(); const operand_ty = l.typeOf(ty_op.operand); @@ -1723,7 +1723,7 @@ fn scalarizeBitcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!? try loop.finish(l); const inst_data = l.air_instructions.items(.data); - inst_data[@intFromEnum(uint_block_inst)].ty_pl.payload = try l.addBlockBody(uint_block.body()); + inst_data[@backingInt(uint_block_inst)].ty_pl.payload = try l.addBlockBody(uint_block.body()); break :uint_val uint_block_inst.toRef(); }; @@ -1736,7 +1736,7 @@ fn scalarizeBitcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!? if (int_to_dest_ok) { _ = main_block.stealCapacity(17); - const result = switch (l.air_instructions.items(.tag)[@intFromEnum(orig_inst)]) { + const result = switch (l.air_instructions.items(.tag)[@backingInt(orig_inst)]) { .bit_cast => main_block.addBitCast(l, dest_ty, uint_val), .bit_cast_safe => main_block.add(l, .{ .tag = .bit_cast_safe, @@ -1752,7 +1752,7 @@ fn scalarizeBitcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!? _ = main_block.stealCapacity(16); const elem = main_block.addBitCast(l, dest_ty.childType(zcu), uint_val); const aggregate_init_payload_start = l.air_extra.items.len; - try l.air_extra.append(zcu.gpa, @intFromEnum(elem)); + try l.air_extra.append(zcu.gpa, @backingInt(elem)); const result = main_block.add(l, .{ .tag = .aggregate_init, .data = .{ .ty_pl = .{ @@ -1863,7 +1863,7 @@ fn scalarizeOverflowBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error! const pt = l.pt; const zcu = pt.zcu; - const orig = l.air_instructions.get(@intFromEnum(orig_inst)); + const orig = l.air_instructions.get(@backingInt(orig_inst)); const orig_operands = l.extraData(Air.Bin, orig.data.ty_pl.payload).data; const vec_tuple_ty = l.typeOfIndex(orig_inst); @@ -2009,7 +2009,7 @@ fn scalarizeReduceBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, optimize const pt = l.pt; const zcu = pt.zcu; - const reduce = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].reduce; + const reduce = l.air_instructions.items(.data)[@backingInt(orig_inst)].reduce; const vector_ty = l.typeOf(reduce.operand); const scalar_ty = vector_ty.childType(zcu); @@ -2136,7 +2136,7 @@ fn scalarizeReduceBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, optimize fn safeBitcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!?Air.Inst.Data { const pt = l.pt; const zcu = pt.zcu; - const ty_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_op; const operand_ref = ty_op.operand; const dest_ty = ty_op.ty.toType(); @@ -2191,7 +2191,7 @@ fn safeBitcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!?Air.I fn safeIntcastBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!?Air.Inst.Data { const pt = l.pt; const zcu = pt.zcu; - const ty_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_op; const operand_ref = ty_op.operand; const operand_ty = l.typeOf(operand_ref); @@ -2362,7 +2362,7 @@ fn safeIntFromFloatBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, optimiz const pt = l.pt; const zcu = pt.zcu; const gpa = zcu.gpa; - const ty_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_op; const operand_ref = ty_op.operand; const operand_ty = l.typeOf(operand_ref); @@ -2470,7 +2470,7 @@ fn safeIntFromFloatBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, optimiz fn safeArithmeticBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index, overflow_op_tag: Air.Inst.Tag) Error!Air.Inst.Data { const pt = l.pt; const zcu = pt.zcu; - const bin_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].bin_op; const operand_ty = l.typeOf(bin_op.lhs); assert(l.typeOf(bin_op.rhs).toIntern() == operand_ty.toIntern()); @@ -2567,7 +2567,7 @@ fn divCeilBlockPayload( const zcu = pt.zcu; const gpa = zcu.gpa; - const bin_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].bin_op; + const bin_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].bin_op; const operand_ty = l.typeOf(bin_op.lhs); assert(l.typeOf(bin_op.rhs).toIntern() == operand_ty.toIntern()); @@ -2715,7 +2715,7 @@ fn packedLoadBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!Air.Ins const pt = l.pt; const zcu = pt.zcu; - const orig_ty_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_op; + const orig_ty_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_op; const res_ty = orig_ty_op.ty.toType(); const res_int_ty = try pt.intType(.unsigned, @intCast(res_ty.bitSize(zcu))); const ptr_ty = l.typeOf(orig_ty_op.operand); @@ -2771,7 +2771,7 @@ fn packedStoreBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Error!Air.In const pt = l.pt; const zcu = pt.zcu; - const orig_bin_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].bin_op; + const orig_bin_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].bin_op; const ptr_ty = l.typeOf(orig_bin_op.lhs); const ptr_info = ptr_ty.ptrInfo(zcu); const operand_ty = l.typeOf(orig_bin_op.rhs); @@ -2869,7 +2869,7 @@ fn packedStructFieldValBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Err const pt = l.pt; const zcu = pt.zcu; - const orig_ty_pl = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_pl; + const orig_ty_pl = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_pl; const orig_extra = l.extraData(Air.StructField, orig_ty_pl.payload).data; const field_ty = orig_ty_pl.ty.toType(); const agg_ty = l.typeOf(orig_extra.struct_operand); @@ -2903,7 +2903,7 @@ fn packedAggregateInitBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Erro const zcu = pt.zcu; const gpa = zcu.gpa; - const orig_ty_pl = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_pl; + const orig_ty_pl = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_pl; const agg_ty = orig_ty_pl.ty.toType(); const agg_field_count = agg_ty.structFieldCount(zcu); @@ -2930,7 +2930,7 @@ fn packedAggregateInitBlockPayload(l: *Legalize, orig_inst: Air.Inst.Index) Erro assert(field_bits < num_bits); const field_uint_ty = try pt.intType(.unsigned, field_bits); const field_bit_size_ref: Air.Inst.Ref = .fromValue(try pt.intValue(shift_ty, field_bits)); - const field_val: Air.Inst.Ref = @enumFromInt(l.air_extra.items[orig_ty_pl.payload + field_idx]); + const field_val: Air.Inst.Ref = @fromBackingInt(@intCast(l.air_extra.items[orig_ty_pl.payload + field_idx])); const shifted = main_block.addBinOp(l, .shl_exact, cur_uint, field_bit_size_ref).toRef(); const field_as_uint = main_block.addBitCast(l, field_uint_ty, field_val); @@ -3298,7 +3298,7 @@ const Loop = struct { } fn finish(loop: Loop, l: *Legalize) Error!void { - const data = &l.air_instructions.items(.data)[@intFromEnum(loop.inst)]; + const data = &l.air_instructions.items(.data)[@backingInt(loop.inst)]; data.ty_pl.payload = try l.addBlockBody(loop.block.body()); } }; @@ -3331,7 +3331,7 @@ const CondBr = struct { const else_body = cond_br.else_block.body(); try l.air_extra.ensureUnusedCapacity(l.pt.zcu.gpa, 3 + then_body.len + else_body.len); - const data = &l.air_instructions.items(.data)[@intFromEnum(cond_br.inst)]; + const data = &l.air_instructions.items(.data)[@backingInt(cond_br.inst)]; data.pl_op.payload = @intCast(l.air_extra.items.len); l.air_extra.appendSliceAssumeCapacity(&.{ @intCast(then_body.len), @@ -3345,7 +3345,7 @@ const CondBr = struct { fn addInstAssumeCapacity(l: *Legalize, inst: Air.Inst) Air.Inst.Index { defer l.air_instructions.appendAssumeCapacity(inst); - return @enumFromInt(l.air_instructions.len); + return @fromBackingInt(@intCast(l.air_instructions.len)); } fn addExtra(l: *Legalize, comptime Extra: type, extra: Extra) Error!u32 { @@ -3353,7 +3353,7 @@ fn addExtra(l: *Legalize, comptime Extra: type, extra: Extra) Error!u32 { try l.air_extra.ensureUnusedCapacity(l.pt.zcu.gpa, extra_info.field_names.len); defer inline for (extra_info.field_names, extra_info.field_types) |field_name, field_type| l.air_extra.appendAssumeCapacity(switch (field_type) { u32 => @field(extra, field_name), - Air.Inst.Ref => @intFromEnum(@field(extra, field_name)), + Air.Inst.Ref => @backingInt(@field(extra, field_name)), else => @compileError(@typeName(field_type)), }); return @intCast(l.air_extra.items.len); @@ -3372,7 +3372,7 @@ fn addBlockBody(l: *Legalize, body: []const Air.Inst.Index) Error!u32 { /// `inline` to propagate the comptime-known `tag` result. inline fn replaceInst(l: *Legalize, inst: Air.Inst.Index, comptime tag: Air.Inst.Tag, data: Air.Inst.Data) Air.Inst.Tag { const orig_ty = if (std.debug.runtime_safety) l.typeOfIndex(inst) else {}; - l.air_instructions.set(@intFromEnum(inst), .{ .tag = tag, .data = data }); + l.air_instructions.set(@backingInt(inst), .{ .tag = tag, .data = data }); if (std.debug.runtime_safety) assert(l.typeOfIndex(inst).toIntern() == orig_ty.toIntern()); return tag; } @@ -3436,7 +3436,7 @@ fn softFptruncFunc(l: *const Legalize, src_ty: Type, dst_ty: Type) Air.CompilerR 80 => 3, else => unreachable, }; - return @enumFromInt(@intFromEnum(to_f16_func) + offset); + return @fromBackingInt(@intCast(@backingInt(to_f16_func) + offset)); } fn softFpextFunc(l: *const Legalize, src_ty: Type, dst_ty: Type) Air.CompilerRtFunc { const target = l.pt.zcu.getTarget(); @@ -3457,7 +3457,7 @@ fn softFpextFunc(l: *const Legalize, src_ty: Type, dst_ty: Type) Air.CompilerRtF 32 => 3, else => unreachable, }; - return @enumFromInt(@intFromEnum(to_f128_func) + offset); + return @fromBackingInt(@intCast(@backingInt(to_f128_func) + offset)); } fn softFloatFromInt(l: *Legalize, orig_inst: Air.Inst.Index) Error!union(enum) { call: Air.CompilerRtFunc, @@ -3467,7 +3467,7 @@ fn softFloatFromInt(l: *Legalize, orig_inst: Air.Inst.Index) Error!union(enum) { const zcu = pt.zcu; const target = zcu.getTarget(); - const ty_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_op; const dest_ty = ty_op.ty.toType(); const src_ty = l.typeOf(ty_op.operand); @@ -3497,7 +3497,7 @@ fn softFloatFromInt(l: *Legalize, orig_inst: Air.Inst.Index) Error!union(enum) { break :fixed; } - const func: Air.CompilerRtFunc = @enumFromInt(@intFromEnum(base) + int_bits_off + float_off); + const func: Air.CompilerRtFunc = @fromBackingInt(@intCast(@backingInt(base) + int_bits_off + float_off)); if (extended_int_bits == src_info.bits) return .{ .call = func }; // We need to emit a block which first sign/zero-extends to the right type and *then* calls @@ -3522,7 +3522,7 @@ fn softFloatFromInt(l: *Legalize, orig_inst: Air.Inst.Index) Error!union(enum) { // We need to emit a block which puts the integer into an `alloc` (possibly sign/zero-extended) // and calls an arbitrary-width conversion routine. - const func: Air.CompilerRtFunc = @enumFromInt(@intFromEnum(base) + 15 + float_off); + const func: Air.CompilerRtFunc = @fromBackingInt(@intCast(@backingInt(base) + 15 + float_off)); // The extended integer routines expect the integer representation where the integer is // effectively zero- or sign-extended to its ABI size. We represent that by intcasting to @@ -3560,7 +3560,7 @@ fn softIntFromFloat(l: *Legalize, orig_inst: Air.Inst.Index) Error!union(enum) { const zcu = pt.zcu; const target = zcu.getTarget(); - const ty_op = l.air_instructions.items(.data)[@intFromEnum(orig_inst)].ty_op; + const ty_op = l.air_instructions.items(.data)[@backingInt(orig_inst)].ty_op; const src_ty = l.typeOf(ty_op.operand); const dest_ty = ty_op.ty.toType(); @@ -3590,7 +3590,7 @@ fn softIntFromFloat(l: *Legalize, orig_inst: Air.Inst.Index) Error!union(enum) { break :fixed; } - const func: Air.CompilerRtFunc = @enumFromInt(@intFromEnum(base) + int_bits_off + float_off); + const func: Air.CompilerRtFunc = @fromBackingInt(@intCast(@backingInt(base) + int_bits_off + float_off)); if (extended_int_bits == dest_info.bits) return .{ .call = func }; // We need to emit a block which calls the routine and then casts to the required type. @@ -3611,7 +3611,7 @@ fn softIntFromFloat(l: *Legalize, orig_inst: Air.Inst.Index) Error!union(enum) { // We need to emit a block which calls an arbitrary-width conversion routine, then loads the // integer from an `alloc` and possibly truncates it. - const func: Air.CompilerRtFunc = @enumFromInt(@intFromEnum(base) + 15 + float_off); + const func: Air.CompilerRtFunc = @fromBackingInt(@intCast(@backingInt(base) + 15 + float_off)); const extended_ty = try pt.intType(dest_info.signedness, @intCast(dest_ty.abiSize(zcu) * 8)); assert(extended_ty.abiSize(zcu) == dest_ty.abiSize(zcu)); @@ -3678,7 +3678,7 @@ fn softFloatFunc(op: Air.Inst.Tag, float_ty: Type, zcu: *const Zcu) Air.Compiler 128 => 4, else => unreachable, }; - return @enumFromInt(@intFromEnum(f16_func) + offset); + return @fromBackingInt(@intCast(@backingInt(f16_func) + offset)); } fn softFloatNegBlockPayload( diff --git a/src/Air/Liveness.zig b/src/Air/Liveness.zig index fcdf0017cee39cbfe6836f3e6fe33d550ee77726..520f71f313fc6e4b1a4c64860b4ce7f040391c26 100644 --- a/src/Air/Liveness.zig +++ b/src/Air/Liveness.zig @@ -188,23 +188,23 @@ pub fn analyze(zcu: *Zcu, air: Air, intern_pool: *InternPool) Allocator.Error!Li } pub fn getTombBits(l: Liveness, inst: Air.Inst.Index) Bpi { - const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize); + const usize_index = (@backingInt(inst) * bpi) / @bitSizeOf(usize); return @as(Bpi, @truncate(l.tomb_bits[usize_index] >> - @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi)))); + @as(Log2Int(usize), @intCast((@backingInt(inst) % (@bitSizeOf(usize) / bpi)) * bpi)))); } pub fn isUnused(l: Liveness, inst: Air.Inst.Index) bool { - const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize); + const usize_index = (@backingInt(inst) * bpi) / @bitSizeOf(usize); const mask = @as(usize, 1) << - @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi + (bpi - 1))); + @as(Log2Int(usize), @intCast((@backingInt(inst) % (@bitSizeOf(usize) / bpi)) * bpi + (bpi - 1))); return (l.tomb_bits[usize_index] & mask) != 0; } pub fn operandDies(l: Liveness, inst: Air.Inst.Index, operand: OperandInt) bool { assert(operand < bpi - 1); - const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize); + const usize_index = (@backingInt(inst) * bpi) / @bitSizeOf(usize); const mask = @as(usize, 1) << - @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi + operand)); + @as(Log2Int(usize), @intCast((@backingInt(inst) % (@bitSizeOf(usize) / bpi)) * bpi + operand)); return (l.tomb_bits[usize_index] & mask) != 0; } @@ -393,7 +393,7 @@ fn analyzeInst( const inst_tags = a.air.instructions.items(.tag); const inst_datas = a.air.instructions.items(.data); - switch (inst_tags[@intFromEnum(inst)]) { + switch (inst_tags[@backingInt(inst)]) { .add, .add_safe, .add_optimized, @@ -461,7 +461,7 @@ fn analyzeInst( .memmove, .legalize_vec_elem_val, => { - const o = inst_datas[@intFromEnum(inst)].bin_op; + const o = inst_datas[@backingInt(inst)].bin_op; return analyzeOperands(a, pass, data, inst, .{ o.lhs, o.rhs, .none }); }, @@ -543,7 +543,7 @@ fn analyzeInst( .c_va_copy, .abs, => { - const o = inst_datas[@intFromEnum(inst)].ty_op; + const o = inst_datas[@backingInt(inst)].ty_op; return analyzeOperands(a, pass, data, inst, .{ o.operand, .none, .none }); }, @@ -577,7 +577,7 @@ fn analyzeInst( .set_err_return_trace, .c_va_end, => { - const operand = inst_datas[@intFromEnum(inst)].un_op; + const operand = inst_datas[@backingInt(inst)].un_op; return analyzeOperands(a, pass, data, inst, .{ operand, .none, .none }); }, @@ -585,7 +585,7 @@ fn analyzeInst( .ret_safe, .ret_load, => { - const operand = inst_datas[@intFromEnum(inst)].un_op; + const operand = inst_datas[@backingInt(inst)].un_op; return analyzeFuncEnd(a, pass, data, inst, .{ operand, .none, .none }); }, @@ -599,7 +599,7 @@ fn analyzeInst( .slice_elem_ptr, .slice, => { - const ty_pl = inst_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = inst_datas[@backingInt(inst)].ty_pl; const extra = a.air.extraData(Air.Bin, ty_pl.payload).data; return analyzeOperands(a, pass, data, inst, .{ extra.lhs, extra.rhs, .none }); }, @@ -608,12 +608,12 @@ fn analyzeInst( .dbg_var_val, .dbg_arg_inline, => { - const operand = inst_datas[@intFromEnum(inst)].pl_op.operand; + const operand = inst_datas[@backingInt(inst)].pl_op.operand; return analyzeOperands(a, pass, data, inst, .{ operand, .none, .none }); }, .prefetch => { - const prefetch = inst_datas[@intFromEnum(inst)].prefetch; + const prefetch = inst_datas[@backingInt(inst)].prefetch; return analyzeOperands(a, pass, data, inst, .{ prefetch.ptr, .none, .none }); }, @@ -638,7 +638,7 @@ fn analyzeInst( return big.finish(); }, .select => { - const pl_op = inst_datas[@intFromEnum(inst)].pl_op; + const pl_op = inst_datas[@backingInt(inst)].pl_op; const extra = a.air.extraData(Air.Bin, pl_op.payload).data; return analyzeOperands(a, pass, data, inst, .{ pl_op.operand, extra.lhs, extra.rhs }); }, @@ -651,15 +651,15 @@ fn analyzeInst( return analyzeOperands(a, pass, data, inst, .{ unwrapped.operand_a, unwrapped.operand_b, .none }); }, .reduce, .reduce_optimized => { - const reduce = inst_datas[@intFromEnum(inst)].reduce; + const reduce = inst_datas[@backingInt(inst)].reduce; return analyzeOperands(a, pass, data, inst, .{ reduce.operand, .none, .none }); }, .cmp_vector, .cmp_vector_optimized => { - const extra = a.air.extraData(Air.VectorCmp, inst_datas[@intFromEnum(inst)].ty_pl.payload).data; + const extra = a.air.extraData(Air.VectorCmp, inst_datas[@backingInt(inst)].ty_pl.payload).data; return analyzeOperands(a, pass, data, inst, .{ extra.lhs, extra.rhs, .none }); }, .aggregate_init => { - const ty_pl = inst_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = inst_datas[@backingInt(inst)].ty_pl; const aggregate_ty = ty_pl.ty.toType(); const len = @as(usize, @intCast(aggregate_ty.arrayLenIp(ip))); const elements = @as([]const Air.Inst.Ref, @ptrCast(a.air.extra.items[ty_pl.payload..][0..len])); @@ -680,32 +680,32 @@ fn analyzeInst( return big.finish(); }, .union_init => { - const extra = a.air.extraData(Air.UnionInit, inst_datas[@intFromEnum(inst)].ty_pl.payload).data; + const extra = a.air.extraData(Air.UnionInit, inst_datas[@backingInt(inst)].ty_pl.payload).data; return analyzeOperands(a, pass, data, inst, .{ extra.init, .none, .none }); }, .struct_field_ptr, .agg_field_val, .spirv_runtime_array_len => { - const extra = a.air.extraData(Air.StructField, inst_datas[@intFromEnum(inst)].ty_pl.payload).data; + const extra = a.air.extraData(Air.StructField, inst_datas[@backingInt(inst)].ty_pl.payload).data; return analyzeOperands(a, pass, data, inst, .{ extra.struct_operand, .none, .none }); }, .field_parent_ptr => { - const extra = a.air.extraData(Air.FieldParentPtr, inst_datas[@intFromEnum(inst)].ty_pl.payload).data; + const extra = a.air.extraData(Air.FieldParentPtr, inst_datas[@backingInt(inst)].ty_pl.payload).data; return analyzeOperands(a, pass, data, inst, .{ extra.field_ptr, .none, .none }); }, .cmpxchg_strong, .cmpxchg_weak => { - const extra = a.air.extraData(Air.Cmpxchg, inst_datas[@intFromEnum(inst)].ty_pl.payload).data; + const extra = a.air.extraData(Air.Cmpxchg, inst_datas[@backingInt(inst)].ty_pl.payload).data; return analyzeOperands(a, pass, data, inst, .{ extra.ptr, extra.expected_value, extra.new_value }); }, .mul_add => { - const pl_op = inst_datas[@intFromEnum(inst)].pl_op; + const pl_op = inst_datas[@backingInt(inst)].pl_op; const extra = a.air.extraData(Air.Bin, pl_op.payload).data; return analyzeOperands(a, pass, data, inst, .{ extra.lhs, extra.rhs, pl_op.operand }); }, .atomic_load => { - const ptr = inst_datas[@intFromEnum(inst)].atomic_load.ptr; + const ptr = inst_datas[@backingInt(inst)].atomic_load.ptr; return analyzeOperands(a, pass, data, inst, .{ ptr, .none, .none }); }, .atomic_rmw => { - const pl_op = inst_datas[@intFromEnum(inst)].pl_op; + const pl_op = inst_datas[@backingInt(inst)].pl_op; const extra = a.air.extraData(Air.AtomicRmw, pl_op.payload).data; return analyzeOperands(a, pass, data, inst, .{ pl_op.operand, extra.operand, .none }); }, @@ -769,12 +769,12 @@ fn analyzeInst( .loop_switch_br => return analyzeInstSwitchBr(a, pass, data, inst, true), .wasm_memory_grow => { - const pl_op = inst_datas[@intFromEnum(inst)].pl_op; + const pl_op = inst_datas[@backingInt(inst)].pl_op; return analyzeOperands(a, pass, data, inst, .{ pl_op.operand, .none, .none }); }, .legalize_vec_store_elem => { - const pl_op = inst_datas[@intFromEnum(inst)].pl_op; + const pl_op = inst_datas[@backingInt(inst)].pl_op; const bin = a.air.extraData(Air.Bin, pl_op.payload).data; return analyzeOperands(a, pass, data, inst, .{ pl_op.operand, bin.lhs, bin.rhs }); }, @@ -823,7 +823,7 @@ fn analyzeOperands( }, .main_analysis => { - const usize_index = (@intFromEnum(inst) * bpi) / @bitSizeOf(usize); + const usize_index = (@backingInt(inst) * bpi) / @bitSizeOf(usize); // This logic must synchronize with `will_die_immediately` in `AnalyzeBigOperands.init`. const immediate_death = if (data.live_set.remove(inst)) blk: { @@ -858,7 +858,7 @@ fn analyzeOperands( } a.tomb_bits[usize_index] |= @as(usize, tomb_bits) << - @as(Log2Int(usize), @intCast((@intFromEnum(inst) % (@bitSizeOf(usize) / bpi)) * bpi)); + @as(Log2Int(usize), @intCast((@backingInt(inst) % (@bitSizeOf(usize) / bpi)) * bpi)); }, } } @@ -893,7 +893,7 @@ fn analyzeInstBr( inst: Air.Inst.Index, ) !void { const inst_datas = a.air.instructions.items(.data); - const br = inst_datas[@intFromEnum(inst)].br; + const br = inst_datas[@backingInt(inst)].br; const gpa = a.gpa; switch (pass) { @@ -920,7 +920,7 @@ fn analyzeInstRepeat( inst: Air.Inst.Index, ) !void { const inst_datas = a.air.instructions.items(.data); - const repeat = inst_datas[@intFromEnum(inst)].repeat; + const repeat = inst_datas[@backingInt(inst)].repeat; const gpa = a.gpa; switch (pass) { @@ -949,7 +949,7 @@ fn analyzeInstSwitchDispatch( // This happens to be identical to `analyzeInstBr`, but is separated anyway for clarity. const inst_datas = a.air.instructions.items(.data); - const br = inst_datas[@intFromEnum(inst)].br; + const br = inst_datas[@backingInt(inst)].br; const gpa = a.gpa; switch (pass) { @@ -1023,7 +1023,7 @@ fn analyzeInstBlock( const alive = key.*; if (!block_scope.live_set.contains(alive)) { // Dies in block - a.extra.appendAssumeCapacity(@intFromEnum(alive)); + a.extra.appendAssumeCapacity(@backingInt(alive)); measured_num += 1; } } @@ -1064,7 +1064,7 @@ fn writeLoopInfo( var it = data.breaks.keyIterator(); while (it.next()) |key| { const block_inst = key.*; - a.extra.appendAssumeCapacity(@intFromEnum(block_inst)); + a.extra.appendAssumeCapacity(@backingInt(block_inst)); } log.debug("[{t}] {f}: includes breaks to {f}", .{ LivenessPass.loop_analysis, inst, fmtInstSet(&data.breaks) }); @@ -1076,7 +1076,7 @@ fn writeLoopInfo( it = data.live_set.keyIterator(); while (it.next()) |key| { const alive = key.*; - a.extra.appendAssumeCapacity(@intFromEnum(alive)); + a.extra.appendAssumeCapacity(@backingInt(alive)); } log.debug("[{t}] {f}: maintain liveness of {f}", .{ LivenessPass.loop_analysis, inst, fmtInstSet(&data.live_set) }); @@ -1297,7 +1297,7 @@ fn analyzeInstSwitchBr( is_dispatch_loop: bool, ) !void { const inst_datas = a.air.instructions.items(.data); - const pl_op = inst_datas[@intFromEnum(inst)].pl_op; + const pl_op = inst_datas[@backingInt(inst)].pl_op; const condition = pl_op.operand; const switch_br = a.air.unwrapSwitch(inst); const gpa = a.gpa; diff --git a/src/Air/Liveness/Verify.zig b/src/Air/Liveness/Verify.zig index dd7c189bdab31cd31f09969e8d9a697176be33a0..c136509de9156318907cf45c0473c544cca04bc5 100644 --- a/src/Air/Liveness/Verify.zig +++ b/src/Air/Liveness/Verify.zig @@ -48,7 +48,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { continue; } - switch (tags[@intFromEnum(inst)]) { + switch (tags[@backingInt(inst)]) { // no operands .arg, .alloc, @@ -131,7 +131,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { .c_va_copy, .abs, => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; try self.verifyInstOperands(inst, .{ ty_op.operand, .none, .none }); }, .is_null, @@ -164,14 +164,14 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { .set_err_return_trace, .c_va_end, => { - const un_op = data[@intFromEnum(inst)].un_op; + const un_op = data[@backingInt(inst)].un_op; try self.verifyInstOperands(inst, .{ un_op, .none, .none }); }, .ret, .ret_safe, .ret_load, => { - const un_op = data[@intFromEnum(inst)].un_op; + const un_op = data[@backingInt(inst)].un_op; try self.verifyInstOperands(inst, .{ un_op, .none, .none }); // This instruction terminates the function, so everything should be dead if (self.live.count() > 0) return invalid("{f}: instructions still alive", .{inst}); @@ -181,36 +181,36 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { .dbg_arg_inline, .wasm_memory_grow, => { - const pl_op = data[@intFromEnum(inst)].pl_op; + const pl_op = data[@backingInt(inst)].pl_op; try self.verifyInstOperands(inst, .{ pl_op.operand, .none, .none }); }, .prefetch => { - const prefetch = data[@intFromEnum(inst)].prefetch; + const prefetch = data[@backingInt(inst)].prefetch; try self.verifyInstOperands(inst, .{ prefetch.ptr, .none, .none }); }, .reduce, .reduce_optimized, => { - const reduce = data[@intFromEnum(inst)].reduce; + const reduce = data[@backingInt(inst)].reduce; try self.verifyInstOperands(inst, .{ reduce.operand, .none, .none }); }, .union_init => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data; try self.verifyInstOperands(inst, .{ extra.init, .none, .none }); }, .struct_field_ptr, .agg_field_val, .spirv_runtime_array_len => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.StructField, ty_pl.payload).data; try self.verifyInstOperands(inst, .{ extra.struct_operand, .none, .none }); }, .field_parent_ptr => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; try self.verifyInstOperands(inst, .{ extra.field_ptr, .none, .none }); }, .atomic_load => { - const atomic_load = data[@intFromEnum(inst)].atomic_load; + const atomic_load = data[@backingInt(inst)].atomic_load; try self.verifyInstOperands(inst, .{ atomic_load.ptr, .none, .none }); }, @@ -282,7 +282,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { .memmove, .legalize_vec_elem_val, => { - const bin_op = data[@intFromEnum(inst)].bin_op; + const bin_op = data[@backingInt(inst)].bin_op; try self.verifyInstOperands(inst, .{ bin_op.lhs, bin_op.rhs, .none }); }, .add_with_overflow, @@ -295,7 +295,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { .slice_elem_ptr, .slice, => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Bin, ty_pl.payload).data; try self.verifyInstOperands(inst, .{ extra.lhs, extra.rhs, .none }); }, @@ -310,38 +310,38 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { .cmp_vector, .cmp_vector_optimized, => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.VectorCmp, ty_pl.payload).data; try self.verifyInstOperands(inst, .{ extra.lhs, extra.rhs, .none }); }, .atomic_rmw => { - const pl_op = data[@intFromEnum(inst)].pl_op; + const pl_op = data[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data; try self.verifyInstOperands(inst, .{ pl_op.operand, extra.operand, .none }); }, // ternary .select => { - const pl_op = data[@intFromEnum(inst)].pl_op; + const pl_op = data[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.Bin, pl_op.payload).data; try self.verifyInstOperands(inst, .{ pl_op.operand, extra.lhs, extra.rhs }); }, .mul_add => { - const pl_op = data[@intFromEnum(inst)].pl_op; + const pl_op = data[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.Bin, pl_op.payload).data; try self.verifyInstOperands(inst, .{ extra.lhs, extra.rhs, pl_op.operand }); }, .cmpxchg_strong, .cmpxchg_weak, => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data; try self.verifyInstOperands(inst, .{ extra.ptr, extra.expected_value, extra.new_value }); }, // big tombs .aggregate_init => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const aggregate_ty = ty_pl.ty.toType(); const len = @as(usize, @intCast(aggregate_ty.arrayLenIp(ip))); const elements = @as([]const Air.Inst.Ref, @ptrCast(self.air.extra.items[ty_pl.payload..][0..len])); @@ -422,7 +422,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { try self.verifyInst(inst); }, .br => { - const br = data[@intFromEnum(inst)].br; + const br = data[@backingInt(inst)].br; const gop = try self.blocks.getOrPut(self.gpa, br.block_inst); try self.verifyOperand(inst, br.operand, self.liveness.operandDies(inst, 0)); @@ -434,14 +434,14 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { try self.verifyInst(inst); }, .repeat => { - const repeat = data[@intFromEnum(inst)].repeat; + const repeat = data[@backingInt(inst)].repeat; const expected_live = self.loops.get(repeat.loop_inst) orelse return invalid("{f}: loop {f} not in scope", .{ inst, repeat.loop_inst }); try self.verifyMatchingLiveness(repeat.loop_inst, expected_live); }, .switch_dispatch => { - const br = data[@intFromEnum(inst)].br; + const br = data[@backingInt(inst)].br; try self.verifyOperand(inst, br.operand, self.liveness.operandDies(inst, 0)); @@ -451,7 +451,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { try self.verifyMatchingLiveness(br.block_inst, expected_live); }, .block, .dbg_inline_block => |tag| { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const block_ty = ty_pl.ty.toType(); const block_body = switch (tag) { .block => self.air.unwrapBlock(inst).body, @@ -570,7 +570,7 @@ fn verifyBody(self: *Verify, body: []const Air.Inst.Index) Error!void { try self.verifyInst(inst); }, .legalize_vec_store_elem => { - const pl_op = data[@intFromEnum(inst)].pl_op; + const pl_op = data[@backingInt(inst)].pl_op; const bin = self.air.extraData(Air.Bin, pl_op.payload).data; try self.verifyInstOperands(inst, .{ pl_op.operand, bin.lhs, bin.rhs }); }, diff --git a/src/Air/Verify.zig b/src/Air/Verify.zig index b3f9f002295e671b24c7e4f0558012e42384d933..438de7d1b43471f36535a6bc1ea3af7359d8b1f3 100644 --- a/src/Air/Verify.zig +++ b/src/Air/Verify.zig @@ -69,7 +69,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { const data = air.instructions.items(.data); for (body_insts, 0..) |inst, body_index| { verify.cur_inst = inst; - switch (tags[@intFromEnum(inst)]) { + switch (tags[@backingInt(inst)]) { .block => { const block = air.unwrapBlock(inst); try verify.body(block.body); @@ -107,11 +107,11 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { } }, .ret, .ret_safe => { - const operand = data[@intFromEnum(inst)].un_op; + const operand = data[@backingInt(inst)].un_op; if (air.typeOf(operand, ip).toIntern() != verify.ret_ty.toIntern()) return verify.fail("bad return type"); }, .ret_load => { - const operand = data[@intFromEnum(inst)].un_op; + const operand = data[@backingInt(inst)].un_op; const ptr_ty = air.typeOf(operand, ip); if (ptr_ty.zigTypeTag(zcu) != .pointer) return verify.fail("operand is not a pointer"); if (ptr_ty.ptrSize(zcu) != .one) return verify.fail("pointer size is not '.one'"); @@ -119,7 +119,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { }, .bit_cast, .bit_cast_safe => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); // Enums are allowed here even if their backing type is implicit. @@ -134,7 +134,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { if (operand_ty.bitSize(zcu) != result_ty.bitSize(zcu)) return verify.fail("bit size mismatch"); }, .ptr_cast => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); const operand_scalar_ty = operand_ty.scalarType(zcu); @@ -152,7 +152,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { } }, .ptr_from_int => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); const operand_scalar_ty = operand_ty.scalarType(zcu); @@ -163,7 +163,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { if (!operand_ty.isVector(zcu) and result_ty.isVector(zcu)) return verify.fail("result is vector, but operand is not"); }, .int_from_ptr => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); const operand_scalar_ty = operand_ty.scalarType(zcu); @@ -174,7 +174,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { if (!operand_ty.isVector(zcu) and result_ty.isVector(zcu)) return verify.fail("result is vector, but operand is not"); }, .error_cast => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); switch (operand_ty.zigTypeTag(zcu)) { @@ -193,7 +193,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { } }, .error_from_int => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); if (!operand_ty.isUnsignedInt(zcu)) return verify.fail("bad operand type"); @@ -201,7 +201,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { if (result_ty.zigTypeTag(zcu) != .error_set) return verify.fail("bad result type"); }, .int_from_error => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); if (operand_ty.zigTypeTag(zcu) != .error_set) return verify.fail("bad operand type"); @@ -209,7 +209,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { if (result_ty.bitSize(zcu) != zcu.errorSetBits()) return verify.fail("bad result bit size"); }, .union_from_enum => { - const ty_op = data[@intFromEnum(inst)].ty_op; + const ty_op = data[@backingInt(inst)].ty_op; const operand_ty = air.typeOf(ty_op.operand, ip); const result_ty = ty_op.ty.toType(); if (operand_ty.zigTypeTag(zcu) != .@"enum") return verify.fail("bad operand type"); @@ -219,7 +219,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { }, .ptr_elem_ptr => { - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const bin_op = air.extraData(Air.Bin, ty_pl.payload).data; const ptr_ty = air.typeOf(bin_op.lhs, ip); const result_ty = ty_pl.ty.toType(); @@ -442,7 +442,7 @@ fn body(verify: *Verify, body_insts: []const Air.Inst.Index) Error!void { // probably just needs to live exclusively in backends; putting AIR instructions after a // call implies that we have e.g. a valid stack at that point, which we can't actually // assume when the user has gotten a function's ABI wrong. - switch (tags[@intFromEnum(inst)]) { + switch (tags[@backingInt(inst)]) { .call, .call_always_tail, .call_never_tail, diff --git a/src/Air/print.zig b/src/Air/print.zig index eccc5619967b588ccc87f54cb35f7fe4e87f78e7..1712607a673187a351788aeda3907f7e614a2044 100644 --- a/src/Air/print.zig +++ b/src/Air/print.zig @@ -106,7 +106,7 @@ const Writer = struct { } fn writeInst(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const tag = w.air.instructions.items(.tag)[@intFromEnum(inst)]; + const tag = w.air.instructions.items(.tag)[@backingInt(inst)]; try s.splatByteAll(' ', w.indent); try s.print("{f}{c}= {s}(", .{ inst, @@ -357,14 +357,14 @@ const Writer = struct { } fn writeBinOp(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = w.air.instructions.items(.data)[@backingInt(inst)].bin_op; try w.writeOperand(s, inst, 0, bin_op.lhs); try s.writeAll(", "); try w.writeOperand(s, inst, 1, bin_op.rhs); } fn writeUnOp(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const un_op = w.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = w.air.instructions.items(.data)[@backingInt(inst)].un_op; try w.writeOperand(s, inst, 0, un_op); } @@ -380,25 +380,25 @@ const Writer = struct { } fn writeTy(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const ty = w.air.instructions.items(.data)[@intFromEnum(inst)].ty; + const ty = w.air.instructions.items(.data)[@backingInt(inst)].ty; try w.writeType(s, ty); } fn writeArg(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const arg = w.air.instructions.items(.data)[@intFromEnum(inst)].arg; + const arg = w.air.instructions.items(.data)[@backingInt(inst)].arg; try w.writeType(s, arg.ty.toType()); try s.print(", {d}", .{arg.zir_param_index}); } fn writeTyOp(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const ty_op = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = w.air.instructions.items(.data)[@backingInt(inst)].ty_op; try w.writeType(s, ty_op.ty.toType()); try s.writeAll(", "); try w.writeOperand(s, inst, 0, ty_op.operand); } fn writeBlock(w: *Writer, s: *std.Io.Writer, tag: Air.Inst.Tag, inst: Air.Inst.Index) Error!void { - const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = w.air.instructions.items(.data)[@backingInt(inst)].ty_pl; try w.writeType(s, ty_pl.ty.toType()); const body = switch (tag) { @@ -446,7 +446,7 @@ const Writer = struct { fn writeAggregateInit(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { const zcu = w.pt.zcu; - const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = w.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const vector_ty = ty_pl.ty.toType(); const len = @as(usize, @intCast(vector_ty.arrayLen(zcu))); const elements = @as([]const Air.Inst.Ref, @ptrCast(w.air.extra.items[ty_pl.payload..][0..len])); @@ -461,7 +461,7 @@ const Writer = struct { } fn writeUnionInit(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = w.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = w.air.extraData(Air.UnionInit, ty_pl.payload).data; try s.print("{d}, ", .{extra.field_index}); @@ -469,7 +469,7 @@ const Writer = struct { } fn writeStructField(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = w.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = w.air.extraData(Air.StructField, ty_pl.payload).data; try w.writeOperand(s, inst, 0, extra.struct_operand); @@ -478,10 +478,10 @@ const Writer = struct { fn writeTyPlBin(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { const data = w.air.instructions.items(.data); - const ty_pl = data[@intFromEnum(inst)].ty_pl; + const ty_pl = data[@backingInt(inst)].ty_pl; const extra = w.air.extraData(Air.Bin, ty_pl.payload).data; - const inst_ty = data[@intFromEnum(inst)].ty_pl.ty.toType(); + const inst_ty = data[@backingInt(inst)].ty_pl.ty.toType(); try w.writeType(s, inst_ty); try s.writeAll(", "); try w.writeOperand(s, inst, 0, extra.lhs); @@ -490,7 +490,7 @@ const Writer = struct { } fn writeCmpxchg(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = w.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = w.air.extraData(Air.Cmpxchg, ty_pl.payload).data; try w.writeOperand(s, inst, 0, extra.ptr); @@ -504,7 +504,7 @@ const Writer = struct { } fn writeMulAdd(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = w.air.extraData(Air.Bin, pl_op.payload).data; try w.writeOperand(s, inst, 0, extra.lhs); @@ -515,7 +515,7 @@ const Writer = struct { } fn writeLegalizeVecStoreElem(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; const bin = w.air.extraData(Air.Bin, pl_op.payload).data; try w.writeOperand(s, inst, 0, pl_op.operand); @@ -574,7 +574,7 @@ const Writer = struct { fn writeSelect(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { const zcu = w.pt.zcu; - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = w.air.extraData(Air.Bin, pl_op.payload).data; const elem_ty = w.typeOfIndex(inst).childType(zcu); @@ -588,14 +588,14 @@ const Writer = struct { } fn writeReduce(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const reduce = w.air.instructions.items(.data)[@intFromEnum(inst)].reduce; + const reduce = w.air.instructions.items(.data)[@backingInt(inst)].reduce; try w.writeOperand(s, inst, 0, reduce.operand); try s.print(", {s}", .{@tagName(reduce.operation)}); } fn writeCmpVector(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = w.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = w.air.extraData(Air.VectorCmp, ty_pl.payload).data; try s.print("{s}, ", .{@tagName(extra.compareOperator())}); @@ -606,20 +606,20 @@ const Writer = struct { fn writeRuntimeNavPtr(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { const ip = &w.pt.zcu.intern_pool; - const ty_nav = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav; + const ty_nav = w.air.instructions.items(.data)[@backingInt(inst)].ty_nav; try w.writeType(s, .fromInterned(ty_nav.ty)); try s.print(", '{f}'", .{ip.getNav(ty_nav.nav).fqn.fmt(ip)}); } fn writeAtomicLoad(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const atomic_load = w.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; + const atomic_load = w.air.instructions.items(.data)[@backingInt(inst)].atomic_load; try w.writeOperand(s, inst, 0, atomic_load.ptr); try s.print(", {s}", .{@tagName(atomic_load.order)}); } fn writePrefetch(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const prefetch = w.air.instructions.items(.data)[@intFromEnum(inst)].prefetch; + const prefetch = w.air.instructions.items(.data)[@backingInt(inst)].prefetch; try w.writeOperand(s, inst, 0, prefetch.ptr); try s.print(", {s}, {d}, {s}", .{ @@ -633,7 +633,7 @@ const Writer = struct { inst: Air.Inst.Index, order: std.lang.AtomicOrder, ) Error!void { - const bin_op = w.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = w.air.instructions.items(.data)[@backingInt(inst)].bin_op; try w.writeOperand(s, inst, 0, bin_op.lhs); try s.writeAll(", "); try w.writeOperand(s, inst, 1, bin_op.rhs); @@ -641,7 +641,7 @@ const Writer = struct { } fn writeAtomicRmw(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = w.air.extraData(Air.AtomicRmw, pl_op.payload).data; try w.writeOperand(s, inst, 0, pl_op.operand); @@ -651,7 +651,7 @@ const Writer = struct { } fn writeFieldParentPtr(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const ty_pl = w.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = w.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = w.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; try w.writeOperand(s, inst, 0, extra.field_ptr); @@ -719,14 +719,14 @@ const Writer = struct { } fn writeDbgStmt(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const dbg_stmt = w.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = w.air.instructions.items(.data)[@backingInt(inst)].dbg_stmt; try s.print("{d}:{d}", .{ dbg_stmt.line + 1, dbg_stmt.column + 1 }); } fn writeDbgVar(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; try w.writeOperand(s, inst, 0, pl_op.operand); - const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); try s.print(", \"{f}\"", .{std.zig.fmtString(name.toSlice(w.air))}); } @@ -743,14 +743,14 @@ const Writer = struct { } fn writeBr(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const br = w.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = w.air.instructions.items(.data)[@backingInt(inst)].br; try w.writeInstIndex(s, br.block_inst, false); try s.writeAll(", "); try w.writeOperand(s, inst, 0, br.operand); } fn writeRepeat(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const repeat = w.air.instructions.items(.data)[@intFromEnum(inst)].repeat; + const repeat = w.air.instructions.items(.data)[@backingInt(inst)].repeat; try w.writeInstIndex(s, repeat.loop_inst, false); } @@ -968,18 +968,18 @@ const Writer = struct { } fn writeWasmMemorySize(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; try s.print("{d}", .{pl_op.payload}); } fn writeWasmMemoryGrow(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; try s.print("{d}, ", .{pl_op.payload}); try w.writeOperand(s, inst, 0, pl_op.operand); } fn writeWorkDimension(w: *Writer, s: *std.Io.Writer, inst: Air.Inst.Index) Error!void { - const pl_op = w.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = w.air.instructions.items(.data)[@backingInt(inst)].pl_op; try s.print("{d}", .{pl_op.payload}); } @@ -1015,7 +1015,7 @@ const Writer = struct { operand: Air.Inst.Ref, dies: bool, ) Error!void { - if (@intFromEnum(operand) < InternPool.static_len) { + if (@backingInt(operand) < InternPool.static_len) { return s.print("@{}", .{operand}); } else if (operand.toInterned()) |ip_index| { const pt = w.pt; diff --git a/src/Compilation.zig b/src/Compilation.zig index 3e3658021438b7aa518282c77c3d04bba3d269b9..293b553d233ce437470ab229ad14c721e33ef56b 100644 --- a/src/Compilation.zig +++ b/src/Compilation.zig @@ -418,7 +418,7 @@ pub const Path = struct { /// The added data is relocatable across any compiler process using the same lib and cache /// directories; it does not depend on cwd. pub fn addToHasher(p: Path, h: *Cache.Hasher) void { - h.update(&.{@intFromEnum(p.root)}); + h.update(&.{@backingInt(p.root)}); h.update(p.sub_path); } @@ -843,7 +843,7 @@ pub const CObject = struct { pub fn addToErrorBundle(diag: *const Diag, io: Io, eb: *ErrorBundle.Wip, bundle: Bundle, note: *u32) !void { const err_msg = try eb.addErrorMessage(try diag.toErrorMessage(io, eb, bundle, 0)); - eb.extra.items[note.*] = @intFromEnum(err_msg); + eb.extra.items[note.*] = @backingInt(err_msg); note.* += 1; for (diag.sub_diags) |sub_diag| try sub_diag.addToErrorBundle(io, eb, bundle, note); } @@ -976,12 +976,12 @@ pub const CObject = struct { try bc.checkMagic("DIAG"); while (try bc.next()) |item| switch (item) { - .start_block => |block| switch (@as(BlockId, @enumFromInt(block.id))) { + .start_block => |block| switch (@as(BlockId, @fromBackingInt(@intCast(block.id)))) { .Meta => if (stack.items.len > 0) try bc.skipBlock(block), .Diag => try stack.append(gpa, .{}), _ => try bc.skipBlock(block), }, - .record => |record| switch (@as(RecordId, @enumFromInt(record.id))) { + .record => |record| switch (@as(RecordId, @fromBackingInt(@intCast(record.id)))) { .Version => if (record.operands[0] != 2) return error.InvalidVersion, .DiagInfo => { const top = &stack.items[stack.items.len - 1]; @@ -1027,7 +1027,7 @@ pub const CObject = struct { .FixIt => {}, _ => {}, }, - .end_block => |block| switch (@as(BlockId, @enumFromInt(block.id))) { + .end_block => |block| switch (@as(BlockId, @fromBackingInt(@intCast(block.id)))) { .Meta => {}, .Diag => { try stack.items[stack.items.len - 2].sub_diags.ensureUnusedCapacity(gpa, 1); @@ -2401,26 +2401,26 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, if (!std.zig.target.canBuildLibC(target)) return diag.fail(.cross_libc_unavailable); if (musl.needsCrt0(comp.config.output_mode, comp.config.link_mode, comp.config.pie)) |f| { - comp.queued_jobs.musl_crt_file[@intFromEnum(f)] = true; + comp.queued_jobs.musl_crt_file[@backingInt(f)] = true; } switch (comp.config.link_mode) { - .static => comp.queued_jobs.musl_crt_file[@intFromEnum(musl.CrtFile.libc_a)] = true, - .dynamic => comp.queued_jobs.musl_crt_file[@intFromEnum(musl.CrtFile.libc_so)] = true, + .static => comp.queued_jobs.musl_crt_file[@backingInt(musl.CrtFile.libc_a)] = true, + .dynamic => comp.queued_jobs.musl_crt_file[@backingInt(musl.CrtFile.libc_so)] = true, } } else if (target.isGnuLibC()) { if (!std.zig.target.canBuildLibC(target)) return diag.fail(.cross_libc_unavailable); if (glibc.needsCrt0(comp.config.output_mode)) |f| { - comp.queued_jobs.glibc_crt_file[@intFromEnum(f)] = true; + comp.queued_jobs.glibc_crt_file[@backingInt(f)] = true; } comp.queued_jobs.glibc_shared_objects = true; - comp.queued_jobs.glibc_crt_file[@intFromEnum(glibc.CrtFile.libc_nonshared_a)] = true; + comp.queued_jobs.glibc_crt_file[@backingInt(glibc.CrtFile.libc_nonshared_a)] = true; } else if (target.isFreeBSDLibC()) { if (!std.zig.target.canBuildLibC(target)) return diag.fail(.cross_libc_unavailable); if (freebsd.needsCrt0(comp.config.output_mode)) |f| { - comp.queued_jobs.freebsd_crt_file[@intFromEnum(f)] = true; + comp.queued_jobs.freebsd_crt_file[@backingInt(f)] = true; } comp.queued_jobs.freebsd_shared_objects = true; @@ -2428,7 +2428,7 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, if (!std.zig.target.canBuildLibC(target)) return diag.fail(.cross_libc_unavailable); if (netbsd.needsCrt0(comp.config.output_mode)) |f| { - comp.queued_jobs.netbsd_crt_file[@intFromEnum(f)] = true; + comp.queued_jobs.netbsd_crt_file[@backingInt(f)] = true; } comp.queued_jobs.netbsd_shared_objects = true; @@ -2436,21 +2436,21 @@ pub fn create(gpa: Allocator, arena: Allocator, io: Io, diag: *CreateDiagnostic, if (!std.zig.target.canBuildLibC(target)) return diag.fail(.cross_libc_unavailable); if (openbsd.needsCrt0(comp.config.output_mode)) |f| { - comp.queued_jobs.openbsd_crt_file[@intFromEnum(f)] = true; + comp.queued_jobs.openbsd_crt_file[@backingInt(f)] = true; } comp.queued_jobs.openbsd_shared_objects = true; } else if (target.isWasiLibC()) { if (!std.zig.target.canBuildLibC(target)) return diag.fail(.cross_libc_unavailable); - comp.queued_jobs.wasi_libc_crt_file[@intFromEnum(wasi_libc.execModelCrtFile(comp.config.wasi_exec_model))] = true; - comp.queued_jobs.wasi_libc_crt_file[@intFromEnum(wasi_libc.CrtFile.libc_a)] = true; + comp.queued_jobs.wasi_libc_crt_file[@backingInt(wasi_libc.execModelCrtFile(comp.config.wasi_exec_model))] = true; + comp.queued_jobs.wasi_libc_crt_file[@backingInt(wasi_libc.CrtFile.libc_a)] = true; } else if (target.isMinGW()) { if (!std.zig.target.canBuildLibC(target)) return diag.fail(.cross_libc_unavailable); const main_crt_file: mingw.CrtFile = if (is_dyn_lib) .dllcrt2_o else .crt2_o; - comp.queued_jobs.mingw_crt_file[@intFromEnum(main_crt_file)] = true; - comp.queued_jobs.mingw_crt_file[@intFromEnum(mingw.CrtFile.libmingw32_lib)] = true; + comp.queued_jobs.mingw_crt_file[@backingInt(main_crt_file)] = true; + comp.queued_jobs.mingw_crt_file[@backingInt(mingw.CrtFile.libmingw32_lib)] = true; // When linking mingw-w64 there are some import libs we always need. try comp.windows_libs.ensureUnusedCapacity(gpa, mingw.always_link_libs.len); @@ -3783,7 +3783,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle { }); const notes_start = try bundle.reserveNotes(notes_len); for (notes_start.., lld_error.context_lines) |note, context_line| { - bundle.extra.items[note] = @intFromEnum(bundle.addErrorMessageAssumeCapacity(.{ + bundle.extra.items[note] = @backingInt(bundle.addErrorMessageAssumeCapacity(.{ .msg = try bundle.addString(context_line), })); } @@ -3845,7 +3845,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle { pub fn lessThan(ctx: @This(), lhs_index: usize, rhs_index: usize) bool { const lhs_path = ctx.zcu.fileByIndex(ctx.failed_files_keys[lhs_index]).path; const rhs_path = ctx.zcu.fileByIndex(ctx.failed_files_keys[rhs_index]).path; - if (lhs_path.root != rhs_path.root) return @intFromEnum(lhs_path.root) < @intFromEnum(rhs_path.root); + if (lhs_path.root != rhs_path.root) return @backingInt(lhs_path.root) < @backingInt(rhs_path.root); return std.mem.order(u8, lhs_path.sub_path, rhs_path.sub_path).compare(.lt); } }; @@ -3946,7 +3946,7 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle { .notes_len = 1, }); const notes_start = try bundle.reserveNotes(1); - bundle.extra.items[notes_start] = @intFromEnum(bundle.addErrorMessageAssumeCapacity(.{ + bundle.extra.items[notes_start] = @backingInt(bundle.addErrorMessageAssumeCapacity(.{ .msg = try bundle.printString("use '--error-limit {d}' to increase limit", .{ actual_error_count, }), @@ -3968,10 +3968,10 @@ pub fn getAllErrorsAlloc(comp: *Compilation) error{OutOfMemory}!ErrorBundle { .notes_len = 2, }); const notes_start = try bundle.reserveNotes(2); - bundle.extra.items[notes_start + 0] = @intFromEnum(bundle.addErrorMessageAssumeCapacity(.{ + bundle.extra.items[notes_start + 0] = @backingInt(bundle.addErrorMessageAssumeCapacity(.{ .msg = try bundle.addString("run 'zig libc -h' to learn about libc installations"), })); - bundle.extra.items[notes_start + 1] = @intFromEnum(bundle.addErrorMessageAssumeCapacity(.{ + bundle.extra.items[notes_start + 1] = @backingInt(bundle.addErrorMessageAssumeCapacity(.{ .msg = try bundle.addString("run 'zig targets' to see the targets for which zig can always provide libc"), })); } @@ -4227,7 +4227,7 @@ pub fn addModuleErrorMsg( const notes_start = try eb.reserveNotes(notes_len); for (notes_start.., notes.keys()) |i, note| { - eb.extra.items[i] = @intFromEnum(eb.addErrorMessageAssumeCapacity(note)); + eb.extra.items[i] = @backingInt(eb.addErrorMessageAssumeCapacity(note)); } } @@ -4260,7 +4260,7 @@ fn addWholeFileError( }); if (imported_note) |n| { const note_idx = try eb.reserveNotes(1); - eb.extra.items[note_idx] = @intFromEnum(n); + eb.extra.items[note_idx] = @backingInt(n); } } @@ -4483,49 +4483,49 @@ fn dispatchPrelinkWork(comp: *Compilation, main_progress_node: std.Progress.Node for (0..@typeInfo(musl.CrtFile).@"enum".field_names.len) |i| { if (comp.queued_jobs.musl_crt_file[i]) { - const tag: musl.CrtFile = @enumFromInt(i); + const tag: musl.CrtFile = @fromBackingInt(@intCast(i)); prelink_group.async(io, buildMuslCrtFile, .{ comp, tag, main_progress_node }); } } for (0..@typeInfo(glibc.CrtFile).@"enum".field_names.len) |i| { if (comp.queued_jobs.glibc_crt_file[i]) { - const tag: glibc.CrtFile = @enumFromInt(i); + const tag: glibc.CrtFile = @fromBackingInt(@intCast(i)); prelink_group.async(io, buildGlibcCrtFile, .{ comp, tag, main_progress_node }); } } for (0..@typeInfo(freebsd.CrtFile).@"enum".field_names.len) |i| { if (comp.queued_jobs.freebsd_crt_file[i]) { - const tag: freebsd.CrtFile = @enumFromInt(i); + const tag: freebsd.CrtFile = @fromBackingInt(@intCast(i)); prelink_group.async(io, buildFreeBSDCrtFile, .{ comp, tag, main_progress_node }); } } for (0..@typeInfo(netbsd.CrtFile).@"enum".field_names.len) |i| { if (comp.queued_jobs.netbsd_crt_file[i]) { - const tag: netbsd.CrtFile = @enumFromInt(i); + const tag: netbsd.CrtFile = @fromBackingInt(@intCast(i)); prelink_group.async(io, buildNetBSDCrtFile, .{ comp, tag, main_progress_node }); } } for (0..@typeInfo(openbsd.CrtFile).@"enum".field_names.len) |i| { if (comp.queued_jobs.openbsd_crt_file[i]) { - const tag: openbsd.CrtFile = @enumFromInt(i); + const tag: openbsd.CrtFile = @fromBackingInt(@intCast(i)); prelink_group.async(io, buildOpenBSDCrtFile, .{ comp, tag, main_progress_node }); } } for (0..@typeInfo(wasi_libc.CrtFile).@"enum".field_names.len) |i| { if (comp.queued_jobs.wasi_libc_crt_file[i]) { - const tag: wasi_libc.CrtFile = @enumFromInt(i); + const tag: wasi_libc.CrtFile = @fromBackingInt(@intCast(i)); prelink_group.async(io, buildWasiLibcCrtFile, .{ comp, tag, main_progress_node }); } } for (0..@typeInfo(mingw.CrtFile).@"enum".field_names.len) |i| { if (comp.queued_jobs.mingw_crt_file[i]) { - const tag: mingw.CrtFile = @enumFromInt(i); + const tag: mingw.CrtFile = @fromBackingInt(@intCast(i)); prelink_group.async(io, buildMingwCrtFile, .{ comp, tag, main_progress_node }); } } @@ -5127,7 +5127,7 @@ fn buildRt( fn buildMuslCrtFile(comp: *Compilation, crt_file: musl.CrtFile, prog_node: std.Progress.Node) void { if (musl.buildCrtFile(comp, crt_file, prog_node)) |_| { - comp.queued_jobs.musl_crt_file[@intFromEnum(crt_file)] = false; + comp.queued_jobs.musl_crt_file[@backingInt(crt_file)] = false; } else |err| switch (err) { error.AlreadyReported => return, else => comp.lockAndSetMiscFailure(.musl_crt_file, "unable to build musl {s}: {s}", .{ @@ -5138,7 +5138,7 @@ fn buildMuslCrtFile(comp: *Compilation, crt_file: musl.CrtFile, prog_node: std.P fn buildGlibcCrtFile(comp: *Compilation, crt_file: glibc.CrtFile, prog_node: std.Progress.Node) void { if (glibc.buildCrtFile(comp, crt_file, prog_node)) |_| { - comp.queued_jobs.glibc_crt_file[@intFromEnum(crt_file)] = false; + comp.queued_jobs.glibc_crt_file[@backingInt(crt_file)] = false; } else |err| switch (err) { error.AlreadyReported => return, else => comp.lockAndSetMiscFailure(.glibc_crt_file, "unable to build glibc {s}: {s}", .{ @@ -5159,7 +5159,7 @@ fn buildGlibcSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) voi fn buildFreeBSDCrtFile(comp: *Compilation, crt_file: freebsd.CrtFile, prog_node: std.Progress.Node) void { if (freebsd.buildCrtFile(comp, crt_file, prog_node)) |_| { - comp.queued_jobs.freebsd_crt_file[@intFromEnum(crt_file)] = false; + comp.queued_jobs.freebsd_crt_file[@backingInt(crt_file)] = false; } else |err| switch (err) { error.AlreadyReported => return, else => comp.lockAndSetMiscFailure(.freebsd_crt_file, "unable to build FreeBSD {s}: {s}", .{ @@ -5182,7 +5182,7 @@ fn buildFreeBSDSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) v fn buildNetBSDCrtFile(comp: *Compilation, crt_file: netbsd.CrtFile, prog_node: std.Progress.Node) void { if (netbsd.buildCrtFile(comp, crt_file, prog_node)) |_| { - comp.queued_jobs.netbsd_crt_file[@intFromEnum(crt_file)] = false; + comp.queued_jobs.netbsd_crt_file[@backingInt(crt_file)] = false; } else |err| switch (err) { error.AlreadyReported => return, else => comp.lockAndSetMiscFailure(.netbsd_crt_file, "unable to build NetBSD {s}: {s}", .{ @@ -5205,7 +5205,7 @@ fn buildNetBSDSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) vo fn buildOpenBSDCrtFile(comp: *Compilation, crt_file: openbsd.CrtFile, prog_node: std.Progress.Node) void { if (openbsd.buildCrtFile(comp, crt_file, prog_node)) |_| { - comp.queued_jobs.openbsd_crt_file[@intFromEnum(crt_file)] = false; + comp.queued_jobs.openbsd_crt_file[@backingInt(crt_file)] = false; } else |err| switch (err) { error.AlreadyReported => return, else => comp.lockAndSetMiscFailure(.openbsd_crt_file, "unable to build OpenBSD {s}: {s}", .{ @@ -5228,7 +5228,7 @@ fn buildOpenBSDSharedObjects(comp: *Compilation, prog_node: std.Progress.Node) v fn buildMingwCrtFile(comp: *Compilation, crt_file: mingw.CrtFile, prog_node: std.Progress.Node) void { if (mingw.buildCrtFile(comp, crt_file, prog_node)) |_| { - comp.queued_jobs.mingw_crt_file[@intFromEnum(crt_file)] = false; + comp.queued_jobs.mingw_crt_file[@backingInt(crt_file)] = false; } else |err| switch (err) { error.AlreadyReported => return, else => comp.lockAndSetMiscFailure(.mingw_crt_file, "unable to build mingw-w64 {s}: {s}", .{ @@ -5272,7 +5272,7 @@ fn buildMingwImportLib(comp: *Compilation, lib_name: []const u8, is_prelink: boo fn buildWasiLibcCrtFile(comp: *Compilation, crt_file: wasi_libc.CrtFile, prog_node: std.Progress.Node) void { if (wasi_libc.buildCrtFile(comp, crt_file, prog_node)) |_| { - comp.queued_jobs.wasi_libc_crt_file[@intFromEnum(crt_file)] = false; + comp.queued_jobs.wasi_libc_crt_file[@backingInt(crt_file)] = false; } else |err| switch (err) { error.AlreadyReported => return, else => comp.lockAndSetMiscFailure(.wasi_libc_crt_file, "unable to build WASI libc {s}: {s}", .{ @@ -6213,7 +6213,7 @@ fn addCommonCCArgs( } else if (target.isMinGW()) { try argv.append("-D__MSVCRT_VERSION__=0xE00"); // use ucrt - const minver: u16 = @truncate(@intFromEnum(target.os.versionRange().windows.min) >> 16); + const minver: u16 = @truncate(@backingInt(target.os.versionRange().windows.min) >> 16); try argv.append( try std.fmt.allocPrint(arena, "-D_WIN32_WINNT=0x{x:0>4}", .{minver}), ); diff --git a/src/IncrementalDebugServer.zig b/src/IncrementalDebugServer.zig index a14ba7c2b39e5eb52dc83ee3bee9e83217cf5453..4d34812ae507191ea3799f12209d482008e14b93 100644 --- a/src/IncrementalDebugServer.zig +++ b/src/IncrementalDebugServer.zig @@ -208,7 +208,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const zcu.incremental_debug_state.units.count(), }); } else if (std.mem.eql(u8, cmd_str, "nav_info")) { - const nav_index: InternPool.Nav.Index = @enumFromInt(parseIndex(arg_str) orelse return w.writeAll("malformed nav index")); + const nav_index: InternPool.Nav.Index = @fromBackingInt(@intCast(parseIndex(arg_str) orelse return w.writeAll("malformed nav index"))); const create_gen = zcu.incremental_debug_state.navs.get(nav_index) orelse return w.writeAll("unknown nav index"); const nav = ip.getNav(nav_index); try w.print( @@ -251,7 +251,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const }; if (success) { num_results += 1; - try w.print("* type {d} ('{s}')\n", .{ @intFromEnum(type_ip_index), ty_name }); + try w.print("* type {d} ('{s}')\n", .{ @backingInt(type_ip_index), ty_name }); } } try w.print("Found {d} results\n", .{num_results}); @@ -272,7 +272,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const }; if (success) { num_results += 1; - try w.print("* nav {d} ('{s}')\n", .{ @intFromEnum(nav_index), nav_fqn }); + try w.print("* nav {d} ('{s}')\n", .{ @backingInt(nav_index), nav_fqn }); } } try w.print("Found {d} results\n", .{num_results}); @@ -308,8 +308,8 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const try w.print("[{d}] ", .{i}); switch (dependee) { .src_hash, .namespace, .namespace_name, .source_file, .embed_file => try w.print("{f}", .{zcu.fmtDependee(dependee)}), - .nav_val, .nav_ty => |nav| try w.print("{t} {d}", .{ dependee, @intFromEnum(nav) }), - .type_layout, .struct_defaults, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @intFromEnum(ip_index) }), + .nav_val, .nav_ty => |nav| try w.print("{t} {d}", .{ dependee, @backingInt(nav) }), + .type_layout, .struct_defaults, .func_ies => |ip_index| try w.print("{t} {d}", .{ dependee, @backingInt(ip_index) }), .memoized_state => |stage| try w.print("memoized_state {s}", .{@tagName(stage)}), } try w.writeByte('\n'); @@ -326,7 +326,7 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const opt_cur = if (refs.get(cur).?) |ref| ref.referencer else null; } } else if (std.mem.eql(u8, cmd_str, "type_info")) { - const ip_index: InternPool.Index = @enumFromInt(parseIndex(arg_str) orelse return w.writeAll("malformed ip index")); + const ip_index: InternPool.Index = @fromBackingInt(@intCast(parseIndex(arg_str) orelse return w.writeAll("malformed ip index"))); const create_gen = zcu.incremental_debug_state.types.get(ip_index) orelse return w.writeAll("unknown type"); try w.print( \\name: '{f}' @@ -337,24 +337,24 @@ fn handleCommand(zcu: *Zcu, w: *Io.Writer, cmd_str: []const u8, arg_str: []const create_gen, }); } else if (std.mem.eql(u8, cmd_str, "type_namespace")) { - const ip_index: InternPool.Index = @enumFromInt(parseIndex(arg_str) orelse return w.writeAll("malformed ip index")); + const ip_index: InternPool.Index = @fromBackingInt(@intCast(parseIndex(arg_str) orelse return w.writeAll("malformed ip index"))); if (!zcu.incremental_debug_state.types.contains(ip_index)) return w.writeAll("unknown type"); const ns = zcu.namespacePtr(Type.fromInterned(ip_index).getNamespaceIndex(zcu)); try w.print("{d} pub decls:\n", .{ns.pub_decls.count()}); for (ns.pub_decls.keys()) |nav| { - try w.print("* nav {d}\n", .{@intFromEnum(nav)}); + try w.print("* nav {d}\n", .{@backingInt(nav)}); } try w.print("{d} non-pub decls:\n", .{ns.priv_decls.count()}); for (ns.priv_decls.keys()) |nav| { - try w.print("* nav {d}\n", .{@intFromEnum(nav)}); + try w.print("* nav {d}\n", .{@backingInt(nav)}); } try w.print("{d} comptime decls:\n", .{ns.comptime_decls.items.len}); for (ns.comptime_decls.items) |id| { - try w.print("* comptime {d}\n", .{@intFromEnum(id)}); + try w.print("* comptime {d}\n", .{@backingInt(id)}); } try w.print("{d} tests:\n", .{ns.test_decls.items.len}); for (ns.test_decls.items) |nav| { - try w.print("* nav {d}\n", .{@intFromEnum(nav)}); + try w.print("* nav {d}\n", .{@backingInt(nav)}); } } else { try w.writeAll("command not found; run 'help' for a command list"); @@ -369,17 +369,17 @@ fn parseAnalUnit(str: []const u8) ?AnalUnit { const kind = str[0..split_idx]; const idx_str = str[split_idx + 1 ..]; if (std.mem.eql(u8, kind, "comptime")) { - return .wrap(.{ .@"comptime" = @enumFromInt(parseIndex(idx_str) orelse return null) }); + return .wrap(.{ .@"comptime" = @fromBackingInt(@intCast(parseIndex(idx_str) orelse return null)) }); } else if (std.mem.eql(u8, kind, "nav_val")) { - return .wrap(.{ .nav_val = @enumFromInt(parseIndex(idx_str) orelse return null) }); + return .wrap(.{ .nav_val = @fromBackingInt(@intCast(parseIndex(idx_str) orelse return null)) }); } else if (std.mem.eql(u8, kind, "nav_ty")) { - return .wrap(.{ .nav_ty = @enumFromInt(parseIndex(idx_str) orelse return null) }); + return .wrap(.{ .nav_ty = @fromBackingInt(@intCast(parseIndex(idx_str) orelse return null)) }); } else if (std.mem.eql(u8, kind, "type_layout")) { - return .wrap(.{ .type_layout = @enumFromInt(parseIndex(idx_str) orelse return null) }); + return .wrap(.{ .type_layout = @fromBackingInt(@intCast(parseIndex(idx_str) orelse return null)) }); } else if (std.mem.eql(u8, kind, "struct_defaults")) { - return .wrap(.{ .struct_defaults = @enumFromInt(parseIndex(idx_str) orelse return null) }); + return .wrap(.{ .struct_defaults = @fromBackingInt(@intCast(parseIndex(idx_str) orelse return null)) }); } else if (std.mem.eql(u8, kind, "func")) { - return .wrap(.{ .func = @enumFromInt(parseIndex(idx_str) orelse return null) }); + return .wrap(.{ .func = @fromBackingInt(@intCast(parseIndex(idx_str) orelse return null)) }); } else if (std.mem.eql(u8, kind, "memoized_state")) { return .wrap(.{ .memoized_state = std.meta.stringToEnum( InternPool.MemoizedStateStage, @@ -392,7 +392,7 @@ fn parseAnalUnit(str: []const u8) ?AnalUnit { fn printAnalUnit(unit: AnalUnit, buf: *[32]u8) []const u8 { const idx: u32 = switch (unit.unwrap()) { .memoized_state => |stage| return std.fmt.bufPrint(buf, "memoized_state {s}", .{@tagName(stage)}) catch unreachable, - inline else => |i| @intFromEnum(i), + inline else => |i| @backingInt(i), }; return std.fmt.bufPrint(buf, "{s} {d}", .{ @tagName(unit.unwrap()), idx }) catch unreachable; } @@ -437,7 +437,7 @@ fn printType(ty: Type, zcu: *const Zcu, w: *Io.Writer) Io.Writer.Error!void { .union_type, .enum_type, .opaque_type, - => try w.print("{f}[{d}]", .{ ty.containerTypeName(ip).fmt(ip), @intFromEnum(ty.toIntern()) }), + => try w.print("{f}[{d}]", .{ ty.containerTypeName(ip).fmt(ip), @backingInt(ty.toIntern()) }), else => unreachable, } diff --git a/src/InternPool.zig b/src/InternPool.zig index bb68c6c5a07161773911af2c740b6ff68d5cfa72..5a28a997418a52a40a06c324d610348ab5c17800 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -152,11 +152,11 @@ pub const TrackedInst = extern struct { pub fn unwrap(inst: ZirIndex) ?Zir.Inst.Index { return switch (inst) { .lost => null, - _ => @enumFromInt(@intFromEnum(inst)), + _ => @fromBackingInt(@intCast(@backingInt(inst))), }; } pub fn wrap(inst: Zir.Inst.Index) ZirIndex { - return @enumFromInt(@intFromEnum(inst)); + return @fromBackingInt(@intCast(@backingInt(inst))); } }; comptime { @@ -187,7 +187,7 @@ pub const TrackedInst = extern struct { } pub fn toOptional(i: TrackedInst.Index) Optional { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } pub const Optional = enum(u32) { none = std.math.maxInt(u32), @@ -195,7 +195,7 @@ pub const TrackedInst = extern struct { pub fn unwrap(opt: Optional) ?TrackedInst.Index { return switch (opt) { .none => null, - _ => @enumFromInt(@intFromEnum(opt)), + _ => @fromBackingInt(@intCast(@backingInt(opt))), }; } @@ -207,16 +207,16 @@ pub const TrackedInst = extern struct { index: u32, pub fn wrap(unwrapped: Unwrapped, ip: *const InternPool) TrackedInst.Index { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | - unwrapped.index); + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_32) | + unwrapped.index)); } }; pub fn unwrap(tracked_inst_index: TrackedInst.Index, ip: *const InternPool) Unwrapped { return .{ - .tid = @enumFromInt(@intFromEnum(tracked_inst_index) >> ip.tid_shift_32 & ip.getTidMask()), - .index = @intFromEnum(tracked_inst_index) & ip.getIndexMask(u32), + .tid = @fromBackingInt(@intCast(@backingInt(tracked_inst_index) >> ip.tid_shift_32 & ip.getTidMask())), + .index = @backingInt(tracked_inst_index) & ip.getIndexMask(u32), }; } @@ -408,7 +408,7 @@ pub fn rehashTrackedInsts( if (entry.acquire() == .none) break entry; }; const index = TrackedInst.Index.Unwrapped.wrap(.{ - .tid = @enumFromInt(local_tid), + .tid = @fromBackingInt(@intCast(local_tid)), .index = @intCast(local_inst_index), }, ip); entry.hash = hash; @@ -455,7 +455,7 @@ pub const AnalUnit = packed struct(u64) { inline else => |tag| @unionInit( Unwrapped, @tagName(tag), - @enumFromInt(au.id), + @fromBackingInt(@intCast(au.id)), ), }; } @@ -463,13 +463,13 @@ pub const AnalUnit = packed struct(u64) { return switch (raw) { inline else => |id, tag| .{ .kind = tag, - .id = @intFromEnum(id), + .id = @backingInt(id), }, }; } pub fn toOptional(as: AnalUnit) Optional { - return @enumFromInt(@as(u64, @bitCast(as))); + return @fromBackingInt(@intCast(@as(u64, @bitCast(as)))); } pub const Optional = enum(u64) { none = std.math.maxInt(u64), @@ -477,7 +477,7 @@ pub const AnalUnit = packed struct(u64) { pub fn unwrap(opt: Optional) ?AnalUnit { return switch (opt) { .none => null, - _ => @bitCast(@intFromEnum(opt)), + _ => @bitCast(@backingInt(opt)), }; } }; @@ -509,16 +509,16 @@ pub const ComptimeUnit = extern struct { tid: Zcu.PerThread.Id, index: u32, fn wrap(unwrapped: Unwrapped, ip: *const InternPool) ComptimeUnit.Id { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | - unwrapped.index); + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_32) | + unwrapped.index)); } }; fn unwrap(id: Id, ip: *const InternPool) Unwrapped { return .{ - .tid = @enumFromInt(@intFromEnum(id) >> ip.tid_shift_32 & ip.getTidMask()), - .index = @intFromEnum(id) & ip.getIndexMask(u31), + .tid = @fromBackingInt(@intCast(@backingInt(id) >> ip.tid_shift_32 & ip.getTidMask())), + .index = @backingInt(id) & ip.getIndexMask(u31), }; } @@ -633,30 +633,30 @@ pub const Nav = struct { pub fn unwrap(opt: Optional) ?Nav.Index { return switch (opt) { .none => null, - _ => @enumFromInt(@intFromEnum(opt)), + _ => @fromBackingInt(@intCast(@backingInt(opt))), }; } const debug_state = InternPool.debug_state; }; pub fn toOptional(i: Nav.Index) Optional { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } const Unwrapped = struct { tid: Zcu.PerThread.Id, index: u32, fn wrap(unwrapped: Unwrapped, ip: *const InternPool) Nav.Index { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u30)); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_30) | - unwrapped.index); + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_30) | + unwrapped.index)); } }; fn unwrap(nav_index: Nav.Index, ip: *const InternPool) Unwrapped { return .{ - .tid = @enumFromInt(@intFromEnum(nav_index) >> ip.tid_shift_30 & ip.getTidMask()), - .index = @intFromEnum(nav_index) & ip.getIndexMask(u30), + .tid = @fromBackingInt(@intCast(@backingInt(nav_index) >> ip.tid_shift_30 & ip.getTidMask())), + .index = @backingInt(nav_index) & ip.getIndexMask(u30), }; } @@ -762,19 +762,19 @@ pub fn removeDependenciesForDepender(ip: *InternPool, gpa: Allocator, depender: var opt_idx = (ip.first_dependency.fetchSwapRemove(depender) orelse return).value.toOptional(); while (opt_idx.unwrap()) |idx| { - const dep = ip.dep_entries.items[@intFromEnum(idx)]; + const dep = ip.dep_entries.items[@backingInt(idx)]; opt_idx = dep.next_dependee; const prev_idx = dep.prev.unwrap() orelse { // This entry is the start of a list in some `*_deps`. // We cannot easily remove this mapping, so this must remain as a dummy entry. - ip.dep_entries.items[@intFromEnum(idx)].depender = .none; + ip.dep_entries.items[@backingInt(idx)].depender = .none; continue; }; - ip.dep_entries.items[@intFromEnum(prev_idx)].next = dep.next; + ip.dep_entries.items[@backingInt(prev_idx)].next = dep.next; if (dep.next.unwrap()) |next_idx| { - ip.dep_entries.items[@intFromEnum(next_idx)].prev = dep.prev; + ip.dep_entries.items[@backingInt(next_idx)].prev = dep.prev; } ip.free_dep_entries.append(gpa, idx) catch { @@ -790,7 +790,7 @@ pub const DependencyIterator = struct { pub fn next(it: *DependencyIterator) ?AnalUnit { while (true) { const idx = it.next_entry.unwrap() orelse return null; - const entry = it.ip.dep_entries.items[@intFromEnum(idx)]; + const entry = it.ip.dep_entries.items[@backingInt(idx)]; it.next_entry = entry.next; if (entry.depender.unwrap()) |depender| return depender; } @@ -853,7 +853,7 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend }; if (deps.unwrap()) |first| { - if (ip.dep_entries.items[@intFromEnum(first)].depender == .none) { + if (ip.dep_entries.items[@backingInt(first)].depender == .none) { // Dummy entry, so we can reuse it rather than allocating a new one! break :new_index first; } @@ -861,11 +861,11 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend // Prepend a new dependency. const new_index: DepEntry.Index, const ptr = if (ip.free_dep_entries.pop()) |new_index| new: { - break :new .{ new_index, &ip.dep_entries.items[@intFromEnum(new_index)] }; - } else .{ @enumFromInt(ip.dep_entries.items.len), ip.dep_entries.addOneAssumeCapacity() }; + break :new .{ new_index, &ip.dep_entries.items[@backingInt(new_index)] }; + } else .{ @fromBackingInt(@intCast(ip.dep_entries.items.len)), ip.dep_entries.addOneAssumeCapacity() }; if (deps.unwrap()) |old_first| { ptr.next = old_first.toOptional(); - ip.dep_entries.items[@intFromEnum(old_first)].prev = new_index.toOptional(); + ip.dep_entries.items[@backingInt(old_first)].prev = new_index.toOptional(); } else { ptr.next = .none; } @@ -887,18 +887,18 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend .memoized_state => comptime unreachable, }.getOrPut(gpa, dependee_payload); - if (gop.found_existing and ip.dep_entries.items[@intFromEnum(gop.value_ptr.*)].depender == .none) { + if (gop.found_existing and ip.dep_entries.items[@backingInt(gop.value_ptr.*)].depender == .none) { // Dummy entry, so we can reuse it rather than allocating a new one! break :new_index gop.value_ptr.*; } // Prepend a new dependency. const new_index: DepEntry.Index, const ptr = if (ip.free_dep_entries.pop()) |new_index| new: { - break :new .{ new_index, &ip.dep_entries.items[@intFromEnum(new_index)] }; - } else .{ @enumFromInt(ip.dep_entries.items.len), ip.dep_entries.addOneAssumeCapacity() }; + break :new .{ new_index, &ip.dep_entries.items[@backingInt(new_index)] }; + } else .{ @fromBackingInt(@intCast(ip.dep_entries.items.len)), ip.dep_entries.addOneAssumeCapacity() }; if (gop.found_existing) { ptr.next = gop.value_ptr.*.toOptional(); - ip.dep_entries.items[@intFromEnum(gop.value_ptr.*)].prev = new_index.toOptional(); + ip.dep_entries.items[@backingInt(gop.value_ptr.*)].prev = new_index.toOptional(); } else { ptr.next = .none; } @@ -907,9 +907,9 @@ pub fn addDependency(ip: *InternPool, gpa: Allocator, depender: AnalUnit, depend }, }; - ip.dep_entries.items[@intFromEnum(new_index)].depender = depender.toOptional(); - ip.dep_entries.items[@intFromEnum(new_index)].prev = .none; - ip.dep_entries.items[@intFromEnum(new_index)].next_dependee = first_depender_dep; + ip.dep_entries.items[@backingInt(new_index)].depender = depender.toOptional(); + ip.dep_entries.items[@backingInt(new_index)].prev = .none; + ip.dep_entries.items[@backingInt(new_index)].next_dependee = first_depender_dep; ip.first_dependency.putAssumeCapacity(depender, new_index); } @@ -942,7 +942,7 @@ pub const DepEntry = extern struct { pub const Index = enum(u32) { _, pub fn toOptional(dep: DepEntry.Index) Optional { - return @enumFromInt(@intFromEnum(dep)); + return @fromBackingInt(@intCast(@backingInt(dep))); } pub const Optional = enum(u32) { none = std.math.maxInt(u32), @@ -950,7 +950,7 @@ pub const DepEntry = extern struct { pub fn unwrap(opt: Optional) ?DepEntry.Index { return switch (opt) { .none => null, - _ => @enumFromInt(@intFromEnum(opt)), + _ => @fromBackingInt(@intCast(@backingInt(opt))), }; } }; @@ -1439,11 +1439,11 @@ const Local = struct { }; pub fn getLocal(ip: *InternPool, tid: Zcu.PerThread.Id) *Local { - return &ip.locals[@intFromEnum(tid)]; + return &ip.locals[@backingInt(tid)]; } pub fn getLocalShared(ip: *const InternPool, tid: Zcu.PerThread.Id) *const Local.Shared { - return &ip.locals[@intFromEnum(tid)].shared; + return &ip.locals[@backingInt(tid)].shared; } const Shard = struct { @@ -1596,7 +1596,7 @@ pub const OptionalMapIndex = enum(u32) { pub fn unwrap(oi: OptionalMapIndex) ?MapIndex { if (oi == .none) return null; - return @enumFromInt(@intFromEnum(oi)); + return @fromBackingInt(@intCast(@backingInt(oi))); } }; @@ -1611,7 +1611,7 @@ pub const MapIndex = enum(u32) { } pub fn toOptional(i: MapIndex) OptionalMapIndex { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } const Unwrapped = struct { @@ -1619,16 +1619,16 @@ pub const MapIndex = enum(u32) { index: u32, fn wrap(unwrapped: Unwrapped, ip: *const InternPool) MapIndex { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | - unwrapped.index); + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_32) | + unwrapped.index)); } }; fn unwrap(map_index: MapIndex, ip: *const InternPool) Unwrapped { return .{ - .tid = @enumFromInt(@intFromEnum(map_index) >> ip.tid_shift_32 & ip.getTidMask()), - .index = @intFromEnum(map_index) & ip.getIndexMask(u32), + .tid = @fromBackingInt(@intCast(@backingInt(map_index) >> ip.tid_shift_32 & ip.getTidMask())), + .index = @backingInt(map_index) & ip.getIndexMask(u32), }; } }; @@ -1644,25 +1644,25 @@ pub const NamespaceIndex = enum(u32) { index: u32, fn wrap(unwrapped: Unwrapped, ip: *const InternPool) NamespaceIndex { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.bucket_index <= ip.getIndexMask(u32) >> Local.namespaces_bucket_width); assert(unwrapped.index <= Local.namespaces_bucket_mask); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_32) | unwrapped.bucket_index << Local.namespaces_bucket_width | - unwrapped.index); + unwrapped.index)); } }; fn unwrap(namespace_index: NamespaceIndex, ip: *const InternPool) Unwrapped { - const index = @intFromEnum(namespace_index) & ip.getIndexMask(u32); + const index = @backingInt(namespace_index) & ip.getIndexMask(u32); return .{ - .tid = @enumFromInt(@intFromEnum(namespace_index) >> ip.tid_shift_32 & ip.getTidMask()), + .tid = @fromBackingInt(@intCast(@backingInt(namespace_index) >> ip.tid_shift_32 & ip.getTidMask())), .bucket_index = index >> Local.namespaces_bucket_width, .index = index & Local.namespaces_bucket_mask, }; } pub fn toOptional(i: NamespaceIndex) OptionalNamespaceIndex { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } }; @@ -1671,12 +1671,12 @@ pub const OptionalNamespaceIndex = enum(u32) { _, pub fn init(oi: ?NamespaceIndex) OptionalNamespaceIndex { - return @enumFromInt(@intFromEnum(oi orelse return .none)); + return @fromBackingInt(@intCast(@backingInt(oi orelse return .none))); } pub fn unwrap(oi: OptionalNamespaceIndex) ?NamespaceIndex { if (oi == .none) return null; - return @enumFromInt(@intFromEnum(oi)); + return @fromBackingInt(@intCast(@backingInt(oi))); } }; @@ -1688,20 +1688,20 @@ pub const FileIndex = enum(u32) { index: u32, fn wrap(unwrapped: Unwrapped, ip: *const InternPool) FileIndex { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | - unwrapped.index); + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_32) | + unwrapped.index)); } }; pub fn unwrap(file_index: FileIndex, ip: *const InternPool) Unwrapped { return .{ - .tid = @enumFromInt(@intFromEnum(file_index) >> ip.tid_shift_32 & ip.getTidMask()), - .index = @intFromEnum(file_index) & ip.getIndexMask(u32), + .tid = @fromBackingInt(@intCast(@backingInt(file_index) >> ip.tid_shift_32 & ip.getTidMask())), + .index = @backingInt(file_index) & ip.getIndexMask(u32), }; } pub fn toOptional(i: FileIndex) Optional { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } pub const Optional = enum(u32) { none = std.math.maxInt(u32), @@ -1709,7 +1709,7 @@ pub const FileIndex = enum(u32) { pub fn unwrap(opt: Optional) ?FileIndex { return switch (opt) { .none => null, - _ => @enumFromInt(@intFromEnum(opt)), + _ => @fromBackingInt(@intCast(@backingInt(opt))), }; } }; @@ -1739,7 +1739,7 @@ pub const String = enum(u32) { pub fn toNullTerminatedString(string: String, len: u64, ip: *const InternPool) NullTerminatedString { assert(std.mem.indexOfScalar(u8, string.toSlice(len, ip), 0) == null); assert(string.at(len, ip) == 0); - return @enumFromInt(@intFromEnum(string)); + return @fromBackingInt(@intCast(@backingInt(string))); } const Unwrapped = struct { @@ -1747,16 +1747,16 @@ pub const String = enum(u32) { index: u32, fn wrap(unwrapped: Unwrapped, ip: *const InternPool) String { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u32)); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_32) | - unwrapped.index); + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_32) | + unwrapped.index)); } }; fn unwrap(string: String, ip: *const InternPool) Unwrapped { return .{ - .tid = @enumFromInt(@intFromEnum(string) >> ip.tid_shift_32 & ip.getTidMask()), - .index = @intFromEnum(string) & ip.getIndexMask(u32), + .tid = @fromBackingInt(@intCast(@backingInt(string) >> ip.tid_shift_32 & ip.getTidMask())), + .index = @backingInt(string) & ip.getIndexMask(u32), }; } @@ -1779,7 +1779,7 @@ pub const OptionalString = enum(u32) { _, pub fn unwrap(string: OptionalString) ?String { - return if (string != .none) @enumFromInt(@intFromEnum(string)) else null; + return if (string != .none) @fromBackingInt(@intCast(@backingInt(string))) else null; } pub fn toSlice(string: OptionalString, len: u64, ip: *const InternPool) ?[]const u8 { @@ -1812,11 +1812,11 @@ pub const NullTerminatedString = enum(u32) { }; pub fn toString(self: NullTerminatedString) String { - return @enumFromInt(@intFromEnum(self)); + return @fromBackingInt(@intCast(@backingInt(self))); } pub fn toOptional(self: NullTerminatedString) OptionalNullTerminatedString { - return @enumFromInt(@intFromEnum(self)); + return @fromBackingInt(@intCast(@backingInt(self))); } pub fn toSlice(string: NullTerminatedString, ip: *const InternPool) [:0]const u8 { @@ -1851,14 +1851,14 @@ pub const NullTerminatedString = enum(u32) { pub fn hash(ctx: @This(), a: NullTerminatedString) u32 { _ = ctx; - return std.hash.int(@intFromEnum(a)); + return std.hash.int(@backingInt(a)); } }; /// Compare based on integer value alone, ignoring the string contents. pub fn indexLessThan(ctx: void, a: NullTerminatedString, b: NullTerminatedString) bool { _ = ctx; - return @intFromEnum(a) < @intFromEnum(b); + return @backingInt(a) < @backingInt(b); } pub fn toUnsigned(string: NullTerminatedString, ip: *const InternPool) ?u32 { @@ -1901,7 +1901,7 @@ pub const OptionalNullTerminatedString = enum(u32) { _, pub fn unwrap(string: OptionalNullTerminatedString) ?NullTerminatedString { - return if (string != .none) @enumFromInt(@intFromEnum(string)) else null; + return if (string != .none) @fromBackingInt(@intCast(@backingInt(string))) else null; } pub fn toSlice(string: OptionalNullTerminatedString, ip: *const InternPool) ?[:0]const u8 { @@ -1923,18 +1923,18 @@ pub const CaptureValue = packed struct(u32) { pub fn wrap(val: Unwrapped) CaptureValue { return switch (val) { - .@"comptime" => |i| .{ .tag = .@"comptime", .idx = @intCast(@intFromEnum(i)) }, - .runtime => |i| .{ .tag = .runtime, .idx = @intCast(@intFromEnum(i)) }, - .nav_val => |i| .{ .tag = .nav_val, .idx = @intCast(@intFromEnum(i)) }, - .nav_ref => |i| .{ .tag = .nav_ref, .idx = @intCast(@intFromEnum(i)) }, + .@"comptime" => |i| .{ .tag = .@"comptime", .idx = @intCast(@backingInt(i)) }, + .runtime => |i| .{ .tag = .runtime, .idx = @intCast(@backingInt(i)) }, + .nav_val => |i| .{ .tag = .nav_val, .idx = @intCast(@backingInt(i)) }, + .nav_ref => |i| .{ .tag = .nav_ref, .idx = @intCast(@backingInt(i)) }, }; } pub fn unwrap(val: CaptureValue) Unwrapped { return switch (val.tag) { - .@"comptime" => .{ .@"comptime" = @enumFromInt(val.idx) }, - .runtime => .{ .runtime = @enumFromInt(val.idx) }, - .nav_val => .{ .nav_val = @enumFromInt(val.idx) }, - .nav_ref => .{ .nav_ref = @enumFromInt(val.idx) }, + .@"comptime" => .{ .@"comptime" = @fromBackingInt(@intCast(val.idx)) }, + .runtime => .{ .runtime = @fromBackingInt(@intCast(val.idx)) }, + .nav_val => .{ .nav_val = @fromBackingInt(@intCast(val.idx)) }, + .nav_ref => .{ .nav_ref = @fromBackingInt(@intCast(val.idx)) }, }; } @@ -2605,7 +2605,7 @@ pub const Key = union(enum) { pub fn hash64(key: Key, ip: *const InternPool) u64 { const asBytes = std.mem.asBytes; const KeyTag = @typeInfo(Key).@"union".tag_type.?; - const seed = @intFromEnum(@as(KeyTag, key)); + const seed = @backingInt(@as(KeyTag, key)); return switch (key) { inline .ptr_type, .array_type, @@ -2629,7 +2629,7 @@ pub const Key = union(enum) { return Hash.hash(seed, asBytes(&x)); }, - .int_type => |x| Hash.hash(seed + @intFromEnum(x.signedness), asBytes(&x.bits)), + .int_type => |x| Hash.hash(seed + @backingInt(x.signedness), asBytes(&x.bits)), .error_union => |x| switch (x.val) { .err_name => |y| Hash.hash(seed + 0, asBytes(&x.ty) ++ asBytes(&y)), @@ -2695,7 +2695,7 @@ pub const Key = union(enum) { // Int-to-ptr pointers are hashed separately than decl-referencing pointers. // This is sound due to pointer provenance rules. const addr_tag: Key.Ptr.BaseAddr.Tag = ptr.base_addr; - const seed2 = seed + @intFromEnum(addr_tag); + const seed2 = seed + @backingInt(addr_tag); const big_offset: i128 = ptr.byte_offset; const common = asBytes(&ptr.ty) ++ asBytes(&big_offset); return switch (ptr.base_addr) { @@ -2829,7 +2829,7 @@ pub const Key = union(enum) { asBytes(&e.is_threadlocal) ++ asBytes(&e.is_dll_import) ++ asBytes(&e.relocation) ++ asBytes(&e.is_const) ++ asBytes(&e.alignment) ++ asBytes(&e.@"addrspace") ++ - asBytes(&e.zir_index) ++ &[1]u8{@intFromEnum(e.source)}), + asBytes(&e.zir_index) ++ &[1]u8{@backingInt(e.source)}), .bitpack => |bitpack| Hash.hash(seed, asBytes(&bitpack.ty) ++ asBytes(&bitpack.backing_int_val)), }; @@ -3304,7 +3304,7 @@ pub const LoadedStructType = struct { return switch (i) { .omitted => null, .unresolved => unreachable, - else => @intFromEnum(i), + else => @backingInt(i), }; } }; @@ -3642,7 +3642,7 @@ pub fn loadStructType(ip: *const InternPool, index: Index) LoadedStructType { _ => |n| .{ .tid = unwrapped_index.tid, .start = extra_index, - .len = @intFromEnum(n), + .len = @backingInt(n), }, }; extra_index += captures.len; @@ -3778,7 +3778,7 @@ pub fn loadUnionType(ip: *const InternPool, index: Index) LoadedUnionType { _ => |n| .{ .tid = unwrapped_index.tid, .start = extra_index, - .len = @intFromEnum(n), + .len = @backingInt(n), }, }; extra_index += captures.len; @@ -3834,30 +3834,30 @@ pub fn loadEnumType(ip: *const InternPool, index: Index) LoadedEnumType { var extra_index: u32 = @intCast(extra.end); const zir_index: TrackedInst.Index.Optional, const captures: CaptureValue.Slice, const owner_union: Index = switch (extra.data.bits.captures_len) { .reified => info: { - const zir_index: TrackedInst.Index = @enumFromInt(extra_items[extra_index]); + const zir_index: TrackedInst.Index = @fromBackingInt(@intCast(extra_items[extra_index])); extra_index += 1; extra_index += 2; // type_hash: PackedU64 break :info .{ zir_index.toOptional(), .empty, .none }; }, .generated_union_tag => info: { - const owner_union: Index = @enumFromInt(extra_items[extra_index]); + const owner_union: Index = @fromBackingInt(@intCast(extra_items[extra_index])); extra_index += 1; break :info .{ .none, .empty, owner_union }; }, _ => |n| info: { - const zir_index: TrackedInst.Index = @enumFromInt(extra_items[extra_index]); + const zir_index: TrackedInst.Index = @fromBackingInt(@intCast(extra_items[extra_index])); extra_index += 1; const captures: CaptureValue.Slice = .{ .tid = unwrapped_index.tid, .start = extra_index, - .len = @intFromEnum(n), + .len = @backingInt(n), }; extra_index += captures.len; break :info .{ zir_index.toOptional(), captures, .none }; }, }; const field_value_map: OptionalMapIndex = if (explicit_int_tag) m: { - const map: MapIndex = @enumFromInt(extra_items[extra_index]); + const map: MapIndex = @fromBackingInt(@intCast(extra_items[extra_index])); extra_index += 1; break :m map.toOptional(); } else .none; @@ -4138,7 +4138,7 @@ pub const Index = enum(u32) { pub fn hash(ctx: @This(), a: Index) u32 { _ = ctx; - return std.hash.int(@intFromEnum(a)); + return std.hash.int(@backingInt(a)); } }; @@ -4147,10 +4147,10 @@ pub const Index = enum(u32) { index: u32, fn wrap(unwrapped: Unwrapped, ip: *const InternPool) Index { - assert(@intFromEnum(unwrapped.tid) <= ip.getTidMask()); + assert(@backingInt(unwrapped.tid) <= ip.getTidMask()); assert(unwrapped.index <= ip.getIndexMask(u30)); - return @enumFromInt(@shlExact(@as(u32, @intFromEnum(unwrapped.tid)), ip.tid_shift_30) | - unwrapped.index); + return @fromBackingInt(@intCast(@shlExact(@as(u32, @backingInt(unwrapped.tid)), ip.tid_shift_30) | + unwrapped.index)); } pub fn getExtra(unwrapped: Unwrapped, ip: *const InternPool) Local.Extra { @@ -4188,8 +4188,8 @@ pub const Index = enum(u32) { }; pub fn unwrap(index: Index, ip: *const InternPool) Unwrapped { return .{ - .tid = @enumFromInt(@intFromEnum(index) >> ip.tid_shift_30 & ip.getTidMask()), - .index = @intFromEnum(index) & ip.getIndexMask(u30), + .tid = @fromBackingInt(@intCast(@backingInt(index) >> ip.tid_shift_30 & ip.getTidMask())), + .index = @backingInt(index) & ip.getIndexMask(u30), }; } @@ -5794,46 +5794,46 @@ pub const TypeTuple = struct { /// implement logic that only wants to deal with types because the logic can /// ignore all simple values. Note that technically, types are values. pub const SimpleType = enum(u32) { - f16 = @intFromEnum(Index.f16_type), - f32 = @intFromEnum(Index.f32_type), - f64 = @intFromEnum(Index.f64_type), - f80 = @intFromEnum(Index.f80_type), - f128 = @intFromEnum(Index.f128_type), - usize = @intFromEnum(Index.usize_type), - isize = @intFromEnum(Index.isize_type), - c_char = @intFromEnum(Index.c_char_type), - c_short = @intFromEnum(Index.c_short_type), - c_ushort = @intFromEnum(Index.c_ushort_type), - c_int = @intFromEnum(Index.c_int_type), - c_uint = @intFromEnum(Index.c_uint_type), - c_long = @intFromEnum(Index.c_long_type), - c_ulong = @intFromEnum(Index.c_ulong_type), - c_longlong = @intFromEnum(Index.c_longlong_type), - c_ulonglong = @intFromEnum(Index.c_ulonglong_type), - c_longdouble = @intFromEnum(Index.c_longdouble_type), - anyopaque = @intFromEnum(Index.anyopaque_type), - bool = @intFromEnum(Index.bool_type), - void = @intFromEnum(Index.void_type), - type = @intFromEnum(Index.type_type), - anyerror = @intFromEnum(Index.anyerror_type), - comptime_int = @intFromEnum(Index.comptime_int_type), - comptime_float = @intFromEnum(Index.comptime_float_type), - noreturn = @intFromEnum(Index.noreturn_type), - null = @intFromEnum(Index.null_type), - undefined = @intFromEnum(Index.undefined_type), - enum_literal = @intFromEnum(Index.enum_literal_type), + f16 = @backingInt(Index.f16_type), + f32 = @backingInt(Index.f32_type), + f64 = @backingInt(Index.f64_type), + f80 = @backingInt(Index.f80_type), + f128 = @backingInt(Index.f128_type), + usize = @backingInt(Index.usize_type), + isize = @backingInt(Index.isize_type), + c_char = @backingInt(Index.c_char_type), + c_short = @backingInt(Index.c_short_type), + c_ushort = @backingInt(Index.c_ushort_type), + c_int = @backingInt(Index.c_int_type), + c_uint = @backingInt(Index.c_uint_type), + c_long = @backingInt(Index.c_long_type), + c_ulong = @backingInt(Index.c_ulong_type), + c_longlong = @backingInt(Index.c_longlong_type), + c_ulonglong = @backingInt(Index.c_ulonglong_type), + c_longdouble = @backingInt(Index.c_longdouble_type), + anyopaque = @backingInt(Index.anyopaque_type), + bool = @backingInt(Index.bool_type), + void = @backingInt(Index.void_type), + type = @backingInt(Index.type_type), + anyerror = @backingInt(Index.anyerror_type), + comptime_int = @backingInt(Index.comptime_int_type), + comptime_float = @backingInt(Index.comptime_float_type), + noreturn = @backingInt(Index.noreturn_type), + null = @backingInt(Index.null_type), + undefined = @backingInt(Index.undefined_type), + enum_literal = @backingInt(Index.enum_literal_type), - adhoc_inferred_error_set = @intFromEnum(Index.adhoc_inferred_error_set_type), - generic_poison = @intFromEnum(Index.generic_poison_type), + adhoc_inferred_error_set = @backingInt(Index.adhoc_inferred_error_set_type), + generic_poison = @backingInt(Index.generic_poison_type), }; pub const SimpleValue = enum(u32) { - void = @intFromEnum(Index.void_value), + void = @backingInt(Index.void_value), /// This is untyped `null`. - null = @intFromEnum(Index.null_value), - true = @intFromEnum(Index.bool_true), - false = @intFromEnum(Index.bool_false), - @"unreachable" = @intFromEnum(Index.unreachable_value), + null = @backingInt(Index.null_value), + true = @backingInt(Index.bool_true), + false = @backingInt(Index.bool_false), + @"unreachable" = @backingInt(Index.unreachable_value), }; /// Stored as a power-of-two, with one special value to indicate none. @@ -5851,14 +5851,14 @@ pub const Alignment = enum(u6) { pub fn toByteUnits(a: Alignment) ?u64 { return switch (a) { .none => null, - else => @as(u64, 1) << @intFromEnum(a), + else => @as(u64, 1) << @backingInt(a), }; } pub fn fromByteUnits(n: u64) Alignment { if (n == 0) return .none; assert(std.math.isPowerOfTwo(n)); - return @enumFromInt(@ctz(n)); + return @fromBackingInt(@intCast(@ctz(n))); } pub fn fromNonzeroByteUnits(n: u64) Alignment { @@ -5868,21 +5868,21 @@ pub const Alignment = enum(u6) { pub fn toLog2Units(a: Alignment) u6 { assert(a != .none); - return @intFromEnum(a); + return @backingInt(a); } /// This is just a glorified `@enumFromInt` but using it can help /// document the intended conversion. /// The parameter uses a u32 for convenience at the callsite. pub fn fromLog2Units(a: u32) Alignment { - assert(a != @intFromEnum(Alignment.none)); - return @enumFromInt(a); + assert(a != @backingInt(Alignment.none)); + return @fromBackingInt(@intCast(a)); } pub fn order(lhs: Alignment, rhs: Alignment) std.math.Order { assert(lhs != .none); assert(rhs != .none); - return std.math.order(@intFromEnum(lhs), @intFromEnum(rhs)); + return std.math.order(@backingInt(lhs), @backingInt(rhs)); } /// Relaxed comparison. We have this as default because a lot of callsites @@ -5896,7 +5896,7 @@ pub const Alignment = enum(u6) { pub fn compareStrict(lhs: Alignment, op: std.math.CompareOperator, rhs: Alignment) bool { assert(lhs != .none); assert(rhs != .none); - return std.math.compare(@intFromEnum(lhs), op, @intFromEnum(rhs)); + return std.math.compare(@backingInt(lhs), op, @backingInt(rhs)); } /// Treats `none` as zero. @@ -5911,7 +5911,7 @@ pub const Alignment = enum(u6) { pub fn maxStrict(lhs: Alignment, rhs: Alignment) Alignment { assert(lhs != .none); assert(rhs != .none); - return @enumFromInt(@max(@intFromEnum(lhs), @intFromEnum(rhs))); + return @fromBackingInt(@intCast(@max(@backingInt(lhs), @backingInt(rhs)))); } /// Treats `none` as zero. @@ -5926,7 +5926,7 @@ pub const Alignment = enum(u6) { pub fn minStrict(lhs: Alignment, rhs: Alignment) Alignment { assert(lhs != .none); assert(rhs != .none); - return @enumFromInt(@min(@intFromEnum(lhs), @intFromEnum(rhs))); + return @fromBackingInt(@intCast(@min(@backingInt(lhs), @backingInt(rhs)))); } /// Given a base address known to be aligned to `a`, @@ -5938,21 +5938,21 @@ pub const Alignment = enum(u6) { /// Align an address forwards to this alignment. pub fn forward(a: Alignment, addr: u64) u64 { assert(a != .none); - const x = (@as(u64, 1) << @intFromEnum(a)) - 1; + const x = (@as(u64, 1) << @backingInt(a)) - 1; return (addr + x) & ~x; } /// Align an address backwards to this alignment. pub fn backward(a: Alignment, addr: u64) u64 { assert(a != .none); - const x = (@as(u64, 1) << @intFromEnum(a)) - 1; + const x = (@as(u64, 1) << @backingInt(a)) - 1; return addr & ~x; } /// Check if an address is aligned to this amount. pub fn check(a: Alignment, addr: u64) bool { assert(a != .none); - return @ctz(addr) >= @intFromEnum(a); + return @ctz(addr) >= @backingInt(a); } /// An array of `Alignment` objects existing within the `extra` array. @@ -5981,25 +5981,25 @@ pub const Alignment = enum(u6) { }; pub fn toRelaxedCompareUnits(a: Alignment) u8 { - const n: u8 = @intFromEnum(a); - assert(n <= @intFromEnum(Alignment.none)); - if (n == @intFromEnum(Alignment.none)) return 0; + const n: u8 = @backingInt(a); + assert(n <= @backingInt(Alignment.none)); + if (n == @backingInt(Alignment.none)) return 0; return n + 1; } pub fn toStdMem(a: Alignment) std.mem.Alignment { assert(a != .none); - return @enumFromInt(@intFromEnum(a)); + return @fromBackingInt(@intCast(@backingInt(a))); } pub fn fromStdMem(a: std.mem.Alignment) Alignment { - const r: Alignment = @enumFromInt(@intFromEnum(a)); + const r: Alignment = @fromBackingInt(@intCast(@backingInt(a))); assert(r != .none); return r; } pub fn toLlvm(a: Alignment) std.zig.llvm.Builder.Alignment { - return @enumFromInt(@intFromEnum(a)); + return @fromBackingInt(@intCast(@backingInt(a))); } }; @@ -6349,7 +6349,7 @@ pub fn init(ip: *InternPool, gpa: Allocator, io: Io, available_threads: usize) ! // This inserts all the statically-known values into the intern pool in the // order expected. - for (&static_keys, 0..) |key, key_index| switch (@as(Index, @enumFromInt(key_index))) { + for (&static_keys, 0..) |key, key_index| switch (@as(Index, @fromBackingInt(@intCast(key_index)))) { .empty_tuple_type => assert(try ip.getTupleType(gpa, io, .main, .{ .types = &.{}, .values = &.{}, @@ -6476,8 +6476,8 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { .sentinel = .none, } }; }, - .simple_type => .{ .simple_type = @enumFromInt(@intFromEnum(index)) }, - .simple_value => .{ .simple_value = @enumFromInt(@intFromEnum(index)) }, + .simple_type => .{ .simple_type = @fromBackingInt(@intCast(@backingInt(index))) }, + .simple_value => .{ .simple_value = @fromBackingInt(@intCast(@backingInt(index))) }, .type_vector => { const vector_info = extraData(unwrapped_index.getExtra(ip), Vector, data); @@ -6490,7 +6490,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { .type_pointer => .{ .ptr_type = extraData(unwrapped_index.getExtra(ip), Tag.TypePointer, data) }, .type_slice => { - const many_ptr_index: Index = @enumFromInt(data); + const many_ptr_index: Index = @fromBackingInt(@intCast(data)); const many_ptr_unwrapped = many_ptr_index.unwrap(ip); const many_ptr_item = many_ptr_unwrapped.getItem(ip); assert(many_ptr_item.tag == .type_pointer); @@ -6499,17 +6499,17 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { return .{ .ptr_type = ptr_info }; }, - .type_optional => .{ .opt_type = @enumFromInt(data) }, - .type_anyframe => .{ .anyframe_type = @enumFromInt(data) }, + .type_optional => .{ .opt_type = @fromBackingInt(@intCast(data)) }, + .type_anyframe => .{ .anyframe_type = @fromBackingInt(@intCast(data)) }, .type_error_union => .{ .error_union_type = extraData(unwrapped_index.getExtra(ip), Key.ErrorUnionType, data) }, .type_anyerror_union => .{ .error_union_type = .{ .error_set_type = .anyerror_type, - .payload_type = @enumFromInt(data), + .payload_type = @fromBackingInt(@intCast(data)), } }, .type_error_set => .{ .error_set_type = extraErrorSet(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) }, .type_inferred_error_set => .{ - .inferred_error_set_type = @enumFromInt(data), + .inferred_error_set_type = @fromBackingInt(@intCast(data)), }, .type_function => .{ .func_type = extraFuncType(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) }, .type_tuple => .{ .tuple_type = extraTypeTuple(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) }, @@ -6553,7 +6553,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { .captures = .{ .owned = .{ .tid = unwrapped_index.tid, .start = extra.end, - .len = @intFromEnum(len), + .len = @backingInt(len), } }, } }, }; @@ -6593,7 +6593,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { .captures = .{ .owned = .{ .tid = unwrapped_index.tid, .start = extra.end, - .len = @intFromEnum(len), + .len = @backingInt(len), } }, } }, }; @@ -6603,18 +6603,18 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { const extra = extraDataTrail(extra_list, Tag.TypeEnum, data); break :ns switch (extra.data.bits.captures_len) { .reified => .{ .reified = .{ - .zir_index = @enumFromInt(extra_list.view().items(.@"0")[extra.end]), + .zir_index = @fromBackingInt(@intCast(extra_list.view().items(.@"0")[extra.end])), .type_hash = extraData(extra_list, PackedU64, extra.end + 1).get(), } }, .generated_union_tag => .{ .generated_union_tag = owner_union: { - break :owner_union @enumFromInt(extra_list.view().items(.@"0")[extra.end]); + break :owner_union @fromBackingInt(@intCast(extra_list.view().items(.@"0")[extra.end])); } }, _ => |len| .{ .declared = .{ - .zir_index = @enumFromInt(extra_list.view().items(.@"0")[extra.end]), + .zir_index = @fromBackingInt(@intCast(extra_list.view().items(.@"0")[extra.end])), .captures = .{ .owned = .{ .tid = unwrapped_index.tid, .start = extra.end + 1, - .len = @intFromEnum(len), + .len = @backingInt(len), } }, } }, }; @@ -6638,9 +6638,9 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { } }; } }, - .undef => .{ .undef = @enumFromInt(data) }, + .undef => .{ .undef = @fromBackingInt(@intCast(data)) }, .opt_null => .{ .opt = .{ - .ty = @enumFromInt(data), + .ty = @fromBackingInt(@intCast(data)), .val = .none, } }, .opt_payload => { @@ -6820,7 +6820,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { .func_decl => .{ .func = extraFuncDecl(unwrapped_index.tid, unwrapped_index.getExtra(ip), data) }, .func_coerced => .{ .func = ip.extraFuncCoerced(unwrapped_index.getExtra(ip), data) }, .only_possible_value => { - const ty: Index = @enumFromInt(data); + const ty: Index = @fromBackingInt(@intCast(data)); const ty_unwrapped = ty.unwrap(ip); const ty_extra = ty_unwrapped.getExtra(ip); const ty_item = ty_unwrapped.getItem(ip); @@ -6912,7 +6912,7 @@ pub fn indexToKey(ip: *const InternPool, index: Index) Key { .val = .{ .payload = extra.val }, } }; }, - .enum_literal => .{ .enum_literal = @enumFromInt(data) }, + .enum_literal => .{ .enum_literal = @fromBackingInt(@intCast(data)) }, .enum_tag => .{ .enum_tag = extraData(unwrapped_index.getExtra(ip), Tag.EnumTag, data) }, .bitpack => .{ .bitpack = extraData(unwrapped_index.getExtra(ip), Key.Bitpack, data) }, @@ -7015,9 +7015,9 @@ fn extraFuncInstance(ip: *const InternPool, tid: Zcu.PerThread.Id, extra: Local. const extra_items = extra.view().items(.@"0"); const analysis_extra_index = extra_index + std.meta.fieldIndex(Tag.FuncInstance, "analysis").?; const analysis: FuncAnalysis = @bitCast(@atomicLoad(u32, &extra_items[analysis_extra_index], .unordered)); - const owner_nav: Nav.Index = @enumFromInt(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "owner_nav").?]); - const ty: Index = @enumFromInt(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "ty").?]); - const generic_owner: Index = @enumFromInt(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "generic_owner").?]); + const owner_nav: Nav.Index = @fromBackingInt(@intCast(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "owner_nav").?])); + const ty: Index = @fromBackingInt(@intCast(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "ty").?])); + const generic_owner: Index = @fromBackingInt(@intCast(extra_items[extra_index + std.meta.fieldIndex(Tag.FuncInstance, "generic_owner").?])); const func_decl = ip.funcDeclInfo(generic_owner); const end_extra_index = extra_index + @as(u32, @typeInfo(Tag.FuncInstance).@"struct".field_names.len); return .{ @@ -7279,7 +7279,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: try items.ensureUnusedCapacity(1); items.appendAssumeCapacity(.{ .tag = .type_slice, - .data = @intFromEnum(ptr_type_index), + .data = @backingInt(ptr_type_index), }); return gop.put(); } @@ -7333,20 +7333,20 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: assert(payload_type != .none); items.appendAssumeCapacity(.{ .tag = .type_optional, - .data = @intFromEnum(payload_type), + .data = @backingInt(payload_type), }); }, .anyframe_type => |payload_type| { // payload_type might be none, indicating the type is `anyframe`. items.appendAssumeCapacity(.{ .tag = .type_anyframe, - .data = @intFromEnum(payload_type), + .data = @backingInt(payload_type), }); }, .error_union_type => |error_union_type| { items.appendAssumeCapacity(if (error_union_type.error_set_type == .anyerror_type) .{ .tag = .type_anyerror_union, - .data = @intFromEnum(error_union_type.payload_type), + .data = @backingInt(error_union_type.payload_type), } else .{ .tag = .type_error_union, .data = try addExtra(extra, error_union_type), @@ -7372,18 +7372,18 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: .inferred_error_set_type => |ies_index| { items.appendAssumeCapacity(.{ .tag = .type_inferred_error_set, - .data = @intFromEnum(ies_index), + .data = @backingInt(ies_index), }); }, .simple_type => |simple_type| { - assert(@intFromEnum(simple_type) == items.mutate.len); + assert(@backingInt(simple_type) == items.mutate.len); items.appendAssumeCapacity(.{ .tag = .simple_type, .data = 0, // avoid writing `undefined` bits to a file }); }, .simple_value => |simple_value| { - assert(@intFromEnum(simple_value) == items.mutate.len); + assert(@backingInt(simple_value) == items.mutate.len); items.appendAssumeCapacity(.{ .tag = .simple_value, .data = 0, // avoid writing `undefined` bits to a file @@ -7393,7 +7393,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: assert(ty != .none); items.appendAssumeCapacity(.{ .tag = .undef, - .data = @intFromEnum(ty), + .data = @backingInt(ty), }); }, @@ -7535,7 +7535,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: assert(opt.val == .none or ip.indexToKey(opt.ty).opt_type == ip.typeOf(opt.val)); items.appendAssumeCapacity(if (opt.val == .none) .{ .tag = .opt_null, - .data = @intFromEnum(opt.ty), + .data = @backingInt(opt.ty), } else .{ .tag = .opt_payload, .data = try addExtra(extra, Tag.TypeValue{ @@ -7735,7 +7735,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: .enum_literal => |enum_literal| items.appendAssumeCapacity(.{ .tag = .enum_literal, - .data = @intFromEnum(enum_literal), + .data = @backingInt(enum_literal), }), .enum_tag => |enum_tag| { @@ -7849,7 +7849,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: if (len == 0) { items.appendAssumeCapacity(.{ .tag = .only_possible_value, - .data = @intFromEnum(aggregate.ty), + .data = @backingInt(aggregate.ty), }); return gop.put(); } @@ -7882,7 +7882,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: // in the aggregate fields. items.appendAssumeCapacity(.{ .tag = .only_possible_value, - .data = @intFromEnum(aggregate.ty), + .data = @backingInt(aggregate.ty), }); return gop.put(); }, @@ -7977,7 +7977,7 @@ pub fn get(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerThread.Id, key: }), }); extra.appendSliceAssumeCapacity(.{@ptrCast(aggregate.storage.elems)}); - if (sentinel != .none) extra.appendAssumeCapacity(.{@intFromEnum(sentinel)}); + if (sentinel != .none) extra.appendAssumeCapacity(.{@backingInt(sentinel)}); }, .bitpack => |bitpack| { switch (ip.zigTypeTag(bitpack.ty)) { @@ -8066,7 +8066,7 @@ pub fn getDeclaredStructType( const extra_index = addExtraAssumeCapacity(extra, Tag.TypeStructPacked{ .zir_index = ini.zir_index, .bits = .{ - .captures_len = @enumFromInt(ini.captures.len), + .captures_len = @fromBackingInt(@intCast(ini.captures.len)), .want_layout = false, }, .name = undefined, // set by `finish` @@ -8077,10 +8077,10 @@ pub fn getDeclaredStructType( .field_name_map = field_name_map, }); extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // field_name + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type if (ini.any_field_defaults) { - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_default } items.appendAssumeCapacity(.{ .tag = switch (ini.packed_backing_mode) { @@ -8138,10 +8138,10 @@ pub fn getDeclaredStructType( extra.appendAssumeCapacity(.{@intCast(ini.captures.len)}); // captures_len extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture } - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // field_name + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type if (ini.any_field_defaults) { - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_default } if (ini.any_field_aligns) { extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align @@ -8150,7 +8150,7 @@ pub fn getDeclaredStructType( extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 31) / 32); // field_is_comptime_bits } if (!is_extern) { - extra.appendNTimesAssumeCapacity(.{@intFromEnum(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len); // field_runtime_order + extra.appendNTimesAssumeCapacity(.{@backingInt(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len); // field_runtime_order } extra.appendNTimesAssumeCapacity(.{0}, ini.fields_len); // field_offset items.appendAssumeCapacity(.{ @@ -8222,12 +8222,12 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe }); _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash const field_names_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // field_name const field_types_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type const field_defaults_start = extra.mutate.len; if (ini.any_field_defaults) { - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_default } items.appendAssumeCapacity(.{ .tag = switch (ini.packed_backing_int_type) { @@ -8285,12 +8285,12 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe }); _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash const field_names_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // field_name const field_types_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type const field_defaults_start = extra.mutate.len; if (ini.any_field_defaults) { - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_default + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_default } const field_aligns_start = extra.mutate.len; if (ini.any_field_aligns) { @@ -8301,7 +8301,7 @@ pub fn getReifiedStructType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Pe extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 31) / 32); // field_is_comptime_bits } if (!is_extern) { - extra.appendNTimesAssumeCapacity(.{@intFromEnum(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len); // field_runtime_order + extra.appendNTimesAssumeCapacity(.{@backingInt(LoadedStructType.RuntimeOrder.unresolved)}, ini.fields_len); // field_runtime_order } extra.appendNTimesAssumeCapacity(.{0}, ini.fields_len); // field_offset items.appendAssumeCapacity(.{ @@ -8381,7 +8381,7 @@ pub fn getDeclaredUnionType( const extra_index = addExtraAssumeCapacity(extra, Tag.TypeUnionPacked{ .zir_index = ini.zir_index, .bits = .{ - .captures_len = @enumFromInt(ini.captures.len), + .captures_len = @fromBackingInt(@intCast(ini.captures.len)), .want_layout = false, }, .name = undefined, // set by `finish` @@ -8392,7 +8392,7 @@ pub fn getDeclaredUnionType( .fields_len = ini.fields_len, }); extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type items.appendAssumeCapacity(.{ .tag = switch (ini.packed_backing_mode) { .auto => .type_union_packed_auto, @@ -8446,7 +8446,7 @@ pub fn getDeclaredUnionType( extra.appendAssumeCapacity(.{@intCast(ini.captures.len)}); // captures_len extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture } - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type if (ini.any_field_aligns) { extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align } @@ -8516,9 +8516,9 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per }); _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash const field_names_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // reified_field_name + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // reified_field_name const field_types_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type items.appendAssumeCapacity(.{ .tag = switch (ini.packed_backing_int_type) { .none => .type_union_packed_auto, @@ -8570,9 +8570,9 @@ pub fn getReifiedUnionType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.Per }); _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); const field_names_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // reified_field_name + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // reified_field_name const field_types_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_type + extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_type const field_aligns_start = extra.mutate.len; if (ini.any_field_aligns) { extra.appendNTimesAssumeCapacity(.{0}, (ini.fields_len + 3) / 4); // field_align @@ -8657,7 +8657,7 @@ pub fn getDeclaredEnumType( const extra_index = addExtraAssumeCapacity(extra, Tag.TypeEnum{ .bits = .{ - .captures_len = @enumFromInt(ini.captures.len), + .captures_len = @fromBackingInt(@intCast(ini.captures.len)), .want_layout = false, }, .name = undefined, // set by `finish` @@ -8667,11 +8667,11 @@ pub fn getDeclaredEnumType( .fields_len = ini.fields_len, .field_name_map = field_name_map, }); - extra.appendAssumeCapacity(.{@intFromEnum(ini.zir_index)}); // zir_index + extra.appendAssumeCapacity(.{@backingInt(ini.zir_index)}); // zir_index extra.appendSliceAssumeCapacity(.{@ptrCast(ini.captures)}); // capture - if (have_values) extra.appendAssumeCapacity(.{@intFromEnum(field_value_map)}); // field_value_map - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name - if (have_values) extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_value + if (have_values) extra.appendAssumeCapacity(.{@backingInt(field_value_map)}); // field_value_map + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // field_name + if (have_values) extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_value items.appendAssumeCapacity(.{ .tag = tag, .data = extra_index, @@ -8742,13 +8742,13 @@ pub fn getReifiedEnumType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu.PerT .fields_len = ini.fields_len, .field_name_map = field_name_map, }); - extra.appendAssumeCapacity(.{@intFromEnum(ini.zir_index)}); // zir_index + extra.appendAssumeCapacity(.{@backingInt(ini.zir_index)}); // zir_index _ = addExtraAssumeCapacity(extra, PackedU64.init(ini.type_hash)); // type_hash - if (have_values) extra.appendAssumeCapacity(.{@intFromEnum(field_value_map)}); // field_value_map + if (have_values) extra.appendAssumeCapacity(.{@backingInt(field_value_map)}); // field_value_map const field_names_start = extra.mutate.len; - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // field_name const field_values_start = extra.mutate.len; - if (have_values) extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_value + if (have_values) extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_value items.appendAssumeCapacity(.{ .tag = tag, .data = extra_index, @@ -8841,10 +8841,10 @@ pub fn getGeneratedEnumTagType(ip: *InternPool, gpa: Allocator, io: Io, tid: Zcu .fields_len = ini.fields_len, .field_name_map = field_name_map, }); - extra.appendAssumeCapacity(.{@intFromEnum(ini.union_type)}); // owner_union - if (have_values) extra.appendAssumeCapacity(.{@intFromEnum(field_value_map)}); - extra.appendNTimesAssumeCapacity(.{@intFromEnum(NullTerminatedString.empty)}, ini.fields_len); // field_name - if (have_values) extra.appendNTimesAssumeCapacity(.{@intFromEnum(Index.none)}, ini.fields_len); // field_value + extra.appendAssumeCapacity(.{@backingInt(ini.union_type)}); // owner_union + if (have_values) extra.appendAssumeCapacity(.{@backingInt(field_value_map)}); + extra.appendNTimesAssumeCapacity(.{@backingInt(NullTerminatedString.empty)}, ini.fields_len); // field_name + if (have_values) extra.appendNTimesAssumeCapacity(.{@backingInt(Index.none)}, ini.fields_len); // field_value items.appendAssumeCapacity(.{ .tag = switch (ini.int_tag_mode) { .auto => .type_enum_auto, @@ -8936,8 +8936,8 @@ pub const WipContainerType = struct { ) void { const extra = ip.getLocalShared(wip.tid).extra.acquire(); const extra_items = extra.view().items(.@"0"); - extra_items[wip.type_name_index] = @intFromEnum(type_name); - extra_items[wip.name_nav_index] = @intFromEnum(name_nav); + extra_items[wip.type_name_index] = @backingInt(type_name); + extra_items[wip.name_nav_index] = @backingInt(name_nav); } pub fn finish( @@ -8948,7 +8948,7 @@ pub const WipContainerType = struct { const extra = ip.getLocalShared(wip.tid).extra.acquire(); const extra_items = extra.view().items(.@"0"); - extra_items[wip.namespace_index] = @intFromEnum(namespace); + extra_items[wip.namespace_index] = @backingInt(namespace); return wip.index; } @@ -9361,7 +9361,7 @@ pub fn getFuncDeclIes( .lbrace_column = key.lbrace_column, .rbrace_column = key.rbrace_column, }); - extra.appendAssumeCapacity(.{@intFromEnum(Index.none)}); + extra.appendAssumeCapacity(.{@backingInt(Index.none)}); const func_type_extra_index = addExtraAssumeCapacity(extra, Tag.TypeFunction{ .params_len = params_len, @@ -9391,7 +9391,7 @@ pub fn getFuncDeclIes( .error_set_type = error_set_type, .payload_type = key.bare_return_type, }), - @intFromEnum(func_index), + @backingInt(func_index), func_type_extra_index, }, }); @@ -9659,7 +9659,7 @@ fn getFuncInstanceIes( .branch_quota = 0, .generic_owner = generic_owner, }); - extra.appendAssumeCapacity(.{@intFromEnum(Index.none)}); // resolved error set + extra.appendAssumeCapacity(.{@backingInt(Index.none)}); // resolved error set extra.appendSliceAssumeCapacity(.{@ptrCast(arg.comptime_args)}); const func_type_extra_index = addExtraAssumeCapacity(extra, Tag.TypeFunction{ @@ -9690,7 +9690,7 @@ fn getFuncInstanceIes( .error_set_type = error_set_type, .payload_type = arg.bare_return_type, }), - @intFromEnum(func_index), + @backingInt(func_index), func_type_extra_index, }, }); @@ -9759,7 +9759,7 @@ fn finishFuncInstance( // TODO: improve this name const nav_name = try ip.getOrPutStringFmt(gpa, io, tid, "{f}__anon_{d}", .{ - fn_owner_nav.name.fmt(ip), @intFromEnum(func_index), + fn_owner_nav.name.fmt(ip), @backingInt(func_index), }, .no_embedded_nulls); const nav_fqn = try ip.namespacePtr(fn_namespace).internFullyQualifiedName(ip, gpa, io, tid, nav_name); const nav_index = try ip.createNav(gpa, io, tid, nav_name, nav_fqn, .{ @@ -9776,7 +9776,7 @@ fn finishFuncInstance( // Populate the owner_nav field which was left undefined until now. extra.view().items(.@"0")[ func_extra_index + std.meta.fieldIndex(Tag.FuncInstance, "owner_nav").? - ] = @intFromEnum(nav_index); + ] = @backingInt(nav_index); } pub fn getIfExists(ip: *const InternPool, key: Key) ?Index { @@ -9891,7 +9891,7 @@ fn addExtraAssumeCapacity(extra: Local.Extra.Mutable, item: anytype) u32 { TrackedInst.Index, TrackedInst.Index.Optional, ComptimeAllocIndex, - => @intFromEnum(@field(item, field_name)), + => @backingInt(@field(item, field_name)), u32, i32, @@ -9925,7 +9925,7 @@ fn addLimbsExtraAssumeCapacity(ip: *InternPool, extra: anytype) u32 { inline for (info.field_names, info.field_types, 0..) |field_name, field_type, i| { const new: u32 = switch (field_type) { u32 => @field(extra, field_name), - Index => @intFromEnum(@field(extra, field_name)), + Index => @backingInt(@field(extra, field_name)), else => @compileError("bad field type: " ++ @typeName(field_type)), }; if (i % 2 == 0) { @@ -9959,7 +9959,7 @@ fn extraDataTrail(extra: Local.Extra, comptime T: type, index: u32) struct { dat TrackedInst.Index, TrackedInst.Index.Optional, ComptimeAllocIndex, - => @enumFromInt(extra_item), + => @fromBackingInt(@intCast(extra_item)), u32, i32, @@ -10047,7 +10047,7 @@ pub fn slicePtrType(ip: *const InternPool, index: Index) Index { } const item = index.unwrap(ip).getItem(ip); switch (item.tag) { - .type_slice => return @enumFromInt(item.data), + .type_slice => return @fromBackingInt(@intCast(item.data)), else => unreachable, // not a slice type } } @@ -10135,9 +10135,9 @@ pub fn getCoerced( .func_decl => return getCoercedFuncDecl(ip, gpa, io, tid, val, new_ty), .func_instance => return getCoercedFuncInstance(ip, gpa, io, tid, val, new_ty), .func_coerced => { - const func: Index = @enumFromInt(unwrapped_val.getExtra(ip).view().items(.@"0")[ + const func: Index = @fromBackingInt(@intCast(unwrapped_val.getExtra(ip).view().items(.@"0")[ val_item.data + std.meta.fieldIndex(Tag.FuncCoerced, "func").? - ]); + ])); switch (func.unwrap(ip).getTag(ip)) { .func_decl => return getCoercedFuncDecl(ip, gpa, io, tid, func, new_ty), .func_instance => return getCoercedFuncInstance(ip, gpa, io, tid, func, new_ty), @@ -10378,9 +10378,9 @@ fn getCoercedFuncDecl( new_ty: Index, ) Allocator.Error!Index { const unwrapped_val = val.unwrap(ip); - const prev_ty: Index = @enumFromInt(unwrapped_val.getExtra(ip).view().items(.@"0")[ + const prev_ty: Index = @fromBackingInt(@intCast(unwrapped_val.getExtra(ip).view().items(.@"0")[ unwrapped_val.getData(ip) + std.meta.fieldIndex(Tag.FuncDecl, "ty").? - ]); + ])); if (new_ty == prev_ty) return val; return getCoercedFunc(ip, gpa, io, tid, val, new_ty); } @@ -10394,9 +10394,9 @@ fn getCoercedFuncInstance( new_ty: Index, ) Allocator.Error!Index { const unwrapped_val = val.unwrap(ip); - const prev_ty: Index = @enumFromInt(unwrapped_val.getExtra(ip).view().items(.@"0")[ + const prev_ty: Index = @fromBackingInt(@intCast(unwrapped_val.getExtra(ip).view().items(.@"0")[ unwrapped_val.getData(ip) + std.meta.fieldIndex(Tag.FuncInstance, "ty").? - ]); + ])); if (new_ty == prev_ty) return val; return getCoercedFunc(ip, gpa, io, tid, val, new_ty); } @@ -10739,7 +10739,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data); switch (extra.data.bits.captures_len) { .reified => n += 2, // type_hash: PackedU64 - _ => |len| n += @intFromEnum(len), // capture: CaptureValue + _ => |len| n += @backingInt(len), // capture: CaptureValue } n += extra.data.fields_len; // field_name: NullTerminatedString n += extra.data.fields_len; // field_type: Index @@ -10750,7 +10750,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo const extra = extraDataTrail(extra_list, Tag.TypeStructPacked, data); switch (extra.data.bits.captures_len) { .reified => n += 2, // type_hash: PackedU64 - _ => |len| n += @intFromEnum(len), // capture: CaptureValue + _ => |len| n += @backingInt(len), // capture: CaptureValue } n += extra.data.fields_len; // field_name: NullTerminatedString n += extra.data.fields_len; // field_type: Index @@ -10779,7 +10779,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo const extra = extraDataTrail(extra_list, Tag.TypeUnionPacked, data); switch (extra.data.bits.captures_len) { .reified => n += 2, // type_hash: PackedU64 - _ => |len| n += @intFromEnum(len), // capture: CaptureValue + _ => |len| n += @backingInt(len), // capture: CaptureValue } n += extra.data.fields_len; // field_type: Index break :b n * @sizeOf(u32); @@ -10795,7 +10795,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo }, _ => |len| { n += 1; // zir_index: TrackedInst.Index, - n += @intFromEnum(len); // capture: CaptureValue + n += @backingInt(len); // capture: CaptureValue }, } n += extra.fields_len; // field_name: NullTerminatedString @@ -10812,7 +10812,7 @@ fn dumpStatsFallible(ip: *const InternPool, w: *Io.Writer, arena: Allocator) !vo }, _ => |len| { n += 1; // zir_index: TrackedInst.Index, - n += @intFromEnum(len); // capture: CaptureValue + n += @backingInt(len); // capture: CaptureValue }, } n += 1; // field_value_map: MapIndex @@ -10931,13 +10931,13 @@ fn dumpAllFallible(ip: *const InternPool, w: *Io.Writer) anyerror!void { items.items(.data)[0..local.mutate.items.len], 0.., ) |tag, data, index| { - const i = Index.Unwrapped.wrap(.{ .tid = @enumFromInt(tid), .index = @intCast(index) }, ip); + const i = Index.Unwrapped.wrap(.{ .tid = @fromBackingInt(@intCast(tid)), .index = @intCast(index) }, ip); try w.print("${d} = {s}(", .{ i, @tagName(tag) }); switch (tag) { .removed => {}, - .simple_type => try w.print("{s}", .{@tagName(@as(SimpleType, @enumFromInt(@intFromEnum(i))))}), - .simple_value => try w.print("{s}", .{@tagName(@as(SimpleValue, @enumFromInt(@intFromEnum(i))))}), + .simple_type => try w.print("{s}", .{@tagName(@as(SimpleType, @fromBackingInt(@intCast(@backingInt(i)))))}), + .simple_value => try w.print("{s}", .{@tagName(@as(SimpleValue, @fromBackingInt(@intCast(@backingInt(i)))))}), .type_int_signed, .type_int_unsigned, @@ -11054,7 +11054,7 @@ pub fn dumpGenericInstancesFallible(ip: *const InternPool, allocator: Allocator, try gop.value_ptr.append( arena, - Index.Unwrapped.wrap(.{ .tid = @enumFromInt(tid), .index = @intCast(index) }, ip), + Index.Unwrapped.wrap(.{ .tid = @fromBackingInt(@intCast(tid)), .index = @intCast(index) }, ip), ); } } @@ -11272,10 +11272,10 @@ pub fn createNamespace( const local = ip.getLocal(tid); const free_list_next = local.mutate.namespaces.free_list; if (free_list_next != Local.BucketListMutate.free_list_sentinel) { - const reused_namespace_index: NamespaceIndex = @enumFromInt(free_list_next); + const reused_namespace_index: NamespaceIndex = @fromBackingInt(@intCast(free_list_next)); const reused_namespace = ip.namespacePtr(reused_namespace_index); local.mutate.namespaces.free_list = - @intFromEnum(@field(reused_namespace, Local.namespace_next_free_field)); + @backingInt(@field(reused_namespace, Local.namespace_next_free_field)); reused_namespace.* = initialization; return reused_namespace_index; } @@ -11314,8 +11314,8 @@ pub fn destroyNamespace( .generation = undefined, }; @field(namespace, Local.namespace_next_free_field) = - @enumFromInt(local.mutate.namespaces.free_list); - local.mutate.namespaces.free_list = @intFromEnum(namespace_index); + @fromBackingInt(@intCast(local.mutate.namespaces.free_list)); + local.mutate.namespaces.free_list = @backingInt(namespace_index); } pub fn filePtr(ip: *const InternPool, file_index: FileIndex) *Zcu.File { @@ -11424,10 +11424,10 @@ pub fn getOrPutTrailingString( try string_bytes.ensureUnusedCapacity(1); } const key: []const u8 = string_bytes.view().items(.@"0")[start..]; - const value: embedded_nulls.StringType() = @enumFromInt(@intFromEnum((String.Unwrapped{ + const value: embedded_nulls.StringType() = @fromBackingInt(@intCast(@backingInt((String.Unwrapped{ .tid = tid, .index = strings.mutate.len - 1, - }).wrap(ip))); + }).wrap(ip)))); const has_embedded_null = std.mem.indexOfScalar(u8, key, 0) != null; switch (embedded_nulls) { .no_embedded_nulls => assert(!has_embedded_null), @@ -11452,7 +11452,7 @@ pub fn getOrPutTrailingString( if (entry.hash != hash) continue; if (!index.eqlSlice(key, ip)) continue; string_bytes.shrinkRetainingCapacity(start); - return @enumFromInt(@intFromEnum(index)); + return @fromBackingInt(@intCast(@backingInt(index))); } shard.mutate.string_map.mutex.lock(io, tid); defer shard.mutate.string_map.mutex.unlock(io); @@ -11468,7 +11468,7 @@ pub fn getOrPutTrailingString( if (entry.hash != hash) continue; if (!index.eqlSlice(key, ip)) continue; string_bytes.shrinkRetainingCapacity(start); - return @enumFromInt(@intFromEnum(index)); + return @fromBackingInt(@intCast(@backingInt(index))); } defer shard.mutate.string_map.len += 1; const map_header = map.header().*; @@ -11477,7 +11477,7 @@ pub fn getOrPutTrailingString( strings.appendAssumeCapacity(.{string_bytes.mutate.len}); const entry = &map.entries[map_index]; entry.hash = hash; - entry.release(@enumFromInt(@intFromEnum(value))); + entry.release(@fromBackingInt(@intCast(@backingInt(value)))); return value; } const arena_state = &local.mutate.arena; @@ -11519,7 +11519,7 @@ pub fn getOrPutTrailingString( string_bytes.appendAssumeCapacity(.{0}); strings.appendAssumeCapacity(.{string_bytes.mutate.len}); map.entries[map_index] = .{ - .value = @enumFromInt(@intFromEnum(value)), + .value = @fromBackingInt(@intCast(@backingInt(value))), .hash = hash, }; shard.shared.string_map.release(new_map); @@ -11710,7 +11710,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index { .undef, .opt_null, .only_possible_value, - => @enumFromInt(item.data), + => @fromBackingInt(@intCast(item.data)), .simple_type, .simple_value => unreachable, // handled via Index above @@ -11742,7 +11742,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index { .bitpack, => |t| { const extra_list = unwrapped_index.getExtra(ip); - return @enumFromInt(extra_list.view().items(.@"0")[item.data + std.meta.fieldIndex(t.Payload(), "ty").?]); + return @fromBackingInt(@intCast(extra_list.view().items(.@"0")[item.data + std.meta.fieldIndex(t.Payload(), "ty").?])); }, .int_u8 => .u8_type, @@ -11788,7 +11788,7 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index { /// Assumes that the enum's field indexes equal its value tags. pub fn toEnum(ip: *const InternPool, comptime E: type, i: Index) E { const int = ip.indexToKey(i).enum_tag.int; - return @enumFromInt(ip.indexToKey(int).int.storage.u64); + return @fromBackingInt(@intCast(ip.indexToKey(int).int.storage.u64)); } pub fn toFunc(ip: *const InternPool, i: Index) Key.Func { @@ -11821,9 +11821,9 @@ pub fn funcTypeReturnType(ip: *const InternPool, ty: Index) Index { const ty_item = unwrapped_ty.getItem(ip); const child_extra, const child_item = switch (ty_item.tag) { .type_pointer => child: { - const child_index: Index = @enumFromInt(ty_extra.view().items(.@"0")[ + const child_index: Index = @fromBackingInt(@intCast(ty_extra.view().items(.@"0")[ ty_item.data + std.meta.fieldIndex(Tag.TypePointer, "child").? - ]); + ])); const unwrapped_child = child_index.unwrap(ip); break :child .{ unwrapped_child.getExtra(ip), unwrapped_child.getItem(ip) }; }, @@ -11831,9 +11831,9 @@ pub fn funcTypeReturnType(ip: *const InternPool, ty: Index) Index { else => unreachable, }; assert(child_item.tag == .type_function); - return @enumFromInt(child_extra.view().items(.@"0")[ + return @fromBackingInt(@intCast(child_extra.view().items(.@"0")[ child_item.data + std.meta.fieldIndex(Tag.TypeFunction, "return_type").? - ]); + ])); } pub fn isUndef(ip: *const InternPool, val: Index) bool { @@ -11857,12 +11857,12 @@ pub fn getBackingAddrTag(ip: *const InternPool, val: Index) ?Key.Ptr.BaseAddr.Ta .ptr_opt_payload, .ptr_elem, .ptr_field, - => |tag| base = @enumFromInt(unwrapped_base.getExtra(ip).view().items(.@"0")[ + => |tag| base = @fromBackingInt(@intCast(unwrapped_base.getExtra(ip).view().items(.@"0")[ base_item.data + std.meta.fieldIndex(tag.Payload(), "base").? - ]), - inline .ptr_slice => |tag| base = @enumFromInt(unwrapped_base.getExtra(ip).view().items(.@"0")[ + ])), + inline .ptr_slice => |tag| base = @fromBackingInt(@intCast(unwrapped_base.getExtra(ip).view().items(.@"0")[ base_item.data + std.meta.fieldIndex(tag.Payload(), "ptr").? - ]), + ])), else => return null, } } @@ -12139,7 +12139,7 @@ fn funcAnalysisPtr(ip: *const InternPool, func: Index) *FuncAnalysis { .func_instance => item.data + std.meta.fieldIndex(Tag.FuncInstance, "analysis").?, .func_coerced => { const extra_index = item.data + std.meta.fieldIndex(Tag.FuncCoerced, "func").?; - const coerced_func_index: Index = @enumFromInt(extra.view().items(.@"0")[extra_index]); + const coerced_func_index: Index = @fromBackingInt(@intCast(extra.view().items(.@"0")[extra_index])); const unwrapped_coerced_func = coerced_func_index.unwrap(ip); const coerced_func_item = unwrapped_coerced_func.getItem(ip); return @ptrCast(&unwrapped_coerced_func.getExtra(ip).view().items(.@"0")[ @@ -12201,20 +12201,20 @@ pub fn funcZirBodyInst(ip: *const InternPool, func: Index) TrackedInst.Index { const item_extra = unwrapped_func.getExtra(ip); const zir_body_inst_field_index = std.meta.fieldIndex(Tag.FuncDecl, "zir_body_inst").?; switch (item.tag) { - .func_decl => return @enumFromInt(item_extra.view().items(.@"0")[item.data + zir_body_inst_field_index]), + .func_decl => return @fromBackingInt(@intCast(item_extra.view().items(.@"0")[item.data + zir_body_inst_field_index])), .func_instance => { const generic_owner_field_index = std.meta.fieldIndex(Tag.FuncInstance, "generic_owner").?; - const func_decl_index: Index = @enumFromInt(item_extra.view().items(.@"0")[item.data + generic_owner_field_index]); + const func_decl_index: Index = @fromBackingInt(@intCast(item_extra.view().items(.@"0")[item.data + generic_owner_field_index])); const unwrapped_func_decl = func_decl_index.unwrap(ip); const func_decl_item = unwrapped_func_decl.getItem(ip); const func_decl_extra = unwrapped_func_decl.getExtra(ip); assert(func_decl_item.tag == .func_decl); - return @enumFromInt(func_decl_extra.view().items(.@"0")[func_decl_item.data + zir_body_inst_field_index]); + return @fromBackingInt(@intCast(func_decl_extra.view().items(.@"0")[func_decl_item.data + zir_body_inst_field_index])); }, .func_coerced => { - const uncoerced_func_index: Index = @enumFromInt(item_extra.view().items(.@"0")[ + const uncoerced_func_index: Index = @fromBackingInt(@intCast(item_extra.view().items(.@"0")[ item.data + std.meta.fieldIndex(Tag.FuncCoerced, "func").? - ]); + ])); return ip.funcZirBodyInst(uncoerced_func_index); }, else => unreachable, @@ -12224,7 +12224,7 @@ pub fn funcZirBodyInst(ip: *const InternPool, func: Index) TrackedInst.Index { pub fn iesFuncIndex(ip: *const InternPool, ies_index: Index) Index { const item = ies_index.unwrap(ip).getItem(ip); assert(item.tag == .type_inferred_error_set); - const func_index: Index = @enumFromInt(item.data); + const func_index: Index = @fromBackingInt(@intCast(item.data)); switch (func_index.unwrap(ip).getTag(ip)) { .func_decl, .func_instance => {}, else => unreachable, // assertion failed @@ -12244,9 +12244,9 @@ fn funcIesResolvedPtr(ip: *const InternPool, func_index: Index) *Index { .func_decl => func_item.data + @typeInfo(Tag.FuncDecl).@"struct".field_names.len, .func_instance => func_item.data + @typeInfo(Tag.FuncInstance).@"struct".field_names.len, .func_coerced => { - const uncoerced_func_index: Index = @enumFromInt(func_extra.view().items(.@"0")[ + const uncoerced_func_index: Index = @fromBackingInt(@intCast(func_extra.view().items(.@"0")[ func_item.data + std.meta.fieldIndex(Tag.FuncCoerced, "func").? - ]); + ])); const unwrapped_uncoerced_func = uncoerced_func_index.unwrap(ip); const uncoerced_func_item = unwrapped_uncoerced_func.getItem(ip); return @ptrCast(&unwrapped_uncoerced_func.getExtra(ip).view().items(.@"0")[ @@ -12294,9 +12294,9 @@ pub fn unwrapCoercedFunc(ip: *const InternPool, index: Index) Index { const unwrapped_index = index.unwrap(ip); const item = unwrapped_index.getItem(ip); return switch (item.tag) { - .func_coerced => @enumFromInt(unwrapped_index.getExtra(ip).view().items(.@"0")[ + .func_coerced => @fromBackingInt(@intCast(unwrapped_index.getExtra(ip).view().items(.@"0")[ item.data + std.meta.fieldIndex(Tag.FuncCoerced, "func").? - ]), + ])), .func_instance, .func_decl => index, else => unreachable, }; @@ -12392,7 +12392,7 @@ const GlobalErrorSet = struct { name: NullTerminatedString, ) Allocator.Error!GlobalErrorSet.Index { if (name == .empty) return .none; - const hash = std.hash.int(@intFromEnum(name)); + const hash = std.hash.int(@backingInt(name)); var map = ges.shared.map.acquire(); const Map = @TypeOf(map); var map_mask = map.header().mask(); @@ -12404,7 +12404,7 @@ const GlobalErrorSet = struct { const index = entry.acquire(); if (index == .none) break; if (entry.hash != hash) continue; - if (names.view().items(.@"0")[@intFromEnum(index) - 1] == name) return index; + if (names.view().items(.@"0")[@backingInt(index) - 1] == name) return index; } ges.mutate.map.mutex.lockUncancelable(io); defer ges.mutate.map.mutex.unlock(io); @@ -12419,7 +12419,7 @@ const GlobalErrorSet = struct { const index = entry.value; if (index == .none) break; if (entry.hash != hash) continue; - if (names.view().items(.@"0")[@intFromEnum(index) - 1] == name) return index; + if (names.view().items(.@"0")[@backingInt(index) - 1] == name) return index; } const mutable_names: Names.Mutable = .{ .gpa = gpa, @@ -12432,7 +12432,7 @@ const GlobalErrorSet = struct { const map_header = map.header().*; if (ges.mutate.names.len < map_header.capacity * 3 / 5) { mutable_names.appendAssumeCapacity(.{name}); - const index: GlobalErrorSet.Index = @enumFromInt(mutable_names.mutate.len); + const index: GlobalErrorSet.Index = @fromBackingInt(@intCast(mutable_names.mutate.len)); const entry = &map.entries[map_index]; entry.hash = hash; entry.release(index); @@ -12475,7 +12475,7 @@ const GlobalErrorSet = struct { if (map.entries[map_index].value == .none) break; } mutable_names.appendAssumeCapacity(.{name}); - const index: GlobalErrorSet.Index = @enumFromInt(mutable_names.mutate.len); + const index: GlobalErrorSet.Index = @fromBackingInt(@intCast(mutable_names.mutate.len)); map.entries[map_index] = .{ .value = index, .hash = hash }; ges.shared.map.release(new_map); return index; @@ -12486,7 +12486,7 @@ const GlobalErrorSet = struct { name: NullTerminatedString, ) ?GlobalErrorSet.Index { if (name == .empty) return .none; - const hash = std.hash.int(@intFromEnum(name)); + const hash = std.hash.int(@backingInt(name)); const map = ges.shared.map.acquire(); const map_mask = map.header().mask(); const names_items = ges.shared.names.acquire().view().items(.@"0"); @@ -12497,7 +12497,7 @@ const GlobalErrorSet = struct { const index = entry.acquire(); if (index == .none) return null; if (entry.hash != hash) continue; - if (names_items[@intFromEnum(index) - 1] == name) return index; + if (names_items[@backingInt(index) - 1] == name) return index; } } }; @@ -12509,11 +12509,11 @@ pub fn getErrorValue( tid: Zcu.PerThread.Id, name: NullTerminatedString, ) Allocator.Error!Zcu.ErrorInt { - return @intFromEnum(try ip.global_error_set.getErrorValue(gpa, io, &ip.getLocal(tid).mutate.arena, name)); + return @backingInt(try ip.global_error_set.getErrorValue(gpa, io, &ip.getLocal(tid).mutate.arena, name)); } pub fn getErrorValueIfExists(ip: *const InternPool, name: NullTerminatedString) ?Zcu.ErrorInt { - return @intFromEnum(ip.global_error_set.getErrorValueIfExists(name) orelse return null); + return @backingInt(ip.global_error_set.getErrorValueIfExists(name) orelse return null); } const PackedCallingConvention = packed struct(u18) { @@ -12544,32 +12544,32 @@ const PackedCallingConvention = packed struct(u18) { std.lang.CallingConvention.ArcInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), - .extra = @intFromEnum(pl.type), + .extra = @backingInt(pl.type), }, std.lang.CallingConvention.ArmInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), - .extra = @intFromEnum(pl.type), + .extra = @backingInt(pl.type), }, std.lang.CallingConvention.MicroblazeInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), - .extra = @intFromEnum(pl.type), + .extra = @backingInt(pl.type), }, std.lang.CallingConvention.MipsInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), - .extra = @intFromEnum(pl.mode), + .extra = @backingInt(pl.mode), }, std.lang.CallingConvention.RiscvInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), - .extra = @intFromEnum(pl.mode), + .extra = @backingInt(pl.mode), }, std.lang.CallingConvention.ShInterruptOptions => .{ .tag = tag, .incoming_stack_alignment = .fromByteUnits(pl.incoming_stack_alignment orelse 0), - .extra = @intFromEnum(pl.save), + .extra = @backingInt(pl.save), }, std.lang.CallingConvention.SpirvKernelOptions => .{ .tag = tag, @@ -12579,12 +12579,12 @@ const PackedCallingConvention = packed struct(u18) { std.lang.CallingConvention.SpirvFragmentOptions => .{ .tag = tag, .incoming_stack_alignment = .none, - .extra = @as(u4, @intFromEnum(pl.depth_assumption)) << 1 | @intFromBool(pl.pixel_centered_integer), + .extra = @as(u4, @backingInt(pl.depth_assumption)) << 1 | @intFromBool(pl.pixel_centered_integer), }, std.lang.CallingConvention.SpirvMeshOptions => .{ .tag = tag, .incoming_stack_alignment = .none, - .extra = @intFromEnum(pl.stage_output), + .extra = @backingInt(pl.stage_output), }, else => comptime unreachable, }, @@ -12615,27 +12615,27 @@ const PackedCallingConvention = packed struct(u18) { }, std.lang.CallingConvention.ArcInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), - .type = @enumFromInt(cc.extra), + .type = @fromBackingInt(@intCast(cc.extra)), }, std.lang.CallingConvention.ArmInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), - .type = @enumFromInt(cc.extra), + .type = @fromBackingInt(@intCast(cc.extra)), }, std.lang.CallingConvention.MicroblazeInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), - .type = @enumFromInt(cc.extra), + .type = @fromBackingInt(@intCast(cc.extra)), }, std.lang.CallingConvention.MipsInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), - .mode = @enumFromInt(cc.extra), + .mode = @fromBackingInt(@intCast(cc.extra)), }, std.lang.CallingConvention.RiscvInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), - .mode = @enumFromInt(cc.extra), + .mode = @fromBackingInt(@intCast(cc.extra)), }, std.lang.CallingConvention.ShInterruptOptions => .{ .incoming_stack_alignment = cc.incoming_stack_alignment.toByteUnits(), - .save = @enumFromInt(cc.extra), + .save = @fromBackingInt(@intCast(cc.extra)), }, std.lang.CallingConvention.SpirvKernelOptions => .{ .x = trailing[0], @@ -12644,10 +12644,10 @@ const PackedCallingConvention = packed struct(u18) { }, std.lang.CallingConvention.SpirvFragmentOptions => .{ .pixel_centered_integer = @bitCast(@as(u1, @truncate(cc.extra))), - .depth_assumption = @enumFromInt(@as(u2, @truncate(cc.extra >> 1))), + .depth_assumption = @fromBackingInt(@intCast(@as(u2, @truncate(cc.extra >> 1)))), }, std.lang.CallingConvention.SpirvMeshOptions => .{ - .stage_output = @enumFromInt(cc.extra), + .stage_output = @fromBackingInt(@intCast(cc.extra)), .max_primitives = trailing[0], .max_vertices = trailing[1], }, @@ -12713,7 +12713,7 @@ pub fn resolveUnionLayout( const item = unwrapped_index.getItem(ip); assert(item.tag == .type_union); - extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "enum_tag_type").?] = @intFromEnum(enum_tag_type); + extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "enum_tag_type").?] = @backingInt(enum_tag_type); extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "size").?] = size; extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "padding").?] = padding; const flags: *Tag.TypeUnion.Flags = @ptrCast(&extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnion, "flags").?]); @@ -12746,7 +12746,7 @@ pub fn resolvePackedStructLayout( else => unreachable, } - extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "backing_int_type").?] = @intFromEnum(backing_int_type); + extra_items[item.data + std.meta.fieldIndex(Tag.TypeStructPacked, "backing_int_type").?] = @backingInt(backing_int_type); } /// Asserts that `union_type` is a packed union type. @@ -12772,8 +12772,8 @@ pub fn resolvePackedUnionLayout( else => unreachable, } - extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "enum_tag_type").?] = @intFromEnum(enum_tag_type); - extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "backing_int_type").?] = @intFromEnum(backing_int_type); + extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "enum_tag_type").?] = @backingInt(enum_tag_type); + extra_items[item.data + std.meta.fieldIndex(Tag.TypeUnionPacked, "backing_int_type").?] = @backingInt(backing_int_type); } /// Asserts that `enum_type` is an enum type. @@ -12799,7 +12799,7 @@ pub fn resolveEnumLayout( else => unreachable, } - extra_items[item.data + std.meta.fieldIndex(Tag.TypeEnum, "int_tag_type").?] = @intFromEnum(int_tag_type); + extra_items[item.data + std.meta.fieldIndex(Tag.TypeEnum, "int_tag_type").?] = @backingInt(int_tag_type); } /// Sets the "want_layout" flag on the given struct, union, or enum type. Returns true if the flag diff --git a/src/Module.zig b/src/Module.zig index b0d212070bd298f6d4980eddb4fe32a9fd43b363..c351d9eaf4bb29baa41306fa0b80cf3f42276e08 100644 --- a/src/Module.zig +++ b/src/Module.zig @@ -353,11 +353,11 @@ pub fn create(arena: Allocator, options: CreateOptions) !*Module { // See https://github.com/ziglang/zig/issues/23539 if (target_util.isDynamicAMDGCNFeature(target, feature)) continue; - if (target.cpu.arch.isPowerPC() and @as(std.Target.powerpc.Feature, @enumFromInt(feature.index)) == .@"64bit") continue; - if (target.cpu.arch.isX86() and @as(std.Target.x86.Feature, @enumFromInt(feature.index)) == .x32) continue; + if (target.cpu.arch.isPowerPC() and @as(std.Target.powerpc.Feature, @fromBackingInt(@intCast(feature.index))) == .@"64bit") continue; + if (target.cpu.arch.isX86() and @as(std.Target.x86.Feature, @fromBackingInt(@intCast(feature.index))) == .x32) continue; var is_enabled = target.cpu.features.isEnabled(feature.index); - if (target.cpu.arch == .s390x and @as(std.Target.s390x.Feature, @enumFromInt(feature.index)) == .backchain) { + if (target.cpu.arch == .s390x and @as(std.Target.s390x.Feature, @fromBackingInt(@intCast(feature.index))) == .backchain) { is_enabled = !omit_frame_pointer; } diff --git a/src/Sema.zig b/src/Sema.zig index e20dfdc99c595493ab66ebc23265bd75553cac2f..20df87823ce2703925d26d0f5e7020415b00d7ce 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -142,7 +142,7 @@ const RuntimeIndex = enum(u32) { _, pub fn increment(ri: *RuntimeIndex) void { - ri.* = @enumFromInt(@intFromEnum(ri.*) + 1); + ri.* = @fromBackingInt(@intCast(@backingInt(ri.*) + 1)); } }; @@ -191,11 +191,11 @@ fn newComptimeAlloc(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type, align .alignment = alignment, .runtime_index = block.runtime_index, }); - return @enumFromInt(idx); + return @fromBackingInt(@intCast(idx)); } pub fn getComptimeAlloc(sema: *Sema, idx: ComptimeAllocIndex) *ComptimeAlloc { - return &sema.comptime_allocs.items[@intFromEnum(idx)]; + return &sema.comptime_allocs.items[@backingInt(idx)]; } pub const default_branch_quota = 1000; @@ -253,7 +253,7 @@ pub const InferredErrorSet = struct { /// be called safely for any of the instructions passed in. pub const InstMap = struct { items: []Air.Inst.Ref = &[_]Air.Inst.Ref{}, - start: Zir.Inst.Index = @enumFromInt(0), + start: Zir.Inst.Index = @fromBackingInt(@intCast(0)), pub fn deinit(map: InstMap, allocator: mem.Allocator) void { allocator.free(map.items); @@ -261,7 +261,7 @@ pub const InstMap = struct { pub fn get(map: InstMap, key: Zir.Inst.Index) ?Air.Inst.Ref { if (!map.contains(key)) return null; - return map.items[@intFromEnum(key) - @intFromEnum(map.start)]; + return map.items[@backingInt(key) - @backingInt(map.start)]; } pub fn putAssumeCapacity( @@ -269,7 +269,7 @@ pub const InstMap = struct { key: Zir.Inst.Index, ref: Air.Inst.Ref, ) void { - map.items[@intFromEnum(key) - @intFromEnum(map.start)] = ref; + map.items[@backingInt(key) - @backingInt(map.start)] = ref; } pub fn putAssumeCapacityNoClobber( @@ -290,7 +290,7 @@ pub const InstMap = struct { map: *InstMap, key: Zir.Inst.Index, ) GetOrPutResult { - const index = @intFromEnum(key) - @intFromEnum(map.start); + const index = @backingInt(key) - @backingInt(map.start); return GetOrPutResult{ .value_ptr = &map.items[index], .found_existing = map.items[index] != .none, @@ -299,12 +299,12 @@ pub const InstMap = struct { pub fn remove(map: InstMap, key: Zir.Inst.Index) bool { if (!map.contains(key)) return false; - map.items[@intFromEnum(key) - @intFromEnum(map.start)] = .none; + map.items[@backingInt(key) - @backingInt(map.start)] = .none; return true; } pub fn contains(map: InstMap, key: Zir.Inst.Index) bool { - return map.items[@intFromEnum(key) - @intFromEnum(map.start)] != .none; + return map.items[@backingInt(key) - @backingInt(map.start)] != .none; } pub fn ensureSpaceForInstructions( @@ -313,7 +313,7 @@ pub const InstMap = struct { insts: []const Zir.Inst.Index, ) !void { const start, const end = mem.minMax(u32, @ptrCast(insts)); - const map_start = @intFromEnum(map.start); + const map_start = @backingInt(map.start); if (map_start <= start and end < map.items.len + map_start) return; @@ -336,7 +336,7 @@ pub const InstMap = struct { allocator.free(map.items); map.items = new_items; - map.start = @enumFromInt(better_start); + map.start = @fromBackingInt(@intCast(better_start)); } }; @@ -814,7 +814,7 @@ pub const Block = struct { try sema.air_instructions.ensureUnusedCapacity(gpa, 1); try block.instructions.ensureUnusedCapacity(gpa, 1); - const result_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const result_index: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); sema.air_instructions.appendAssumeCapacity(inst); block.instructions.appendAssumeCapacity(result_index); return result_index; @@ -832,10 +832,10 @@ pub const Block = struct { try sema.air_instructions.ensureUnusedCapacity(gpa, 1); - const result_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const result_index: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); sema.air_instructions.appendAssumeCapacity(inst); - try block.instructions.insert(gpa, @intFromEnum(index), result_index); + try block.instructions.insert(gpa, @backingInt(index), result_index); return result_index; } @@ -1020,7 +1020,7 @@ fn analyzeBodyRuntimeBreak(sema: *Sema, block: *Block, body: []const Zir.Inst.In sema.analyzeBodyInner(block, body) catch |err| switch (err) { error.ComptimeBreak => { const zir_datas = sema.code.instructions.items(.data); - const break_data = zir_datas[@intFromEnum(sema.comptime_break_inst)].@"break"; + const break_data = zir_datas[@backingInt(sema.comptime_break_inst)].@"break"; const extra = sema.code.extraData(Zir.Inst.Break, break_data.payload_index).data; try sema.addRuntimeBreak(block, extra.block_inst, break_data.operand); }, @@ -1061,7 +1061,7 @@ fn analyzeInlineBody( error.ComptimeBreak => {}, else => |e| return e, } - const break_inst = sema.code.instructions.get(@intFromEnum(sema.comptime_break_inst)); + const break_inst = sema.code.instructions.get(@backingInt(sema.comptime_break_inst)); switch (break_inst.tag) { .switch_continue => { // This is handled by separate logic. @@ -1145,7 +1145,7 @@ fn analyzeBodyInner( }, inst }); } - const air_ref: Air.Inst.Ref = inst: switch (tags[@intFromEnum(inst)]) { + const air_ref: Air.Inst.Ref = inst: switch (tags[@backingInt(inst)]) { // zig fmt: off .alloc => try sema.zirAlloc(block, inst), .alloc_inferred => try sema.zirAllocInferred(block, true), @@ -1373,7 +1373,7 @@ fn analyzeBodyInner( .declaration => unreachable, .extended => ext: { - const extended = datas[@intFromEnum(inst)].extended; + const extended = datas[@backingInt(inst)].extended; break :ext switch (extended.opcode) { // zig fmt: off .struct_decl => try sema.zirStructDecl( block, inst), @@ -1624,7 +1624,7 @@ fn analyzeBodyInner( }, .check_comptime_control_flow => { if (!block.isComptime()) { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const inline_block = inst_data.operand.toIndex().?; @@ -1636,7 +1636,7 @@ fn analyzeBodyInner( check_block = check_block.parent.?; }; - if (@intFromEnum(target_runtime_index) < @intFromEnum(block.runtime_index)) { + if (@backingInt(target_runtime_index) < @backingInt(block.runtime_index)) { const runtime_src = block.runtime_cond orelse block.runtime_loop.?; const msg = msg: { const msg = try sema.errMsg(src, "comptime control flow inside runtime block", .{}); @@ -1656,13 +1656,13 @@ fn analyzeBodyInner( continue; }, .restore_err_ret_index_unconditional => { - const un_node = datas[@intFromEnum(inst)].un_node; + const un_node = datas[@backingInt(inst)].un_node; try sema.restoreErrRetIndex(block, block.nodeOffset(un_node.src_node), un_node.operand, .none); i += 1; continue; }, .restore_err_ret_index_fn_entry => { - const un_node = datas[@intFromEnum(inst)].un_node; + const un_node = datas[@backingInt(inst)].un_node; try sema.restoreErrRetIndex(block, block.nodeOffset(un_node.src_node), .none, un_node.operand); i += 1; continue; @@ -1685,7 +1685,7 @@ fn analyzeBodyInner( .repeat => { if (block.isComptime()) { // Send comptime control flow back to the beginning of this block. - const src = block.nodeOffset(datas[@intFromEnum(inst)].node); + const src = block.nodeOffset(datas[@backingInt(inst)].node); try sema.emitBackwardBranch(block, src); i = 0; continue; @@ -1700,7 +1700,7 @@ fn analyzeBodyInner( }, .repeat_inline => { // Send comptime control flow back to the beginning of this block. - const src = block.nodeOffset(datas[@intFromEnum(inst)].node); + const src = block.nodeOffset(datas[@backingInt(inst)].node); try sema.emitBackwardBranch(block, src); i = 0; continue; @@ -1722,7 +1722,7 @@ fn analyzeBodyInner( } else try sema.zirBlock(block, inst), .block_comptime => { - const pl_node = datas[@intFromEnum(inst)].pl_node; + const pl_node = datas[@backingInt(inst)].pl_node; const src = block.nodeOffset(pl_node.src_node); const extra = sema.code.extraData(Zir.Inst.BlockComptime, pl_node.payload_index); const block_body = sema.code.bodySlice(extra.end, extra.data.body_len); @@ -1760,7 +1760,7 @@ fn analyzeBodyInner( // through a runtime conditional branch, we must retroactively emit // a block, so we remember the block index here just in case. const block_index = block.instructions.items.len; - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index); const inline_body = sema.code.bodySlice(extra.end, extra.data.body_len); const gpa = sema.gpa; @@ -1780,7 +1780,7 @@ fn analyzeBodyInner( // If this block contains a function prototype, we need to reset the // current list of parameters and restore it later. // Note: this probably needs to be resolved in a more general manner. - const tag_index = @intFromEnum(inline_body[inline_body.len - 1]); + const tag_index = @backingInt(inline_body[inline_body.len - 1]); child_block.inline_block = (if (tags[tag_index] == .repeat_inline) inline_body[0] else @@ -1801,7 +1801,7 @@ fn analyzeBodyInner( } else |err| switch (err) { error.ComptimeBreak => brk_res: { const break_inst = sema.comptime_break_inst; - const break_data = sema.code.instructions.items(.data)[@intFromEnum(break_inst)].@"break"; + const break_data = sema.code.instructions.items(.data)[@backingInt(break_inst)].@"break"; const break_extra = sema.code.extraData(Zir.Inst.Break, break_data.payload_index).data; break :brk_res .{ .block_inst = break_extra.block_inst, @@ -1869,7 +1869,7 @@ fn analyzeBodyInner( break; }, .condbr_inline => { - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const cond_src = block.src(.{ .node_offset_if_cond = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.CondBr, inst_data.payload_index); const then_body = sema.code.bodySlice(extra.end, extra.data.then_body_len); @@ -1898,7 +1898,7 @@ fn analyzeBodyInner( }, .@"try" => blk: { if (!block.isComptime()) break :blk try sema.zirTry(block, inst); - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.src(.{ .node_offset_try_operand = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index); @@ -1924,7 +1924,7 @@ fn analyzeBodyInner( }, .try_ptr => blk: { if (!block.isComptime()) break :blk try sema.zirTryPtr(block, inst); - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.src(.{ .node_offset_try_operand = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index); @@ -1940,7 +1940,7 @@ fn analyzeBodyInner( break :blk result; }, .@"defer" => blk: { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].@"defer"; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].@"defer"; const defer_body = sema.code.bodySlice(inst_data.index, inst_data.len); if (sema.analyzeBodyInner(block, defer_body)) { // The defer terminated noreturn - no more analysis needed. @@ -1956,7 +1956,7 @@ fn analyzeBodyInner( }, }; - const is_inferred_alloc = if (air_ref.toIndex()) |air_inst| switch (sema.air_instructions.items(.tag)[@intFromEnum(air_inst)]) { + const is_inferred_alloc = if (air_ref.toIndex()) |air_inst| switch (sema.air_instructions.items(.tag)[@backingInt(air_inst)]) { .inferred_alloc, .inferred_alloc_comptime => true, else => false, } else false; @@ -1998,7 +1998,7 @@ fn resolveInst(sema: *Sema, zir_ref: Zir.Inst.Ref) Air.Inst.Ref { } // First section of indexes correspond to a set number of constant values. // We intentionally map the same indexes to the same values between ZIR and AIR. - return @enumFromInt(@intFromEnum(zir_ref)); + return @fromBackingInt(@intCast(@backingInt(zir_ref))); } fn resolveConstBool( @@ -2130,29 +2130,29 @@ fn genericPoisonReason(sema: *Sema, block: *Block, ref: Zir.Inst.Ref) GenericPoi var cur = ref; while (true) { const inst = cur.toIndex() orelse return .unknown; - switch (sema.code.instructions.items(.tag)[@intFromEnum(inst)]) { + switch (sema.code.instructions.items(.tag)[@backingInt(inst)]) { .validate_array_init_ref_ty => { - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.ArrayInitRefTy, pl_node.payload_index).data; cur = extra.ptr_ty; }, .array_init_elem_type => { - const bin = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin; + const bin = sema.code.instructions.items(.data)[@backingInt(inst)].bin; cur = bin.lhs; }, .indexable_ptr_elem_type, .splat_op_result_ty => { - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; cur = un_node.operand; }, .struct_init_field_type => { - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.FieldType, pl_node.payload_index).data; cur = extra.container_type; }, .elem_type => { // There are two cases here: the pointer type may already have been // generic poison, or it may have been an anyopaque pointer. - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_ref = sema.resolveInst(un_node.operand); const operand_val = operand_ref.toInterned() orelse return .unknown; if (operand_val == .generic_poison_type) { @@ -2167,7 +2167,7 @@ fn genericPoisonReason(sema: *Sema, block: *Block, ref: Zir.Inst.Ref) GenericPoi // A function call can never return generic poison, so we must be // evaluating an `anytype` function parameter. // TODO: better source location - function decl rather than call - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; return .{ .anytype_param = block.nodeOffset(pl_node.src_node) }; }, else => return .unknown, @@ -2242,7 +2242,7 @@ fn resolveValue(sema: *Sema, inst: Air.Inst.Ref) ?Value { // Runtime-known value. We'll be returning `null`, but first, some assertions. const air_tags = sema.air_instructions.items(.tag); - switch (air_tags[@intFromEnum(inst.toIndex().?)]) { + switch (air_tags[@backingInt(inst.toIndex().?)]) { .inferred_alloc => unreachable, // assertion failure .inferred_alloc_comptime => unreachable, // assertion failure else => {}, @@ -3043,7 +3043,7 @@ fn zirErrorSetDecl( const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.ErrorSetDecl, inst_data.payload_index); var names: InferredErrorSet.NameMap = .{}; @@ -3052,7 +3052,7 @@ fn zirErrorSetDecl( var extra_index: u32 = @intCast(extra.end); const extra_index_end = extra_index + extra.data.fields_len; while (extra_index < extra_index_end) : (extra_index += 1) { - const name_index: Zir.NullTerminatedString = @enumFromInt(sema.code.extra[extra_index]); + const name_index: Zir.NullTerminatedString = @fromBackingInt(@intCast(sema.code.extra[extra_index])); const name = sema.code.nullTerminatedString(name_index); const name_ip = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, name, .no_embedded_nulls); _ = try pt.getErrorValue(name_ip); @@ -3067,7 +3067,7 @@ fn zirRetPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. const pt = sema.pt; const zcu = pt.zcu; - const src = block.nodeOffset(sema.code.instructions.items(.data)[@intFromEnum(inst)].node); + const src = block.nodeOffset(sema.code.instructions.items(.data)[@backingInt(inst)].node); if (block.isComptime() or sema.fn_ret_ty.comptimeOnly(zcu)) { return sema.analyzeComptimeAlloc(block, src, sema.fn_ret_ty, .none); @@ -3090,13 +3090,13 @@ fn zirRetPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. } fn zirRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_tok; const operand = sema.resolveInst(inst_data.operand); return sema.analyzeRef(block, block.tokenOffset(inst_data.src_tok), operand, .none); } fn zirDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ptr_src = block.src(.{ .node_offset_deref_ptr = inst_data.src_node }); const operand = sema.resolveInst(inst_data.operand); @@ -3109,7 +3109,7 @@ fn zirDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I fn zirRefDeref(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -3169,7 +3169,7 @@ fn validateDeref( } fn zirEnsureResultUsed(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand = sema.resolveInst(inst_data.operand); const src = block.nodeOffset(inst_data.src_node); @@ -3212,7 +3212,7 @@ fn ensureResultUsed( fn zirEnsureResultNonError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand = sema.resolveInst(inst_data.operand); const src = block.nodeOffset(inst_data.src_node); const operand_ty = sema.typeOf(operand); @@ -3234,7 +3234,7 @@ fn zirEnsureResultNonError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com fn zirEnsureErrUnionPayloadVoid(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -3256,7 +3256,7 @@ fn zirEnsureErrUnionPayloadVoid(sema: *Sema, block: *Block, inst: Zir.Inst.Index } fn zirIndexablePtrLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const object = sema.resolveInst(inst_data.operand); @@ -3320,13 +3320,13 @@ fn zirAllocExtended( var extra_index: usize = extra.end; const var_ty: Type = if (small.has_type) blk: { - const type_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); + const type_ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_index])); extra_index += 1; break :blk try sema.resolveType(block, ty_src, type_ref); } else undefined; const alignment = if (small.has_align) blk: { - const align_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); + const align_ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_index])); extra_index += 1; break :blk try sema.resolveAlign(block, align_src, align_ref); } else .none; @@ -3361,7 +3361,7 @@ fn zirAllocExtended( } if (block.isComptime() or small.is_comptime) { - const iac_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const iac_index: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = .inferred_alloc_comptime, .data = .{ .inferred_alloc_comptime = .{ @@ -3389,7 +3389,7 @@ fn zirAllocExtended( } fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node }); const var_src = block.nodeOffset(inst_data.src_node); const var_ty = try sema.resolveType(block, ty_src, inst_data.operand); @@ -3400,7 +3400,7 @@ fn zirAllocComptime(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr fn zirMakePtrConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const alloc = sema.resolveInst(inst_data.operand); const alloc_ty = sema.typeOf(alloc); const ptr_info = alloc_ty.ptrInfo(zcu); @@ -3502,7 +3502,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref, simple: { if (stores.len != 1) break :simple; - const store_inst = sema.air_instructions.get(@intFromEnum(stores[0])); + const store_inst = sema.air_instructions.get(@backingInt(stores[0])); switch (store_inst.tag) { .store, .store_safe => {}, .set_union_tag, .optional_payload_ptr_set, .errunion_payload_ptr_set => break :simple, // there's OPV stuff going on! @@ -3536,7 +3536,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref, var to_map = try std.array_list.Managed(Air.Inst.Index).initCapacity(sema.arena, stores.len); for (stores) |store_inst_idx| { - const store_inst = sema.air_instructions.get(@intFromEnum(store_inst_idx)); + const store_inst = sema.air_instructions.get(@backingInt(store_inst_idx)); const ptr_to_map = switch (store_inst.tag) { .store, .store_safe => store_inst.data.bin_op.lhs.toIndex().?, // Map the pointer being stored to. .set_union_tag => store_inst.data.bin_op.lhs.toIndex().?, // Map the union pointer. @@ -3557,12 +3557,12 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref, field: u32, elem: u64, }; - const inst_tag = tmp_air.instructions.items(.tag)[@intFromEnum(air_ptr)]; + const inst_tag = tmp_air.instructions.items(.tag)[@backingInt(air_ptr)]; const air_parent_ptr: Air.Inst.Ref, const method: PointerMethod = switch (inst_tag) { .struct_field_ptr => blk: { const data = tmp_air.extraData( Air.StructField, - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_pl.payload, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_pl.payload, ).data; break :blk .{ data.struct_operand, @@ -3574,7 +3574,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref, .struct_field_ptr_index_2, .struct_field_ptr_index_3, => .{ - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_op.operand, .{ .field = switch (inst_tag) { .struct_field_ptr_index_0 => 0, .struct_field_ptr_index_1 => 1, @@ -3584,17 +3584,17 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref, } }, }, .ptr_slice_ptr_ptr => .{ - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_op.operand, .{ .field = Value.slice_ptr_index }, }, .ptr_slice_len_ptr => .{ - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_op.operand, .{ .field = Value.slice_len_index }, }, .ptr_elem_ptr => blk: { const data = tmp_air.extraData( Air.Bin, - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_pl.payload, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_pl.payload, ).data; const idx_val = sema.resolveValue(data.rhs).?; break :blk .{ @@ -3603,15 +3603,15 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref, }; }, .ptr_cast => .{ - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_op.operand, .same_addr, }, .optional_payload_ptr_set => .{ - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_op.operand, .opt_payload, }, .errunion_payload_ptr_set => .{ - tmp_air.instructions.items(.data)[@intFromEnum(air_ptr)].ty_op.operand, + tmp_air.instructions.items(.data)[@backingInt(air_ptr)].ty_op.operand, .eu_payload, }, else => unreachable, @@ -3688,7 +3688,7 @@ fn resolveComptimeKnownAllocPtr(sema: *Sema, block: *Block, alloc: Air.Inst.Ref, // instructions were already done above. for (stores) |store_inst_idx| { - const store_inst = sema.air_instructions.get(@intFromEnum(store_inst_idx)); + const store_inst = sema.air_instructions.get(@backingInt(store_inst_idx)); switch (store_inst.tag) { .optional_payload_ptr_set, .errunion_payload_ptr_set => {}, // Handled explicitly above .set_union_tag => { @@ -3750,9 +3750,9 @@ fn finishResolveComptimeKnownAllocPtr( .operand = .zero_usize, } } }; - sema.air_instructions.set(@intFromEnum(alloc_inst), nop_inst); + sema.air_instructions.set(@backingInt(alloc_inst), nop_inst); for (comptime_info.stores.items(.inst)) |store_inst| { - sema.air_instructions.set(@intFromEnum(store_inst), nop_inst); + sema.air_instructions.set(@backingInt(store_inst), nop_inst); } if (Value.fromInterned(result_val).canMutateComptimeVarState(zcu)) { @@ -3812,14 +3812,14 @@ fn zirAllocInferredComptime( .ptr = undefined, } }, }); - return @as(Air.Inst.Index, @enumFromInt(sema.air_instructions.len - 1)).toRef(); + return @as(Air.Inst.Index, @fromBackingInt(@intCast(sema.air_instructions.len - 1))).toRef(); } fn zirAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node }); const var_src = block.nodeOffset(inst_data.src_node); @@ -3848,7 +3848,7 @@ fn zirAllocMut(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node }); const var_src = block.nodeOffset(inst_data.src_node); @@ -3886,7 +3886,7 @@ fn zirAllocInferred( .ptr = undefined, } }, }); - return @as(Air.Inst.Index, @enumFromInt(sema.air_instructions.len - 1)).toRef(); + return @as(Air.Inst.Index, @fromBackingInt(@intCast(sema.air_instructions.len - 1))).toRef(); } const result_index = try block.addInstAsIndex(.{ @@ -3908,24 +3908,24 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com const pt = sema.pt; const zcu = pt.zcu; const gpa = sema.gpa; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ty_src = block.src(.{ .node_offset_var_decl_ty = inst_data.src_node }); const ptr = sema.resolveInst(inst_data.operand); const ptr_inst = ptr.toIndex().?; const target = zcu.getTarget(); - switch (sema.air_instructions.items(.tag)[@intFromEnum(ptr_inst)]) { + switch (sema.air_instructions.items(.tag)[@backingInt(ptr_inst)]) { .inferred_alloc_comptime => { // The work was already done for us by `Sema.storeToInferredAllocComptime`. Also, since // we had a value of the exact correct type to store, the result type's layout must be // already resolved. So all we need to do here is return the pointer. - const iac = sema.air_instructions.items(.data)[@intFromEnum(ptr_inst)].inferred_alloc_comptime; + const iac = sema.air_instructions.items(.data)[@backingInt(ptr_inst)].inferred_alloc_comptime; const resolved_ptr = iac.ptr; if (std.debug.runtime_safety) { // The inferred_alloc_comptime should never be referenced again - sema.air_instructions.set(@intFromEnum(ptr_inst), .{ .tag = undefined, .data = undefined }); + sema.air_instructions.set(@backingInt(ptr_inst), .{ .tag = undefined, .data = undefined }); } const val = switch (zcu.intern_pool.indexToKey(resolved_ptr).ptr.base_addr) { @@ -3948,12 +3948,12 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com return Air.internedToRef(resolved_ptr); }, .inferred_alloc => { - const ia1 = sema.air_instructions.items(.data)[@intFromEnum(ptr_inst)].inferred_alloc; + const ia1 = sema.air_instructions.items(.data)[@backingInt(ptr_inst)].inferred_alloc; const ia2 = sema.unresolved_inferred_allocs.fetchSwapRemove(ptr_inst).?.value; const peer_vals = try sema.arena.alloc(Air.Inst.Ref, ia2.prongs.items.len); for (peer_vals, ia2.prongs.items) |*peer_val, store_inst| { - assert(sema.air_instructions.items(.tag)[@intFromEnum(store_inst)] == .store); - const bin_op = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op; + assert(sema.air_instructions.items(.tag)[@backingInt(store_inst)] == .store); + const bin_op = sema.air_instructions.items(.data)[@backingInt(store_inst)].bin_op; peer_val.* = bin_op.rhs; } const final_elem_ty = try sema.resolvePeerTypes(block, ty_src, peer_vals, .none); @@ -3988,7 +3988,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com return sema.fail(block, mut_src, "local variable in naked function", .{}); } // Change it to a normal alloc. - sema.air_instructions.set(@intFromEnum(ptr_inst), .{ + sema.air_instructions.set(@backingInt(ptr_inst), .{ .tag = .alloc, .data = .{ .ty = final_ptr_ty }, }); @@ -4000,15 +4000,15 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com var replacement_block = block.makeSubBlock(); defer replacement_block.instructions.deinit(gpa); - assert(sema.air_instructions.items(.tag)[@intFromEnum(placeholder_inst)] == .store); - const bin_op = sema.air_instructions.items(.data)[@intFromEnum(placeholder_inst)].bin_op; + assert(sema.air_instructions.items(.tag)[@backingInt(placeholder_inst)] == .store); + const bin_op = sema.air_instructions.items(.data)[@backingInt(placeholder_inst)].bin_op; try sema.storePtr2(&replacement_block, src, bin_op.lhs, src, bin_op.rhs, src, .store); // If only one instruction is produced then we can replace the store // placeholder instruction with this instruction; no need for an entire block. if (replacement_block.instructions.items.len == 1) { const only_inst = replacement_block.instructions.items[0]; - sema.air_instructions.set(@intFromEnum(placeholder_inst), sema.air_instructions.get(@intFromEnum(only_inst))); + sema.air_instructions.set(@backingInt(placeholder_inst), sema.air_instructions.get(@backingInt(only_inst))); continue; } @@ -4019,7 +4019,7 @@ fn zirResolveInferredAlloc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com gpa, @typeInfo(Air.Block).@"struct".field_names.len + replacement_block.instructions.items.len, ); - sema.air_instructions.set(@intFromEnum(placeholder_inst), .{ + sema.air_instructions.set(@backingInt(placeholder_inst), .{ .tag = .block, .data = .{ .ty_pl = .{ .ty = .void_type, @@ -4049,7 +4049,7 @@ fn zirForLen(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index); const all_args = sema.code.refSlice(extra.end, extra.data.operands_len); const arg_pairs: []const [2]Zir.Inst.Ref = @as([*]const [2]Zir.Inst.Ref, @ptrCast(all_args))[0..@divExact(all_args.len, 2)]; @@ -4202,7 +4202,7 @@ fn optEuBasePtrInit(sema: *Sema, block: *Block, ptr: Air.Inst.Ref, src: LazySrcL } fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const ptr = sema.resolveInst(un_node.operand); const src = block.nodeOffset(un_node.src_node); try sema.ensureLayoutResolved(sema.typeOf(ptr).childType(sema.pt.zcu), src, .init); @@ -4212,7 +4212,7 @@ fn zirOptEuBasePtrInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile fn zirCoercePtrElemTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(pl_node.src_node); const extra = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data; const uncoerced_val = sema.resolveInst(extra.rhs); @@ -4265,7 +4265,7 @@ fn zirTryOperandTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is_ref: boo const gpa = comp.gpa; const io = comp.io; - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(un_node.src_node); const operand_ty = try sema.resolveTypeOrPoison(block, src, un_node.operand) orelse return .generic_poison_type; @@ -4311,7 +4311,7 @@ fn zirTryOperandTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is_ref: boo fn zirValidateRefTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const un_tok = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok; + const un_tok = sema.code.instructions.items(.data)[@backingInt(inst)].un_tok; const src = block.tokenOffset(un_tok.src_tok); // In case of GenericPoison, we don't actually have a type, so this will be // treated as an untyped address-of operator. @@ -4329,7 +4329,7 @@ fn zirValidateRefTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr fn zirValidateConst(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { if (!block.isComptime()) return; - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(un_node.src_node); const init_ref = sema.resolveInst(un_node.operand); if (!try sema.isComptimeKnown(init_ref)) { @@ -4344,7 +4344,7 @@ fn zirValidateArrayInitRefTy( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(pl_node.src_node); const extra = sema.code.extraData(Zir.Inst.ArrayInitRefTy, pl_node.payload_index).data; const maybe_wrapped_ptr_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, extra.ptr_ty) orelse return .generic_poison_type; @@ -4384,7 +4384,7 @@ fn zirValidateArrayInitTy( ) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const ty_src: LazySrcLoc = if (is_result_ty) src else block.src(.{ .node_offset_init_ty = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.ArrayInit, inst_data.payload_index).data; @@ -4445,7 +4445,7 @@ fn zirValidateStructInitTy( ) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); // It's okay for the type to be poison: this will result in an anonymous struct init. const ty = try sema.resolveTypeOrPoison(block, src, inst_data.operand) orelse return; @@ -4465,11 +4465,11 @@ fn zirValidatePtrStructInit( ) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const validate_inst = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const validate_inst = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const init_src = block.nodeOffset(validate_inst.src_node); const validate_extra = sema.code.extraData(Zir.Inst.Block, validate_inst.payload_index); const instrs = sema.code.bodySlice(validate_extra.end, validate_extra.data.body_len); - const field_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node; + const field_ptr_data = sema.code.instructions.items(.data)[@backingInt(instrs[0])].pl_node; const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data; const object_ptr = sema.resolveInst(field_ptr_extra.lhs); const agg_ty = sema.typeOf(object_ptr).childType(zcu).optEuBaseType(zcu); @@ -4511,7 +4511,7 @@ fn validateUnionInit( errdefer msg.destroy(sema.gpa); for (instrs[1..]) |inst| { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const inst_src = block.src(.{ .node_offset_initializer = inst_data.src_node }); try sema.errNote(inst_src, msg, "additional initializer here", .{}); } @@ -4542,7 +4542,7 @@ fn validateStructInit( @memset(found_fields, false); for (instrs) |field_ptr| { - const field_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(field_ptr)].pl_node; + const field_ptr_data = sema.code.instructions.items(.data)[@backingInt(field_ptr)].pl_node; const field_src = block.src(.{ .node_offset_initializer = field_ptr_data.src_node }); const field_ptr_extra = sema.code.extraData(Zir.Inst.Field, field_ptr_data.payload_index).data; const field_name = try ip.getOrPutString( @@ -4631,11 +4631,11 @@ fn zirValidatePtrArrayInit( ) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const validate_inst = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const validate_inst = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const init_src = block.nodeOffset(validate_inst.src_node); const validate_extra = sema.code.extraData(Zir.Inst.Block, validate_inst.payload_index); const instrs = sema.code.bodySlice(validate_extra.end, validate_extra.data.body_len); - const first_elem_ptr_data = sema.code.instructions.items(.data)[@intFromEnum(instrs[0])].pl_node; + const first_elem_ptr_data = sema.code.instructions.items(.data)[@backingInt(instrs[0])].pl_node; const elem_ptr_extra = sema.code.extraData(Zir.Inst.ElemPtrImm, first_elem_ptr_data.payload_index).data; const array_ptr = sema.resolveInst(elem_ptr_extra.ptr); const array_ty = sema.typeOf(array_ptr).childType(zcu).optEuBaseType(zcu); @@ -4695,7 +4695,7 @@ fn zirValidatePtrArrayInit( fn zirValidateDestructure(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.ValidateDestructure, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); const destructure_src = block.nodeOffset(extra.destructure_node); @@ -4821,7 +4821,7 @@ pub fn addDeclaredHereNote(sema: *Sema, parent: *Zcu.ErrorMsg, decl_ty: Type) Al } fn zirStoreToInferredPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(pl_node.src_node); const bin = sema.code.extraData(Zir.Inst.Bin, pl_node.payload_index).data; const ptr = sema.resolveInst(bin.lhs); @@ -4829,9 +4829,9 @@ fn zirStoreToInferredPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi const ptr_inst = ptr.toIndex().?; const air_datas = sema.air_instructions.items(.data); - switch (sema.air_instructions.items(.tag)[@intFromEnum(ptr_inst)]) { + switch (sema.air_instructions.items(.tag)[@backingInt(ptr_inst)]) { .inferred_alloc_comptime => { - const iac = &air_datas[@intFromEnum(ptr_inst)].inferred_alloc_comptime; + const iac = &air_datas[@backingInt(ptr_inst)].inferred_alloc_comptime; return sema.storeToInferredAllocComptime(block, src, operand, iac); }, .inferred_alloc => { @@ -4904,7 +4904,7 @@ fn storeToInferredAllocComptime( } fn zirSetEvalBranchQuota(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const quota: u32 = @intCast(try sema.resolveInt(block, src, inst_data.operand, .u32, .{ .simple = .operand_setEvalBranchQuota })); sema.branch_quota = @max(sema.branch_quota, quota); @@ -4914,14 +4914,14 @@ fn zirSetEvalBranchQuota(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi fn zirStoreNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { const zir_tags = sema.code.instructions.items(.tag); const zir_datas = sema.code.instructions.items(.data); - const inst_data = zir_datas[@intFromEnum(inst)].pl_node; + const inst_data = zir_datas[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const ptr = sema.resolveInst(extra.lhs); const operand = sema.resolveInst(extra.rhs); const is_ret = if (extra.lhs.toIndex()) |ptr_index| - zir_tags[@intFromEnum(ptr_index)] == .ret_ptr + zir_tags[@backingInt(ptr_index)] == .ret_ptr else false; @@ -4943,7 +4943,7 @@ fn zirStr(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const gpa = comp.gpa; const io = comp.io; const ip = &zcu.intern_pool; - const bytes = sema.code.instructions.items(.data)[@intFromEnum(inst)].str.get(sema.code); + const bytes = sema.code.instructions.items(.data)[@backingInt(inst)].str.get(sema.code); return sema.addStrLit( try ip.getOrPutString(gpa, io, pt.tid, bytes, .maybe_embedded_nulls), bytes.len, @@ -4975,16 +4975,16 @@ fn uavRef(sema: *Sema, val: Value) CompileError!Air.Inst.Ref { fn zirInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { _ = block; - const int = sema.code.instructions.items(.data)[@intFromEnum(inst)].int; + const int = sema.code.instructions.items(.data)[@backingInt(inst)].int; return sema.pt.intRef(.comptime_int, int); } fn zirIntBig(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { _ = block; - const int = sema.code.instructions.items(.data)[@intFromEnum(inst)].str; + const int = sema.code.instructions.items(.data)[@backingInt(inst)].str; const byte_count = int.len * @sizeOf(std.math.big.Limb); - const limb_bytes = sema.code.string_bytes[@intFromEnum(int.start)..][0..byte_count]; + const limb_bytes = sema.code.string_bytes[@backingInt(int.start)..][0..byte_count]; // TODO: this allocation and copy is only needed because the limbs may be unaligned. // If ZIR is adjusted so that big int limbs are guaranteed to be aligned, these @@ -5000,7 +5000,7 @@ fn zirIntBig(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. fn zirFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { _ = block; - const number = sema.code.instructions.items(.data)[@intFromEnum(inst)].float; + const number = sema.code.instructions.items(.data)[@backingInt(inst)].float; return Air.internedToRef((try sema.pt.floatValue( .comptime_float, number, @@ -5009,14 +5009,14 @@ fn zirFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I fn zirFloat128(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { _ = block; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data; const number = extra.get(); return Air.internedToRef((try sema.pt.floatValue(.comptime_float, number)).toIntern()); } fn zirCompileError(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const msg = try sema.resolveConstString(block, operand_src, inst_data.operand, .{ .simple = .compile_error_string }); @@ -5059,7 +5059,7 @@ fn zirCompileLog( const line_data = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, aw.written(), .no_embedded_nulls); const line_idx: Zcu.CompileLogLine.Index = if (zcu.free_compile_log_lines.pop()) |idx| idx: { - zcu.compile_log_lines.items[@intFromEnum(idx)] = .{ + zcu.compile_log_lines.items[@backingInt(idx)] = .{ .next = .none, .data = line_data, }; @@ -5069,7 +5069,7 @@ fn zirCompileLog( .next = .none, .data = line_data, }); - break :idx @enumFromInt(zcu.compile_log_lines.items.len - 1); + break :idx @fromBackingInt(@intCast(zcu.compile_log_lines.items.len - 1)); }; const gop = try zcu.compile_logs.getOrPut(gpa, sema.owner); @@ -5093,7 +5093,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const msg_inst = sema.resolveInst(inst_data.operand); @@ -5135,7 +5135,7 @@ fn zirPanic(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void } fn zirTrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const src_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].node; + const src_node = sema.code.instructions.items(.data)[@backingInt(inst)].node; const src = block.nodeOffset(src_node); if (block.isComptime()) return sema.fail(block, src, "encountered @trap at comptime", .{}); @@ -5143,7 +5143,7 @@ fn zirTrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { } fn zirBreakpoint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!void { - const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: std.zig.Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); const src = block.nodeOffset(src_node); if (block.isComptime()) return sema.fail(block, src, "encountered @breakpoint at comptime", .{}); @@ -5153,7 +5153,7 @@ fn zirBreakpoint(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = parent_block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Block, inst_data.payload_index); const body = sema.code.bodySlice(extra.end, extra.data.body_len); @@ -5163,8 +5163,8 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError // Reserve space for a Loop instruction so that generated Break instructions can // point to it, even if it doesn't end up getting used because the code ends up being // comptime evaluated. - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); - const loop_inst: Air.Inst.Index = @enumFromInt(@intFromEnum(block_inst) + 1); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); + const loop_inst: Air.Inst.Index = @fromBackingInt(@intCast(@backingInt(block_inst) + 1)); try sema.air_instructions.ensureUnusedCapacity(gpa, 2); sema.air_instructions.appendAssumeCapacity(.{ .tag = .block, @@ -5224,7 +5224,7 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError try child_block.instructions.append(gpa, loop_inst); try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).@"struct".field_names.len + loop_block_len + 1); - sema.air_instructions.items(.data)[@intFromEnum(loop_inst)].ty_pl.payload = sema.addExtraAssumeCapacity( + sema.air_instructions.items(.data)[@backingInt(loop_inst)].ty_pl.payload = sema.addExtraAssumeCapacity( Air.Block{ .body_len = @intCast(loop_block_len + 1) }, ); sema.air_extra.appendSliceAssumeCapacity(@ptrCast(loop_block.instructions.items)); @@ -5233,13 +5233,13 @@ fn zirLoop(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError } fn zirSuspendBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = parent_block.nodeOffset(inst_data.src_node); return sema.failWithUseOfAsync(parent_block, src); } fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = parent_block.nodeOffset(pl_node.src_node); const extra = sema.code.extraData(Zir.Inst.Block, pl_node.payload_index); const body = sema.code.bodySlice(extra.end, extra.data.body_len); @@ -5248,7 +5248,7 @@ fn zirBlock(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileErro // Reserve space for a Block instruction so that generated Break instructions can // point to it, even if it doesn't end up getting used because the code ends up being // comptime evaluated or is an unlabeled block. - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = .block, .data = undefined, @@ -5306,7 +5306,7 @@ fn resolveBlockBody( if (child_block.isComptime()) { return sema.resolveInlineBody(child_block, body, body_inst); } else { - assert(sema.air_instructions.items(.tag)[@intFromEnum(merges.block_inst)] == .block); + assert(sema.air_instructions.items(.tag)[@backingInt(merges.block_inst)] == .block); var need_debug_scope = false; child_block.need_debug_scope = &need_debug_scope; if (sema.analyzeBodyInner(child_block, body)) { @@ -5314,7 +5314,7 @@ fn resolveBlockBody( } else |err| switch (err) { error.ComptimeBreak => { const break_inst = sema.comptime_break_inst; - const break_data = sema.code.instructions.items(.data)[@intFromEnum(break_inst)].@"break"; + const break_data = sema.code.instructions.items(.data)[@backingInt(break_inst)].@"break"; const extra = sema.code.extraData(Zir.Inst.Break, break_data.payload_index).data; const breaks_to_body = extra.block_inst == body_inst; @@ -5330,7 +5330,7 @@ fn resolveBlockBody( try parent_block.instructions.append(sema.gpa, merges.block_inst); try sema.air_extra.ensureUnusedCapacity(sema.gpa, @typeInfo(Air.Block).@"struct".field_names.len + child_block.instructions.items.len); - sema.air_instructions.items(.data)[@intFromEnum(merges.block_inst)] = .{ .ty_pl = .{ + sema.air_instructions.items(.data)[@backingInt(merges.block_inst)] = .{ .ty_pl = .{ .ty = Air.internedToRef(operand_ty.toIntern()), .payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = @intCast(child_block.instructions.items.len), @@ -5386,7 +5386,7 @@ fn resolveAnalyzedBlock( assert(child_block.instructions.items.len != 0); assert(sema.typeOf(child_block.instructions.items[child_block.instructions.items.len - 1].toRef()).isNoReturn(zcu)); - const block_tag = sema.air_instructions.items(.tag)[@intFromEnum(merges.block_inst)]; + const block_tag = sema.air_instructions.items(.tag)[@backingInt(merges.block_inst)]; switch (block_tag) { .block => {}, .dbg_inline_block => assert(need_debug_scope), @@ -5412,7 +5412,7 @@ fn resolveAnalyzedBlock( try parent_block.instructions.append(gpa, merges.block_inst); try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.DbgInlineBlock).@"struct".field_names.len + child_block.instructions.items.len); - sema.air_instructions.items(.data)[@intFromEnum(merges.block_inst)] = .{ .ty_pl = .{ + sema.air_instructions.items(.data)[@backingInt(merges.block_inst)] = .{ .ty_pl = .{ .ty = .noreturn_type, .payload = sema.addExtraAssumeCapacity(Air.DbgInlineBlock{ .func = child_block.inlining.?.func, @@ -5450,7 +5450,7 @@ fn resolveAnalyzedBlock( .block => { try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).@"struct".field_names.len + child_block.instructions.items.len); - sema.air_instructions.items(.data)[@intFromEnum(merges.block_inst)] = .{ .ty_pl = .{ + sema.air_instructions.items(.data)[@backingInt(merges.block_inst)] = .{ .ty_pl = .{ .ty = .void_type, .payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = @intCast(child_block.instructions.items.len), @@ -5460,7 +5460,7 @@ fn resolveAnalyzedBlock( .dbg_inline_block => { try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.DbgInlineBlock).@"struct".field_names.len + child_block.instructions.items.len); - sema.air_instructions.items(.data)[@intFromEnum(merges.block_inst)] = .{ .ty_pl = .{ + sema.air_instructions.items(.data)[@backingInt(merges.block_inst)] = .{ .ty_pl = .{ .ty = .void_type, .payload = sema.addExtraAssumeCapacity(Air.DbgInlineBlock{ .func = child_block.inlining.?.func, @@ -5473,7 +5473,7 @@ fn resolveAnalyzedBlock( sema.air_extra.appendSliceAssumeCapacity(@ptrCast(child_block.instructions.items)); // Rewrite the break to just give value {}; the value is // comptime-known and will be returned directly. - sema.air_instructions.items(.data)[@intFromEnum(merges.br_list.items[0])].br.operand = .void_value; + sema.air_instructions.items(.data)[@backingInt(merges.br_list.items[0])].br.operand = .void_value; return Air.internedToRef(result_val.toIntern()); } } @@ -5515,7 +5515,7 @@ fn resolveAnalyzedBlock( .block => { try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).@"struct".field_names.len + child_block.instructions.items.len); - sema.air_instructions.items(.data)[@intFromEnum(merges.block_inst)] = .{ .ty_pl = .{ + sema.air_instructions.items(.data)[@backingInt(merges.block_inst)] = .{ .ty_pl = .{ .ty = ty_inst, .payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = @intCast(child_block.instructions.items.len), @@ -5525,7 +5525,7 @@ fn resolveAnalyzedBlock( .dbg_inline_block => { try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.DbgInlineBlock).@"struct".field_names.len + child_block.instructions.items.len); - sema.air_instructions.items(.data)[@intFromEnum(merges.block_inst)] = .{ .ty_pl = .{ + sema.air_instructions.items(.data)[@backingInt(merges.block_inst)] = .{ .ty_pl = .{ .ty = ty_inst, .payload = sema.addExtraAssumeCapacity(Air.DbgInlineBlock{ .func = child_block.inlining.?.func, @@ -5539,7 +5539,7 @@ fn resolveAnalyzedBlock( // Now that the block has its type resolved, we need to go back into all the break // instructions, and insert type coercion on the operands. for (merges.br_list.items) |br| { - const br_operand = sema.air_instructions.items(.data)[@intFromEnum(br)].br.operand; + const br_operand = sema.air_instructions.items(.data)[@backingInt(br)].br.operand; const br_operand_src = src; const br_operand_ty = sema.typeOf(br_operand); if (br_operand_ty.eql(resolved_ty)) { @@ -5552,7 +5552,7 @@ fn resolveAnalyzedBlock( // If no instructions were produced, such as in the case of a coercion of a // constant value to a new type, we can simply point the br operand to it. if (coerce_block.instructions.items.len == 0) { - sema.air_instructions.items(.data)[@intFromEnum(br)].br.operand = coerced_operand; + sema.air_instructions.items(.data)[@backingInt(br)].br.operand = coerced_operand; continue; } assert(coerce_block.instructions.items[coerce_block.instructions.items.len - 1].toRef() == coerced_operand); @@ -5563,17 +5563,17 @@ fn resolveAnalyzedBlock( try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).@"struct".field_names.len + sub_block_len); try sema.air_instructions.ensureUnusedCapacity(gpa, 1); - const sub_br_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const sub_br_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); - sema.air_instructions.items(.tag)[@intFromEnum(br)] = .block; - sema.air_instructions.items(.data)[@intFromEnum(br)] = .{ .ty_pl = .{ + sema.air_instructions.items(.tag)[@backingInt(br)] = .block; + sema.air_instructions.items(.data)[@backingInt(br)] = .{ .ty_pl = .{ .ty = .noreturn_type, .payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = sub_block_len, }), } }; sema.air_extra.appendSliceAssumeCapacity(@ptrCast(coerce_block.instructions.items)); - sema.air_extra.appendAssumeCapacity(@intFromEnum(sub_br_inst)); + sema.air_extra.appendAssumeCapacity(@backingInt(sub_br_inst)); sema.air_instructions.appendAssumeCapacity(.{ .tag = .br, @@ -5592,7 +5592,7 @@ fn zirExport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Export, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); @@ -5753,13 +5753,13 @@ fn zirSetFloatMode(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD } fn zirSetRuntimeSafety(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); block.want_safety = try sema.resolveConstBool(block, operand_src, inst_data.operand, .{ .simple = .operand_setRuntimeSafety }); } fn zirBreak(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].@"break"; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].@"break"; const extra = sema.code.extraData(Zir.Inst.Break, inst_data.payload_index).data; const operand = sema.resolveInst(inst_data.operand); const zir_block = extra.block_inst; @@ -5789,13 +5789,13 @@ fn zirBreak(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) CompileError } fn zirSwitchContinue(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].@"break"; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].@"break"; const extra = sema.code.extraData(Zir.Inst.Break, inst_data.payload_index).data; const operand_src = start_block.nodeOffset(extra.operand_src_node.unwrap().?); const uncoerced_operand = sema.resolveInst(inst_data.operand); const switch_inst = extra.block_inst; - switch (sema.code.instructions.items(.tag)[@intFromEnum(switch_inst)]) { + switch (sema.code.instructions.items(.tag)[@backingInt(switch_inst)]) { .switch_block, .switch_block_ref => {}, .switch_block_err_union => unreachable, // wrong code path! else => unreachable, // assertion failure @@ -5833,13 +5833,13 @@ fn zirSwitchContinue(sema: *Sema, start_block: *Block, inst: Zir.Inst.Index) Com fn zirDbgStmt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { if (block.isComptime() or block.ownerModule().strip) return; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].dbg_stmt; if (block.instructions.items.len != 0) { const idx = block.instructions.items[block.instructions.items.len - 1]; - if (sema.air_instructions.items(.tag)[@intFromEnum(idx)] == .dbg_stmt) { + if (sema.air_instructions.items(.tag)[@backingInt(idx)] == .dbg_stmt) { // The previous dbg_stmt didn't correspond to any actual code, so replace it. - sema.air_instructions.items(.data)[@intFromEnum(idx)].dbg_stmt = .{ + sema.air_instructions.items(.data)[@backingInt(idx)].dbg_stmt = .{ .line = inst_data.line, .column = inst_data.column, }; @@ -5867,7 +5867,7 @@ fn zirDbgVar( inst: Zir.Inst.Index, air_tag: Air.Inst.Tag, ) CompileError!void { - const str_op = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_op; + const str_op = sema.code.instructions.items(.data)[@backingInt(inst)].str_op; const operand = sema.resolveInst(str_op.operand); const name = str_op.getStr(sema.code); try sema.addDbgVar(block, operand, air_tag, name); @@ -5911,7 +5911,7 @@ fn addDbgVar( _ = try block.addInst(.{ .tag = air_tag, .data = .{ .pl_op = .{ - .payload = @intFromEnum(name_nts), + .payload = @backingInt(name_nts), .operand = operand, } }, }); @@ -5919,7 +5919,7 @@ fn addDbgVar( pub fn appendAirString(sema: *Sema, str: []const u8) Allocator.Error!Air.NullTerminatedString { if (str.len == 0) return .none; - const nts: Air.NullTerminatedString = @enumFromInt(sema.air_extra.items.len); + const nts: Air.NullTerminatedString = @fromBackingInt(@intCast(sema.air_extra.items.len)); const elements_used = str.len / 4 + 1; const elements = try sema.air_extra.addManyAsSlice(sema.gpa, elements_used); const buffer = mem.sliceAsBytes(elements); @@ -5935,7 +5935,7 @@ fn zirDeclRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].str_tok; const src = block.tokenOffset(inst_data.src_tok); const decl_name = try zcu.intern_pool.getOrPutString( gpa, @@ -5955,7 +5955,7 @@ fn zirDeclVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].str_tok; const src = block.tokenOffset(inst_data.src_tok); const decl_name = try zcu.intern_pool.getOrPutString( gpa, @@ -6144,7 +6144,7 @@ fn popErrorReturnTrace( then_block.instructions.items.len + else_block.instructions.items.len + @typeInfo(Air.Block).@"struct".field_names.len + 1); // +1 for the sole .cond_br instruction in the .block - const cond_br_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const cond_br_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = .cond_br, .data = .{ @@ -6168,8 +6168,8 @@ fn popErrorReturnTrace( sema.air_extra.appendSliceAssumeCapacity(@ptrCast(then_block.instructions.items)); sema.air_extra.appendSliceAssumeCapacity(@ptrCast(else_block.instructions.items)); - sema.air_instructions.items(.data)[@intFromEnum(cond_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = 1 }); - sema.air_extra.appendAssumeCapacity(@intFromEnum(cond_br_inst)); + sema.air_instructions.items(.data)[@backingInt(cond_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = 1 }); + sema.air_extra.appendAssumeCapacity(@backingInt(cond_br_inst)); } } @@ -6185,7 +6185,7 @@ fn zirCall( const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const callee_src = block.src(.{ .node_offset_call_func = inst_data.src_node }); const call_src = block.nodeOffset(inst_data.src_node); const ExtraType = switch (kind) { @@ -6195,7 +6195,7 @@ fn zirCall( const extra = sema.code.extraData(ExtraType, inst_data.payload_index); const args_len = extra.data.flags.args_len; - const modifier: std.lang.CallModifier = @enumFromInt(extra.data.flags.packed_modifier); + const modifier: std.lang.CallModifier = @fromBackingInt(@intCast(extra.data.flags.packed_modifier)); const ensure_result_used = extra.data.flags.ensure_result_used; const pop_error_return_trace = extra.data.flags.pop_error_return_trace; @@ -6224,7 +6224,7 @@ fn zirCall( const func_ty = try sema.checkCallArgumentCount(block, func, callee_src, callee_ty, total_args, callee == .method); // The block index before the call, so we can potentially insert an error trace save here later. - const block_index: Air.Inst.Index = @enumFromInt(block.instructions.items.len); + const block_index: Air.Inst.Index = @fromBackingInt(@intCast(block.instructions.items.len)); // This will be set by `analyzeCall` to indicate whether any parameter was an error (making the // error trace potentially dirty). @@ -6244,7 +6244,7 @@ fn zirCall( } }; // AstGen ensures that a call instruction is always preceded by a dbg_stmt instruction. - const call_dbg_node: Zir.Inst.Index = @enumFromInt(@intFromEnum(inst) - 1); + const call_dbg_node: Zir.Inst.Index = @fromBackingInt(@intCast(@backingInt(inst) - 1)); const call_inst = try sema.analyzeCall(block, func, func_ty, callee_src, call_src, modifier, ensure_result_used, args_info, call_dbg_node, .call); if (block.ownerModule().error_tracing and @@ -6530,11 +6530,11 @@ const CallArgsInfo = union(enum) { const arg_body = if (real_arg_idx == 0) blk: { const start = zir_call.num_args; - const end = @intFromEnum(zir_call.args_body[0]); + const end = @backingInt(zir_call.args_body[0]); break :blk zir_call.args_body[start..end]; } else blk: { - const start = @intFromEnum(zir_call.args_body[real_arg_idx - 1]); - const end = @intFromEnum(zir_call.args_body[real_arg_idx]); + const start = @backingInt(zir_call.args_body[real_arg_idx - 1]); + const end = @backingInt(zir_call.args_body[real_arg_idx]); break :blk zir_call.args_body[start..end]; }; @@ -6777,7 +6777,7 @@ fn analyzeCall( // We must discover the generic parameter type. assert(any_generic_types); const param_inst_idx = fn_zir_info.param_body[arg_idx]; - const param_inst = fn_zir.instructions.get(@intFromEnum(param_inst_idx)); + const param_inst = fn_zir.instructions.get(@backingInt(param_inst_idx)); switch (param_inst.tag) { .param_anytype, .param_anytype_comptime => break :ty .generic_poison, .param, .param_comptime => {}, @@ -6853,7 +6853,7 @@ fn analyzeCall( } else { // We need a dummy instruction with this type. It doesn't actually need to be in any block, // since it will never be referenced at runtime! - const dummy: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const dummy: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = .alloc, .data = .{ .ty = arg_ty } }); generic_inst_map.putAssumeCapacityNoClobber(param_inst_idx, dummy.toRef()); } @@ -7256,7 +7256,7 @@ fn analyzeCall( } const need_debug_scope = !block.isComptime() and !block.is_typeof and !block.ownerModule().strip; - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = if (need_debug_scope) .dbg_inline_block else .block, .data = undefined, @@ -7313,15 +7313,15 @@ fn analyzeCall( if (!block.isComptime() and !block.is_typeof) { const zir_tags = sema.code.instructions.items(.tag); const zir_datas = sema.code.instructions.items(.data); - for (fn_zir_info.param_body) |inst| switch (zir_tags[@intFromEnum(inst)]) { + for (fn_zir_info.param_body) |inst| switch (zir_tags[@backingInt(inst)]) { .param, .param_comptime => { - const extra = sema.code.extraData(Zir.Inst.Param, zir_datas[@intFromEnum(inst)].pl_tok.payload_index); + const extra = sema.code.extraData(Zir.Inst.Param, zir_datas[@backingInt(inst)].pl_tok.payload_index); const param_name = sema.code.nullTerminatedString(extra.data.name); const air_inst = sema.inst_map.get(inst).?; try sema.addDbgVar(&child_block, air_inst, .dbg_arg_inline, param_name); }, .param_anytype, .param_anytype_comptime => { - const param_name = zir_datas[@intFromEnum(inst)].str_tok.get(sema.code); + const param_name = zir_datas[@backingInt(inst)].str_tok.get(sema.code); const air_inst = sema.inst_map.get(inst).?; try sema.addDbgVar(&child_block, air_inst, .dbg_arg_inline, param_name); }, @@ -7410,7 +7410,7 @@ fn handleTailCall(sema: *Sema, block: *Block, call_src: LazySrcLoc, func_ty: Typ } fn zirIntType(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const int_type = sema.code.instructions.items(.data)[@intFromEnum(inst)].int_type; + const int_type = sema.code.instructions.items(.data)[@backingInt(inst)].int_type; const ty = try sema.pt.intType(int_type.signedness, int_type.bit_count); return Air.internedToRef(ty.toIntern()); } @@ -7418,7 +7418,7 @@ fn zirIntType(sema: *Sema, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node }); const child_type = try sema.resolveType(block, operand_src, inst_data.operand); if (child_type.zigTypeTag(zcu) == .@"opaque") { @@ -7434,12 +7434,12 @@ fn zirOptionalType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const bin = sema.code.instructions.items(.data)[@intFromEnum(inst)].bin; + const bin = sema.code.instructions.items(.data)[@backingInt(inst)].bin; const maybe_wrapped_indexable_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, bin.lhs) orelse return .generic_poison_type; const indexable_ty = maybe_wrapped_indexable_ty.optEuBaseType(zcu); assert(indexable_ty.isIndexable(zcu)); // validated by a previous instruction const elem_ty = switch (indexable_ty.zigTypeTag(zcu)) { - .@"struct" => indexable_ty.fieldType(@intFromEnum(bin.rhs), zcu), + .@"struct" => indexable_ty.fieldType(@backingInt(bin.rhs), zcu), else => indexable_ty.indexableElem(zcu), }; return .fromType(elem_ty); @@ -7448,7 +7448,7 @@ fn zirArrayInitElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil fn zirElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const maybe_wrapped_ptr_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, un_node.operand) orelse return .generic_poison_type; const ptr_ty = maybe_wrapped_ptr_ty.optEuBaseType(zcu); assert(ptr_ty.zigTypeTag(zcu) == .pointer); // validated by a previous instruction @@ -7464,7 +7464,7 @@ fn zirElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai fn zirIndexablePtrElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(un_node.src_node); const ptr_ty = try sema.resolveTypeOrPoison(block, src, un_node.operand) orelse return .generic_poison_type; try sema.checkMemOperand(block, src, ptr_ty); @@ -7478,7 +7478,7 @@ fn zirIndexablePtrElemType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Com fn zirSplatOpResultType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const un_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const un_node = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const raw_ty = try sema.resolveTypeOrPoison(block, LazySrcLoc.unneeded, un_node.operand) orelse return .generic_poison_type; const vec_ty = raw_ty.optEuBaseType(zcu); @@ -7491,7 +7491,7 @@ fn zirSplatOpResultType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil } fn zirVectorType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const len_src = block.builtinCallArgSrc(inst_data.src_node, 0); const elem_type_src = block.builtinCallArgSrc(inst_data.src_node, 1); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -7506,7 +7506,7 @@ fn zirVectorType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! } fn zirArrayType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const len_src = block.src(.{ .node_offset_array_type_len = inst_data.src_node }); const elem_src = block.src(.{ .node_offset_array_type_elem = inst_data.src_node }); @@ -7529,7 +7529,7 @@ fn zirArrayTypeSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.ArrayTypeSentinel, inst_data.payload_index).data; const len_src = block.src(.{ .node_offset_array_type_len = inst_data.src_node }); const sentinel_src = block.src(.{ .node_offset_array_type_sentinel = inst_data.src_node }); @@ -7565,7 +7565,7 @@ fn validateArrayElemType(sema: *Sema, block: *Block, elem_type: Type, elem_src: } fn zirAnyframeType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; if (true) { return sema.failWithUseOfAsync(block, block.nodeOffset(inst_data.src_node)); } @@ -7580,7 +7580,7 @@ fn zirAnyframeType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro fn zirErrorUnionType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node }); @@ -7620,7 +7620,7 @@ fn zirErrorValue(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].str_tok; const name = try pt.zcu.intern_pool.getOrPutString( gpa, io, @@ -7718,7 +7718,7 @@ fn zirMergeErrorSets(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); @@ -7776,7 +7776,7 @@ fn zirEnumLiteral(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].str_tok; const name = inst_data.get(sema.code); return Air.internedToRef((try pt.intern(.{ .enum_literal = try zcu.intern_pool.getOrPutString(gpa, io, pt.tid, name, .no_embedded_nulls), @@ -7790,7 +7790,7 @@ fn zirDeclLiteral(sema: *Sema, block: *Block, inst: Zir.Inst.Index, do_coerce: b const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data; const name = try zcu.intern_pool.getOrPutString( @@ -7851,7 +7851,7 @@ fn analyzeDeclLiteral( fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand = sema.resolveInst(inst_data.operand); @@ -7893,7 +7893,7 @@ fn zirIntFromEnum(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError fn zirEnumFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -7954,7 +7954,7 @@ fn zirOptionalPayloadPtr( inst: Zir.Inst.Index, safety_check: bool, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const optional_ptr = sema.resolveInst(inst_data.operand); const src = block.nodeOffset(inst_data.src_node); @@ -8042,7 +8042,7 @@ fn zirOptionalPayload( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -8093,7 +8093,7 @@ fn zirErrUnionPayload( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); const operand_src = src; @@ -8147,7 +8147,7 @@ fn zirErrUnionPayloadPtr( block: *Block, inst: Zir.Inst.Index, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand = sema.resolveInst(inst_data.operand); const src = block.nodeOffset(inst_data.src_node); @@ -8236,7 +8236,7 @@ fn analyzeErrUnionPayloadPtr( /// Value in, value out fn zirErrUnionCode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); return sema.analyzeErrUnionCode(block, src, operand); @@ -8269,7 +8269,7 @@ fn analyzeErrUnionCode(sema: *Sema, block: *Block, src: LazySrcLoc, operand: Air /// Pointer in, value out fn zirErrUnionCodePtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); return sema.analyzeErrUnionCodePtr(block, src, operand); @@ -8316,7 +8316,7 @@ fn zirFunc( const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Func, inst_data.payload_index); const target = zcu.getTarget(); const ret_ty_src = block.src(.{ .node_offset_fn_type_ret_ty = inst_data.src_node }); @@ -8329,7 +8329,7 @@ fn zirFunc( else switch (extra.data.ret_ty.body_len) { 0 => .void, 1 => blk: { - const ret_ty_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); + const ret_ty_ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_index])); extra_index += 1; break :blk try sema.resolveType(block, ret_ty_src, ret_ty_ref); }, @@ -9063,7 +9063,7 @@ fn zirParam( inst: Zir.Inst.Index, comptime_syntax: bool, ) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_tok; const src = block.tokenOffset(inst_data.src_tok); const extra = sema.code.extraData(Zir.Inst.Param, inst_data.payload_index); const param_name: Zir.NullTerminatedString = extra.data.name; @@ -9094,7 +9094,7 @@ fn zirParamAnytype( inst: Zir.Inst.Index, comptime_syntax: bool, ) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].str_tok; const param_name: Zir.NullTerminatedString = inst_data.start; try block.params.append(sema.arena, .{ @@ -9105,14 +9105,14 @@ fn zirParamAnytype( } fn zirAsNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.As, inst_data.payload_index).data; return sema.analyzeAs(block, src, extra.dest_type, extra.operand, false); } fn zirAsShiftOperand(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.As, inst_data.payload_index).data; return sema.analyzeAs(block, src, extra.dest_type, extra.operand, true); @@ -9137,7 +9137,7 @@ fn analyzeAs( } const is_ret = if (zir_dest_type.toIndex()) |ptr_index| - sema.code.instructions.items(.tag)[@intFromEnum(ptr_index)] == .ret_type + sema.code.instructions.items(.tag)[@backingInt(ptr_index)] == .ret_type else false; return sema.coerceExtra(block, dest_ty, operand, src, .{ .is_ret = is_ret, .no_cast_to_comptime_int = no_cast_to_comptime_int }) catch |err| switch (err) { @@ -9149,7 +9149,7 @@ fn analyzeAs( fn zirIntFromPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const ptr_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -9207,7 +9207,7 @@ fn zirFieldPtrLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const field_name_src = block.src(.{ .node_offset_field_name = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data; @@ -9229,7 +9229,7 @@ fn zirFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const field_name_src = block.src(.{ .node_offset_field_name = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data; @@ -9251,7 +9251,7 @@ fn zirStructInitFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const field_name_src = block.src(.{ .node_offset_field_name_init = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Field, inst_data.payload_index).data; @@ -9275,7 +9275,7 @@ fn zirStructInitFieldPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compi } fn zirFieldPtrNamedLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const field_name_src = block.builtinCallArgSrc(inst_data.src_node, 1); const extra = sema.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data; @@ -9285,7 +9285,7 @@ fn zirFieldPtrNamedLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compil } fn zirFieldPtrNamed(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const field_name_src = block.builtinCallArgSrc(inst_data.src_node, 1); const extra = sema.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data; @@ -9295,7 +9295,7 @@ fn zirFieldPtrNamed(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr } fn zirIntCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -9367,7 +9367,7 @@ fn intCast( fn zirBitcast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -9467,7 +9467,7 @@ fn zirBackingInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! const pt = sema.pt; const zcu = pt.zcu; const gpa = zcu.comp.gpa; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand = sema.resolveInst(inst_data.operand); @@ -9524,7 +9524,7 @@ fn zirBackingInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! fn zirFromBackingIntArgTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const dest_ty = try sema.resolveDestType(block, src, inst_data.operand, .remove_eu_opt, "@fromBackingInt"); @@ -9552,7 +9552,7 @@ fn zirFromBackingInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr const zcu = pt.zcu; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -9602,7 +9602,7 @@ fn zirFromBackingInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileEr fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -9665,7 +9665,7 @@ fn zirFloatCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A } fn zirElemVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const array = sema.resolveInst(extra.lhs); @@ -9674,7 +9674,7 @@ fn zirElemVal(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air } fn zirElemPtrLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const elem_index_src = block.src(.{ .node_offset_array_access_index = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -9693,7 +9693,7 @@ fn zirElemPtrLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError } fn zirElemValImm(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].elem_val_imm; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].elem_val_imm; const array = sema.resolveInst(inst_data.operand); const elem_index = try sema.pt.intRef(.usize, inst_data.idx); return sema.elemVal(block, LazySrcLoc.unneeded, array, elem_index, LazySrcLoc.unneeded, false); @@ -9702,7 +9702,7 @@ fn zirElemValImm(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const array_ptr = sema.resolveInst(extra.lhs); @@ -9728,7 +9728,7 @@ fn zirElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air } fn zirElemPtrNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const elem_index_src = block.src(.{ .node_offset_array_access_index = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -9741,7 +9741,7 @@ fn zirElemPtrNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError fn zirArrayInitElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data; const array_ptr = sema.resolveInst(extra.ptr); @@ -9757,7 +9757,7 @@ fn zirArrayInitElemPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Compile } fn zirSliceStart(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.SliceStart, inst_data.payload_index).data; const array_ptr = sema.resolveInst(extra.lhs); @@ -9770,7 +9770,7 @@ fn zirSliceStart(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! } fn zirSliceEnd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.SliceEnd, inst_data.payload_index).data; const array_ptr = sema.resolveInst(extra.lhs); @@ -9784,7 +9784,7 @@ fn zirSliceEnd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } fn zirSliceSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const sentinel_src = block.src(.{ .node_offset_slice_sentinel = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.SliceSentinel, inst_data.payload_index).data; @@ -9800,7 +9800,7 @@ fn zirSliceSentinel(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr } fn zirSliceLength(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.SliceLength, inst_data.payload_index).data; const array_ptr = sema.resolveInst(extra.lhs); @@ -9822,7 +9822,7 @@ fn zirSliceSentinelTy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ptr_src = block.src(.{ .node_offset_slice_ptr = inst_data.src_node }); @@ -9867,7 +9867,7 @@ fn zirSwitchBlockErrUnion(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp assert(!zir_switch.has_continue); // wrong codepath! - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = .block, .data = undefined, @@ -10021,7 +10021,7 @@ fn zirSwitchBlock( ) CompileError!Air.Inst.Ref { const zir_switch = sema.code.getSwitchBlock(inst); - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(sema.gpa, .{ .tag = .block, .data = undefined, @@ -10161,7 +10161,7 @@ fn analyzeSwitchBlock( return result; } else |err| switch (err) { error.ComptimeBreak => { - const break_inst = sema.code.instructions.get(@intFromEnum(sema.comptime_break_inst)); + const break_inst = sema.code.instructions.get(@backingInt(sema.comptime_break_inst)); if (break_inst.tag != .switch_continue) return error.ComptimeBreak; const extra = sema.code.extraData(Zir.Inst.Break, break_inst.data.@"break".payload_index).data; if (extra.block_inst != switch_inst) return error.ComptimeBreak; @@ -10342,7 +10342,7 @@ fn analyzeSwitchBlock( break :switch_ref .{ air_ref, true }; }; - const air_tag = sema.air_instructions.items(.tag)[@intFromEnum(switch_ref.toIndex().?)]; + const air_tag = sema.air_instructions.items(.tag)[@backingInt(switch_ref.toIndex().?)]; switch (air_tag) { .loop_switch_br, .switch_br => assert(!item_has_opv), .loop, .block => assert(item_has_opv), @@ -10362,8 +10362,8 @@ fn analyzeSwitchBlock( var replacement_block = block.makeSubBlock(); defer replacement_block.instructions.deinit(gpa); - assert(sema.air_instructions.items(.tag)[@intFromEnum(placeholder_inst)] == .br); - const new_operand_maybe_ref = sema.air_instructions.items(.data)[@intFromEnum(placeholder_inst)].br.operand; + assert(sema.air_instructions.items(.tag)[@backingInt(placeholder_inst)] == .br); + const new_operand_maybe_ref = sema.air_instructions.items(.data)[@backingInt(placeholder_inst)].br.operand; if (zir_switch.any_maybe_runtime_capture and !item_has_opv) { _ = try replacement_block.addBinOp(.store, operand.loop.operand_alloc, new_operand_maybe_ref); @@ -10404,8 +10404,8 @@ fn analyzeSwitchBlock( if (replacement_block.instructions.items.len == 1) { // Optimization: we don't need a block! sema.air_instructions.set( - @intFromEnum(placeholder_inst), - sema.air_instructions.get(@intFromEnum(replacement_block.instructions.items[0])), + @backingInt(placeholder_inst), + sema.air_instructions.get(@backingInt(replacement_block.instructions.items[0])), ); continue; } @@ -10414,7 +10414,7 @@ fn analyzeSwitchBlock( // No `br` is needed as the block is a switch dispatch so necessarily `noreturn`. try sema.air_extra.ensureUnusedCapacity(gpa, @typeInfo(Air.Block).@"struct".field_names.len + replacement_block.instructions.items.len); - sema.air_instructions.set(@intFromEnum(placeholder_inst), .{ + sema.air_instructions.set(@backingInt(placeholder_inst), .{ .tag = .block, .data = .{ .ty_pl = .{ .ty = .noreturn_type, @@ -10470,7 +10470,7 @@ fn finishSwitchBr( // AstGen guarantees that the instruction immediately preceding // switch_block[_ref]/switch_block_err_union is a dbg_stmt. - const cond_dbg_node_index: Zir.Inst.Index = @enumFromInt(@intFromEnum(switch_inst) - 1); + const cond_dbg_node_index: Zir.Inst.Index = @fromBackingInt(@intCast(@backingInt(switch_inst) - 1)); const else_is_named_only = has_else and has_under; @@ -10499,7 +10499,7 @@ fn finishSwitchBr( fn appendAssumeCapacity(hints: *@This(), hint: std.lang.BranchHint) void { const idx_in_bag = hints.count % hints_per_bag; var bag: u32 = if (idx_in_bag > 0) hints.bags.pop().? else 0; - bag |= @as(u32, @intFromEnum(hint)) << @intCast(@bitSizeOf(std.lang.BranchHint) * idx_in_bag); + bag |= @as(u32, @backingInt(hint)) << @intCast(@bitSizeOf(std.lang.BranchHint) * idx_in_bag); hints.count += 1; return hints.bags.appendAssumeCapacity(bag); } @@ -10613,7 +10613,7 @@ fn finishSwitchBr( .ranges_len = 0, .body_len = @intCast(case_block.instructions.items.len), })); - cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); + cases_extra.appendAssumeCapacity(@backingInt(item_ref)); cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); } } @@ -10685,7 +10685,7 @@ fn finishSwitchBr( .ranges_len = 0, .body_len = @intCast(case_block.instructions.items.len), })); - cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); + cases_extra.appendAssumeCapacity(@backingInt(item_ref)); cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); } } @@ -10828,7 +10828,7 @@ fn finishSwitchBr( .ranges_len = 0, .body_len = @intCast(case_block.instructions.items.len), })); - cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); + cases_extra.appendAssumeCapacity(@backingInt(item_ref)); cases_extra.appendSliceAssumeCapacity(@ptrCast(case_block.instructions.items)); } } @@ -10891,7 +10891,7 @@ fn finishSwitchBr( if (seen_field != null) continue; const item_val = try pt.enumValueFieldIndex(item_ty, @intCast(field_i)); const item_ref: Air.Inst.Ref = .fromValue(item_val); - cases_extra.appendAssumeCapacity(@intFromEnum(item_ref)); + cases_extra.appendAssumeCapacity(@backingInt(item_ref)); items_len += 1; } assert(items_len > 0); // `else` must be reachable at this point @@ -12370,7 +12370,7 @@ fn analyzeSwitchPayloadCaptureTaggedUnion( { // All branch hints are `.none`, so just add zero elems. - comptime assert(@intFromEnum(std.lang.BranchHint.none) == 0); + comptime assert(@backingInt(std.lang.BranchHint.none) == 0); const need_elems = @divCeil(field_indices.len + 1, 10); try cases_extra.appendNTimes(gpa, 0, need_elems); } @@ -12402,15 +12402,15 @@ fn analyzeSwitchPayloadCaptureTaggedUnion( .ranges_len = 0, .body_len = @intCast(coerce_block.instructions.items.len), })); - cases_extra.appendAssumeCapacity(@intFromEnum(item)); // item + cases_extra.appendAssumeCapacity(@backingInt(item)); // item cases_extra.appendSliceAssumeCapacity(@ptrCast(coerce_block.instructions.items)); // body } } const else_body_len = len: { // 'else' prong is unreachable - const result_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const result_index: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = .unreach, .data = .{ .no_op = {} } }); - try cases_extra.append(gpa, @intFromEnum(result_index)); + try cases_extra.append(gpa, @backingInt(result_index)); break :len 1; }; @@ -12439,13 +12439,13 @@ fn analyzeSwitchPayloadCaptureTaggedUnion( .simple => |s| { const air_datas = sema.air_instructions.items(.data); air_datas[switch_br_inst].pl_op.operand = s.cond; - air_datas[@intFromEnum(capture_block_inst)].ty_pl.payload = + air_datas[@backingInt(capture_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = 1 }); sema.air_extra.appendAssumeCapacity(switch_br_inst); }, .loop => { // The block must first extract the tag from the loaded union. - const tag_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const tag_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(sema.gpa, .{ .tag = .get_union_tag, .data = .{ .ty_op = .{ @@ -12455,9 +12455,9 @@ fn analyzeSwitchPayloadCaptureTaggedUnion( }); const air_datas = sema.air_instructions.items(.data); air_datas[switch_br_inst].pl_op.operand = tag_inst.toRef(); - air_datas[@intFromEnum(capture_block_inst)].ty_pl.payload = + air_datas[@backingInt(capture_block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = 2 }); - sema.air_extra.appendAssumeCapacity(@intFromEnum(tag_inst)); + sema.air_extra.appendAssumeCapacity(@backingInt(tag_inst)); sema.air_extra.appendAssumeCapacity(switch_br_inst); }, } @@ -12674,7 +12674,7 @@ fn maybeErrorUnwrap( const tags = sema.code.instructions.items(.tag); for (body) |inst| { - switch (tags[@intFromEnum(inst)]) { + switch (tags[@backingInt(inst)]) { .@"unreachable" => if (!block.wantSafety()) return false, .err_union_code => if (!allow_err_code_inst) return false, .save_err_ret_index, @@ -12688,7 +12688,7 @@ fn maybeErrorUnwrap( } for (body) |inst| { - const air_inst = switch (tags[@intFromEnum(inst)]) { + const air_inst = switch (tags[@backingInt(inst)]) { .err_union_code => continue, .dbg_stmt => { try sema.zirDbgStmt(block, inst); @@ -12705,7 +12705,7 @@ fn maybeErrorUnwrap( return true; }, .panic => { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const msg_inst = sema.resolveInst(inst_data.operand); const panic_fn = try getStdLangValue(sema, operand_src, .@"panic.call"); @@ -12726,9 +12726,9 @@ fn maybeErrorUnwrapCondbr(sema: *Sema, block: *Block, body: []const Zir.Inst.Ind const pt = sema.pt; const zcu = pt.zcu; const index = cond.toIndex() orelse return; - if (sema.code.instructions.items(.tag)[@intFromEnum(index)] != .is_non_err) return; + if (sema.code.instructions.items(.tag)[@backingInt(index)] != .is_non_err) return; - const err_inst_data = sema.code.instructions.items(.data)[@intFromEnum(index)].un_node; + const err_inst_data = sema.code.instructions.items(.data)[@backingInt(index)].un_node; const err_operand = sema.resolveInst(err_inst_data.operand); const operand_ty = sema.typeOf(err_operand); if (operand_ty.zigTypeTag(zcu) == .error_set) { @@ -12745,7 +12745,7 @@ fn maybeErrorUnwrapCondbr(sema: *Sema, block: *Block, body: []const Zir.Inst.Ind fn maybeErrorUnwrapComptime(sema: *Sema, block: *Block, body: []const Zir.Inst.Index, operand: Air.Inst.Ref) !void { const tags = sema.code.instructions.items(.tag); const inst = for (body) |inst| { - switch (tags[@intFromEnum(inst)]) { + switch (tags[@backingInt(inst)]) { .dbg_stmt, .save_err_ret_index, => {}, @@ -12753,7 +12753,7 @@ fn maybeErrorUnwrapComptime(sema: *Sema, block: *Block, body: []const Zir.Inst.I else => return, } } else return; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].@"unreachable"; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].@"unreachable"; const src = block.nodeOffset(inst_data.src_node); if (try sema.resolveDefinedValue(block, src, operand)) |val| { @@ -12766,7 +12766,7 @@ fn maybeErrorUnwrapComptime(sema: *Sema, block: *Block, body: []const Zir.Inst.I fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0); const name_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -12813,7 +12813,7 @@ fn zirHasField(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai fn zirHasDecl(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -12834,7 +12834,7 @@ fn zirHasDecl(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air fn zirImport(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_tok; const extra = sema.code.extraData(Zir.Inst.Import, inst_data.payload_index).data; const operand_src = block.tokenOffset(inst_data.src_tok); const operand = sema.code.nullTerminatedString(extra.path); @@ -12883,7 +12883,7 @@ fn zirEmbedFile(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const name = try sema.resolveConstString(block, operand_src, inst_data.operand, .{ .simple = .operand_embedFile }); @@ -12916,7 +12916,7 @@ fn zirShl( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const lhs = sema.resolveInst(extra.lhs); const rhs = sema.resolveInst(extra.rhs); @@ -13103,7 +13103,7 @@ fn zirShr( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const lhs = sema.resolveInst(extra.lhs); const rhs = sema.resolveInst(extra.rhs); @@ -13230,7 +13230,7 @@ fn zirBitwise( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node }); @@ -13284,7 +13284,7 @@ fn zirBitwise( fn zirBitNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node }); const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); @@ -13410,7 +13410,7 @@ fn analyzeTupleCat( fn zirArrayCat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const lhs = sema.resolveInst(extra.lhs); const rhs = sema.resolveInst(extra.rhs); @@ -13844,7 +13844,7 @@ fn analyzeTupleMul( fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const lhs_src = src; const rhs_src = block.src(.{ .node_offset_un_op = inst_data.src_node }); @@ -13877,7 +13877,7 @@ fn zirNegate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. fn zirNegateWrap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const lhs_src = src; const rhs_src = block.src(.{ .node_offset_un_op = inst_data.src_node }); @@ -13902,7 +13902,7 @@ fn zirArithmetic( zir_tag: Zir.Inst.Tag, safety: bool, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node }); @@ -13916,7 +13916,7 @@ fn zirArithmetic( fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node }); @@ -14025,7 +14025,7 @@ fn zirDiv(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -14121,7 +14121,7 @@ fn zirDivExact(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -14186,7 +14186,7 @@ fn zirDivFloor(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai fn zirDivCeil(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -14251,7 +14251,7 @@ fn zirDivCeil(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air fn zirDivTrunc(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -14462,7 +14462,7 @@ fn airTag(block: *Block, is_int: bool, normal: Air.Inst.Tag, optimized: Air.Inst fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); const rhs_src = block.src(.{ .node_offset_bin_rhs = inst_data.src_node }); @@ -14563,7 +14563,7 @@ fn zirModRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -14627,7 +14627,7 @@ fn zirMod(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Ins fn zirRem(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); const rhs_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -15211,7 +15211,7 @@ fn analyzePtrArithmetic( } fn zirLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ptr_src = src; // TODO better source location const ptr = sema.resolveInst(inst_data.operand); @@ -15241,7 +15241,7 @@ fn zirAsm( const is_global_assembly = sema.func_index == .none; const asm_source: []const u8 = if (tmpl_is_expr) s: { - const tmpl: Zir.Inst.Ref = @enumFromInt(@intFromEnum(extra.data.asm_source)); + const tmpl: Zir.Inst.Ref = @fromBackingInt(@intCast(@backingInt(extra.data.asm_source))); break :s try sema.resolveConstString(block, src, tmpl, .{ .simple = .inline_assembly_code }); } else sema.code.nullTerminatedString(extra.data.asm_source); @@ -15495,7 +15495,7 @@ fn zirCmpEq( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src: LazySrcLoc = block.nodeOffset(inst_data.src_node); const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); @@ -15606,7 +15606,7 @@ fn zirCmp( inst: Zir.Inst.Index, op: std.math.CompareOperator, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src: LazySrcLoc = block.nodeOffset(inst_data.src_node); const lhs_src = block.src(.{ .node_offset_bin_lhs = inst_data.src_node }); @@ -15762,7 +15762,7 @@ fn runtimeBoolCmp( fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const ty = try sema.resolveType(block, operand_src, inst_data.operand); try sema.ensureLayoutResolved(ty, operand_src, .size_of); @@ -15786,7 +15786,7 @@ fn zirSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. fn zirBitSizeOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand_ty = try sema.resolveType(block, operand_src, inst_data.operand); if (!operand_ty.hasBitRepresentation(zcu) and @@ -15816,7 +15816,7 @@ fn zirClosureGet(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDat const ip = &zcu.intern_pool; const captures = Type.fromInterned(zcu.namespacePtr(block.namespace).owner_type).getCaptures(zcu); - const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: std.zig.Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); const src = block.nodeOffset(src_node); const capture_ty = switch (captures.get(ip)[extended.small].unwrap()) { @@ -15912,7 +15912,7 @@ fn zirFrameAddress( block: *Block, extended: Zir.Inst.Extended.InstData, ) CompileError!Air.Inst.Ref { - const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: std.zig.Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); const src = block.nodeOffset(src_node); try sema.requireRuntimeBlock(block, src, null); return try block.addNoOp(.frame_addr); @@ -16034,7 +16034,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ty = try sema.resolveType(block, src, inst_data.operand); const type_info_ty = try sema.getStdLangType(src, .Type); @@ -16207,7 +16207,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"fn"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.@"fn"))).toIntern(), .val = (try pt.aggregateValue(fn_info_ty, &field_values)).toIntern(), }))); }, @@ -16217,13 +16217,13 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const info = ty.intInfo(zcu); const field_values = .{ // signedness: Signedness, - (try pt.enumValueFieldIndex(signedness_ty, @intFromEnum(info.signedness))).toIntern(), + (try pt.enumValueFieldIndex(signedness_ty, @backingInt(info.signedness))).toIntern(), // bits: u16, (try pt.intValue(.u16, info.bits)).toIntern(), }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.int))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.int))).toIntern(), .val = (try pt.aggregateValue(int_info_ty, &field_values)).toIntern(), }))); }, @@ -16236,7 +16236,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.float))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.float))).toIntern(), .val = (try pt.aggregateValue(float_info_ty, &field_vals)).toIntern(), }))); }, @@ -16279,7 +16279,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const field_values = .{ // size: Size, - (try pt.enumValueFieldIndex(ptr_size_ty, @intFromEnum(info.flags.size))).toIntern(), + (try pt.enumValueFieldIndex(ptr_size_ty, @backingInt(info.flags.size))).toIntern(), // attrs: Attributes (try pt.aggregateValue(ptr_attrs_ty, &attributes)).toIntern(), // child: type, @@ -16292,7 +16292,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.pointer))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.pointer))).toIntern(), .val = (try pt.aggregateValue(pointer_ty, &field_values)).toIntern(), }))); }, @@ -16310,7 +16310,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.array))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.array))).toIntern(), .val = (try pt.aggregateValue(array_field_ty, &field_values)).toIntern(), }))); }, @@ -16326,7 +16326,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.vector))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.vector))).toIntern(), .val = (try pt.aggregateValue(vector_field_ty, &field_values)).toIntern(), }))); }, @@ -16339,7 +16339,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.optional))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.optional))).toIntern(), .val = (try pt.aggregateValue(optional_field_ty, &field_values)).toIntern(), }))); }, @@ -16430,7 +16430,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // Construct Type{ .error_set = errors_val } return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_set))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.error_set))).toIntern(), .val = (try pt.aggregateValue(error_set_ty, &field_values)).toIntern(), }))); }, @@ -16445,7 +16445,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.error_union))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.error_union))).toIntern(), .val = (try pt.aggregateValue(error_union_field_ty, &field_values)).toIntern(), }))); }, @@ -16583,7 +16583,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"enum"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.@"enum"))).toIntern(), .val = (try pt.aggregateValue(type_enum_ty, &field_values)).toIntern(), }))); }, @@ -16763,7 +16763,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const field_values = .{ // layout: ContainerLayout, - (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), + (try pt.enumValueFieldIndex(container_layout_ty, @backingInt(layout))).toIntern(), // tag_type: ?type, enum_tag_ty_val, @@ -16782,7 +16782,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"union"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.@"union"))).toIntern(), .val = (try pt.aggregateValue(type_union_ty, &field_values)).toIntern(), }))); }, @@ -17040,7 +17040,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai // is_tuple: bool, Value.makeBool(ty.isTuple(zcu)).toIntern(), // layout: ContainerLayout, - (try pt.enumValueFieldIndex(container_layout_ty, @intFromEnum(layout))).toIntern(), + (try pt.enumValueFieldIndex(container_layout_ty, @backingInt(layout))).toIntern(), // backing_integer: ?type, backing_integer_val, @@ -17056,7 +17056,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"struct"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.@"struct"))).toIntern(), .val = (try pt.aggregateValue(type_struct_ty, &field_values)).toIntern(), }))); }, @@ -17071,7 +17071,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai }; return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.@"opaque"))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.@"opaque"))).toIntern(), .val = (try pt.aggregateValue(type_opaque_ty, &field_values)).toIntern(), }))); }, @@ -17079,7 +17079,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const spirv_info = ip.loadSpirvType(ty.toIntern()); const spirv_union_ty = try sema.getStdLangType(src, .@"Type.Spirv"); const spirv_tag_ty = spirv_union_ty.unionTagType(zcu).?; - const spirv_tag_val = try pt.enumValueFieldIndex(spirv_tag_ty, @intFromEnum(spirv_info.flags.tag)); + const spirv_tag_val = try pt.enumValueFieldIndex(spirv_tag_ty, @backingInt(spirv_info.flags.tag)); const spirv_payload_val: Value = switch (spirv_info.flags.tag) { .sampler => .void, .sampled_image, .runtime_array => .fromInterned(spirv_info.ty), @@ -17091,14 +17091,14 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const depth_ty = try sema.getStdLangType(src, .@"Type.Spirv.Image.Depth"); const access_ty = try sema.getStdLangType(src, .@"Type.Spirv.Image.Access"); const usage_tag_ty = usage_union_ty.unionTagType(zcu).?; - const usage_tag_val = try pt.enumValueFieldIndex(usage_tag_ty, @intFromEnum(spirv_info.flags.usage)); + const usage_tag_val = try pt.enumValueFieldIndex(usage_tag_ty, @backingInt(spirv_info.flags.usage)); const usage_val = try pt.unionValue(usage_union_ty, usage_tag_val, .fromInterned(spirv_info.ty)); const image_field_vals = [_]InternPool.Index{ usage_val.toIntern(), - (try pt.enumValueFieldIndex(format_ty, @intFromEnum(spirv_info.flags.format))).toIntern(), - (try pt.enumValueFieldIndex(dim_ty, @intFromEnum(spirv_info.flags.dim))).toIntern(), - (try pt.enumValueFieldIndex(depth_ty, @intFromEnum(spirv_info.flags.depth))).toIntern(), - (try pt.enumValueFieldIndex(access_ty, @intFromEnum(spirv_info.flags.access))).toIntern(), + (try pt.enumValueFieldIndex(format_ty, @backingInt(spirv_info.flags.format))).toIntern(), + (try pt.enumValueFieldIndex(dim_ty, @backingInt(spirv_info.flags.dim))).toIntern(), + (try pt.enumValueFieldIndex(depth_ty, @backingInt(spirv_info.flags.depth))).toIntern(), + (try pt.enumValueFieldIndex(access_ty, @backingInt(spirv_info.flags.access))).toIntern(), Value.makeBool(spirv_info.flags.is_arrayed).toIntern(), Value.makeBool(spirv_info.flags.is_multisampled).toIntern(), }; @@ -17108,7 +17108,7 @@ fn zirTypeInfo(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const spirv_val = try pt.unionValue(spirv_union_ty, spirv_tag_val, spirv_payload_val); return Air.internedToRef((try pt.internUnion(.{ .ty = type_info_ty.toIntern(), - .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @intFromEnum(std.lang.TypeId.spirv))).toIntern(), + .tag = (try pt.enumValueFieldIndex(type_info_tag_ty, @backingInt(std.lang.TypeId.spirv))).toIntern(), .val = spirv_val.toIntern(), }))); }, @@ -17214,14 +17214,14 @@ fn typeInfoNamespaceDecls( fn zirTypeof(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { _ = block; const zir_datas = sema.code.instructions.items(.data); - const inst_data = zir_datas[@intFromEnum(inst)].un_node; + const inst_data = zir_datas[@backingInt(inst)].un_node; const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); return Air.internedToRef(operand_ty.toIntern()); } fn zirTypeofBuiltin(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const pl_node = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const pl_node = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Block, pl_node.payload_index); const body = sema.code.bodySlice(extra.end, extra.data.body_len); @@ -17245,7 +17245,7 @@ fn zirTypeofBuiltin(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErr } fn zirTypeofLog2IntType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -17324,7 +17324,7 @@ fn zirTypeofPeer( fn zirBoolNot(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.src(.{ .node_offset_un_op = inst_data.src_node }); const uncasted_operand = sema.resolveInst(inst_data.operand); @@ -17356,7 +17356,7 @@ fn zirBoolBr( const gpa = sema.gpa; const datas = sema.code.instructions.items(.data); - const inst_data = datas[@intFromEnum(inst)].pl_node; + const inst_data = datas[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.BoolBr, inst_data.payload_index); const uncoerced_lhs = sema.resolveInst(extra.data.lhs); @@ -17382,7 +17382,7 @@ fn zirBoolBr( return sema.coerce(parent_block, .bool, rhs_result, rhs_src); } - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); try sema.air_instructions.append(gpa, .{ .tag = .block, .data = .{ .ty_pl = .{ @@ -17484,7 +17484,7 @@ fn finishCondBr( .payload = cond_br_payload, } } }); - sema.air_instructions.items(.data)[@intFromEnum(block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity( + sema.air_instructions.items(.data)[@backingInt(block_inst)].ty_pl.payload = sema.addExtraAssumeCapacity( Air.Block{ .body_len = @intCast(child_block.instructions.items.len) }, ); sema.air_extra.appendSliceAssumeCapacity(@ptrCast(child_block.instructions.items)); @@ -17517,7 +17517,7 @@ fn zirIsNonNull( block: *Block, inst: Zir.Inst.Index, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); try sema.checkNullableType(block, src, sema.typeOf(operand)); @@ -17531,7 +17531,7 @@ fn zirIsNonNullPtr( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ptr = sema.resolveInst(inst_data.operand); const ptr_ty = sema.typeOf(ptr); @@ -17565,7 +17565,7 @@ fn checkErrorType(sema: *Sema, block: *Block, src: LazySrcLoc, ty: Type) !void { } fn zirIsNonErr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); try sema.checkErrorType(block, src, sema.typeOf(operand)); @@ -17575,7 +17575,7 @@ fn zirIsNonErr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai fn zirIsNonErrPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ptr = sema.resolveInst(inst_data.operand); const ptr_ty = sema.typeOf(ptr); @@ -17587,7 +17587,7 @@ fn zirIsNonErrPtr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError } fn zirRetIsNonErr(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); return sema.analyzeIsNonErr(block, src, operand); @@ -17600,7 +17600,7 @@ fn zirCondbr( ) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const cond_src = parent_block.src(.{ .node_offset_if_cond = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.CondBr, inst_data.payload_index); @@ -17640,9 +17640,9 @@ fn zirCondbr( const err_cond = blk: { const index = extra.data.condition.toIndex() orelse break :blk null; - if (sema.code.instructions.items(.tag)[@intFromEnum(index)] != .is_non_err) break :blk null; + if (sema.code.instructions.items(.tag)[@backingInt(index)] != .is_non_err) break :blk null; - const err_inst_data = sema.code.instructions.items(.data)[@intFromEnum(index)].un_node; + const err_inst_data = sema.code.instructions.items(.data)[@backingInt(index)].un_node; const err_operand = sema.resolveInst(err_inst_data.operand); const operand_ty = sema.typeOf(err_operand); assert(operand_ty.zigTypeTag(zcu) == .error_union); @@ -17686,7 +17686,7 @@ fn zirCondbr( } fn zirTry(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = parent_block.nodeOffset(inst_data.src_node); const operand_src = parent_block.src(.{ .node_offset_try_operand = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index); @@ -17753,7 +17753,7 @@ fn zirTry(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError! } fn zirTryPtr(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = parent_block.nodeOffset(inst_data.src_node); const operand_src = parent_block.src(.{ .node_offset_try_operand = inst_data.src_node }); const extra = sema.code.extraData(Zir.Inst.Try, inst_data.payload_index); @@ -17835,7 +17835,7 @@ fn ensurePostHoc(sema: *Sema, block: *Block, dest_block: Zir.Inst.Index) !*Label try sema.post_hoc_blocks.ensureUnusedCapacity(sema.gpa, 1); - const new_block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const new_block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); gop.value_ptr.* = new_block_inst.toRef(); try sema.air_instructions.append(sema.gpa, .{ .tag = .block, @@ -17889,7 +17889,7 @@ fn addRuntimeBreak(sema: *Sema, child_block: *Block, block_inst: Zir.Inst.Index, } fn zirUnreachable(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].@"unreachable"; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].@"unreachable"; const src = block.nodeOffset(inst_data.src_node); if (block.isComptime()) { @@ -17918,7 +17918,7 @@ fn zirRetErrValue( const gpa = comp.gpa; const io = comp.io; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].str_tok; const src = block.tokenOffset(inst_data.src_tok); const err_name = try zcu.intern_pool.getOrPutString( gpa, @@ -17944,7 +17944,7 @@ fn zirRetImplicit( ) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_tok; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_tok; const r_brace_src = block.tokenOffset(inst_data.src_tok); if (block.inlining == null and sema.func_is_naked) { assert(!block.isComptime()); @@ -17986,7 +17986,7 @@ fn zirRetImplicit( } fn zirRetNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand = sema.resolveInst(inst_data.operand); const src = block.nodeOffset(inst_data.src_node); @@ -17994,7 +17994,7 @@ fn zirRetNode(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!voi } fn zirRetLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ret_ptr = sema.resolveInst(inst_data.operand); @@ -18053,13 +18053,13 @@ fn maybePushErrorTrace( err_block.instructions.items.len + 1, // the error branch contains the `returnError` call and a `br` ); - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); - const cond_br_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len + 1); - const then_br_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len + 2); - const else_br_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len + 3); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); + const cond_br_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len + 1)); + const then_br_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len + 2)); + const else_br_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len + 3)); const block_payload = sema.addExtraAssumeCapacity(Air.Block{ .body_len = 1 }); - sema.air_extra.appendAssumeCapacity(@intFromEnum(cond_br_inst)); + sema.air_extra.appendAssumeCapacity(@backingInt(cond_br_inst)); sema.air_instructions.appendAssumeCapacity(.{ .tag = .block, .data = .{ .ty_pl = .{ @@ -18080,9 +18080,9 @@ fn maybePushErrorTrace( .else_cov = .none, }, }); - sema.air_extra.appendAssumeCapacity(@intFromEnum(then_br_inst)); + sema.air_extra.appendAssumeCapacity(@backingInt(then_br_inst)); sema.air_extra.appendSliceAssumeCapacity(@ptrCast(err_block.instructions.items)); - sema.air_extra.appendAssumeCapacity(@intFromEnum(else_br_inst)); + sema.air_extra.appendAssumeCapacity(@backingInt(else_br_inst)); sema.air_instructions.appendAssumeCapacity(.{ .tag = .cond_br, .data = .{ .pl_op = .{ @@ -18112,7 +18112,7 @@ fn wantErrorReturnTracing(sema: *Sema) bool { fn zirSaveErrRetIndex(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].save_err_ret_index; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].save_err_ret_index; if (!block.ownerModule().error_tracing) return; @@ -18306,7 +18306,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].ptr_type; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].ptr_type; const extra = sema.code.extraData(Zir.Inst.PtrType, inst_data.payload_index); const elem_ty_src = block.src(.{ .node_offset_ptr_elem = extra.data.src_node }); const sentinel_src = block.src(.{ .node_offset_ptr_sentinel = extra.data.src_node }); @@ -18335,7 +18335,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air var extra_i = extra.end; const sentinel = if (inst_data.flags.has_sentinel) blk: { - const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]); + const ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_i])); extra_i += 1; const coerced = try sema.coerce(block, elem_ty, sema.resolveInst(ref), sentinel_src); const val = try sema.resolveConstDefinedValue(block, sentinel_src, coerced, .{ .simple = .pointer_sentinel }); @@ -18348,7 +18348,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air } else .none; const abi_align: Alignment = if (inst_data.flags.has_align) blk: { - const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]); + const ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_i])); extra_i += 1; const coerced = try sema.coerce(block, align_ty, sema.resolveInst(ref), align_src); const val = try sema.resolveConstDefinedValue(block, align_src, coerced, .{ .simple = .@"align" }); @@ -18357,20 +18357,20 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air } else .none; const address_space: std.lang.AddressSpace = if (inst_data.flags.has_addrspace) blk: { - const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]); + const ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_i])); extra_i += 1; break :blk try sema.resolveAddressSpace(block, addrspace_src, ref, .pointer); } else if (elem_ty.zigTypeTag(zcu) == .@"fn" and target.cpu.arch == .avr) .flash else .generic; const bit_offset: u16 = if (inst_data.flags.has_bit_range) blk: { - const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]); + const ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_i])); extra_i += 1; const bit_offset = try sema.resolveInt(block, bitoffset_src, ref, .u16, .{ .simple = .type }); break :blk @intCast(bit_offset); } else 0; const host_size: u16 = if (inst_data.flags.has_bit_range) blk: { - const ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_i]); + const ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_i])); extra_i += 1; const host_size = try sema.resolveInt(block, hostsize_src, ref, .u16, .{ .simple = .type }); break :blk @intCast(host_size); @@ -18425,7 +18425,7 @@ fn zirPtrType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air } fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const ty_src = block.src(.{ .node_offset_init_ty = inst_data.src_node }); const obj_ty = try sema.resolveType(block, ty_src, inst_data.operand); @@ -18445,7 +18445,7 @@ fn zirStructInitEmpty(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileE fn zirStructInitEmptyResult(sema: *Sema, block: *Block, inst: Zir.Inst.Index, is_byref: bool) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); // Generic poison means this is an untyped anonymous empty struct/array init @@ -18557,7 +18557,7 @@ fn zirUnionInit(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A const pt = sema.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0); const field_src = block.builtinCallArgSrc(inst_data.src_node, 1); const payload_src = block.builtinCallArgSrc(inst_data.src_node, 2); @@ -18601,12 +18601,12 @@ fn zirStructInit( const ip = &zcu.intern_pool; const zir_datas = sema.code.instructions.items(.data); - const inst_data = zir_datas[@intFromEnum(inst)].pl_node; + const inst_data = zir_datas[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.StructInit, inst_data.payload_index); const src = block.nodeOffset(inst_data.src_node); const first_item = sema.code.extraData(Zir.Inst.StructInit.Item, extra.end).data; - const first_field_type_data = zir_datas[@intFromEnum(first_item.field_type)].pl_node; + const first_field_type_data = zir_datas[@backingInt(first_item.field_type)].pl_node; const first_field_type_extra = sema.code.extraData(Zir.Inst.FieldType, first_field_type_data.payload_index).data; const result_ty = try sema.resolveTypeOrPoison(block, src, first_field_type_extra.container_type) orelse { // The type wasn't actually known, so treat this as an anon struct init. @@ -18640,7 +18640,7 @@ fn zirStructInit( const item = sema.code.extraData(Zir.Inst.StructInit.Item, extra_index); extra_index = item.end; - const field_type_data = zir_datas[@intFromEnum(item.data.field_type)].pl_node; + const field_type_data = zir_datas[@backingInt(item.data.field_type)].pl_node; const field_src = block.src(.{ .node_offset_initializer = field_type_data.src_node }); const field_type_extra = sema.code.extraData(Zir.Inst.FieldType, field_type_data.payload_index).data; const field_name = try ip.getOrPutString( @@ -18679,7 +18679,7 @@ fn zirStructInit( const item = sema.code.extraData(Zir.Inst.StructInit.Item, extra.end); - const field_type_data = zir_datas[@intFromEnum(item.data.field_type)].pl_node; + const field_type_data = zir_datas[@backingInt(item.data.field_type)].pl_node; const field_src = block.src(.{ .node_offset_initializer = field_type_data.src_node }); const field_type_extra = sema.code.extraData(Zir.Inst.FieldType, field_type_data.payload_index).data; const field_name = try ip.getOrPutString( @@ -18933,7 +18933,7 @@ fn zirStructInitAnon( block: *Block, inst: Zir.Inst.Index, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.StructInitAnon, inst_data.payload_index); return sema.structInitAnon(block, src, inst, .anon_init, extra.data, extra.end, false); @@ -18984,7 +18984,7 @@ fn structInitAnon( .anon_init => sema.code.nullTerminatedString(item.data.field_name), .typed_init => name: { // `item.data.field_type` references a `field_type` instruction - const field_type_data = zir_datas[@intFromEnum(item.data.field_type)].pl_node; + const field_type_data = zir_datas[@backingInt(item.data.field_type)].pl_node; const field_type_extra = sema.code.extraData(Zir.Inst.FieldType, field_type_data.payload_index); break :name sema.code.nullTerminatedString(field_type_extra.data.name_start); }, @@ -19155,7 +19155,7 @@ fn zirArrayInit( const pt = sema.pt; const zcu = pt.zcu; const gpa = sema.gpa; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index); @@ -19286,7 +19286,7 @@ fn zirArrayInitAnon( block: *Block, inst: Zir.Inst.Index, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index); const operands = sema.code.refSlice(extra.end, extra.data.operands_len); @@ -19406,7 +19406,7 @@ fn addConstantMaybeRef(sema: *Sema, val: Value, is_ref: bool) !Air.Inst.Ref { } fn zirFieldTypeRef(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.FieldTypeRef, inst_data.payload_index).data; const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0); const field_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -19424,7 +19424,7 @@ fn zirStructInitFieldType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) Comp const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.FieldType, inst_data.payload_index).data; const ty_src = block.nodeOffset(inst_data.src_node); const field_name_src = block.src(.{ .node_offset_field_name_init = inst_data.src_node }); @@ -19528,7 +19528,7 @@ fn zirFrame( block: *Block, extended: Zir.Inst.Extended.InstData, ) CompileError!Air.Inst.Ref { - const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: std.zig.Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); const src = block.nodeOffset(src_node); return sema.failWithUseOfAsync(block, src); } @@ -19536,7 +19536,7 @@ fn zirFrame( fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const ty = try sema.resolveType(block, operand_src, inst_data.operand); try sema.ensureLayoutResolved(ty, operand_src, .align_of); @@ -19549,7 +19549,7 @@ fn zirAlignOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -19581,7 +19581,7 @@ fn zirIntFromBool(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError } fn zirErrorName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const uncoerced_operand = sema.resolveInst(inst_data.operand); const operand = try sema.coerce(block, .anyerror, uncoerced_operand, operand_src); @@ -19603,7 +19603,7 @@ fn zirAbs( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand = sema.resolveInst(inst_data.operand); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand_ty = sema.typeOf(operand); @@ -19694,7 +19694,7 @@ fn zirUnaryMath( air_tag: Air.Inst.Tag, comptime eval: fn (Value, Type, Allocator, Zcu.PerThread) Allocator.Error!Value, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand = sema.resolveInst(inst_data.operand); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -19702,7 +19702,7 @@ fn zirUnaryMath( } fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const src = block.nodeOffset(inst_data.src_node); const operand = sema.resolveInst(inst_data.operand); @@ -19752,7 +19752,7 @@ fn zirTagName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air } fn zirReifyInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const signedness_src = block.builtinCallArgSrc(inst_data.src_node, 0); const bits_src = block.builtinCallArgSrc(inst_data.src_node, 1); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -19773,7 +19773,7 @@ fn zirReifySliceArgTy( const zcu = pt.zcu; const extra = sema.code.extraData(Zir.Inst.UnNode, extended.operand).data; - const info: Zir.Inst.ReifySliceArgInfo = @enumFromInt(extended.small); + const info: Zir.Inst.ReifySliceArgInfo = @fromBackingInt(@intCast(extended.small)); const src = block.nodeOffset(extra.node); @@ -20090,7 +20090,7 @@ fn zirReifyStruct( const io = comp.io; const ip = &zcu.intern_pool; - const name_strategy: Zir.Inst.NameStrategy = @enumFromInt(extended.small); + const name_strategy: Zir.Inst.NameStrategy = @fromBackingInt(@intCast(extended.small)); const extra = sema.code.extraData(Zir.Inst.ReifyStruct, extended.operand).data; const tracked_inst = try block.trackZir(inst); @@ -20371,7 +20371,7 @@ fn zirReifyUnion( const io = comp.io; const ip = &zcu.intern_pool; - const name_strategy: Zir.Inst.NameStrategy = @enumFromInt(extended.small); + const name_strategy: Zir.Inst.NameStrategy = @fromBackingInt(@intCast(extended.small)); const extra = sema.code.extraData(Zir.Inst.ReifyUnion, extended.operand).data; const tracked_inst = try block.trackZir(inst); const src: LazySrcLoc = .{ @@ -20592,7 +20592,7 @@ fn zirReifyEnum( const io = comp.io; const ip = &zcu.intern_pool; - const name_strategy: Zir.Inst.NameStrategy = @enumFromInt(extended.small); + const name_strategy: Zir.Inst.NameStrategy = @fromBackingInt(@intCast(extended.small)); const extra = sema.code.extraData(Zir.Inst.ReifyEnum, extended.operand).data; const tracked_inst = try block.trackZir(inst); const src: LazySrcLoc = .{ @@ -21053,7 +21053,7 @@ fn zirCVaEnd(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C } fn zirCVaStart(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) CompileError!Air.Inst.Ref { - const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: std.zig.Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); const src = block.nodeOffset(src_node); const va_list_ty = try sema.getStdLangType(src, .VaList); @@ -21072,7 +21072,7 @@ fn zirTypeName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0); const ty = try sema.resolveType(block, ty_src, inst_data.operand); @@ -21081,7 +21081,7 @@ fn zirTypeName(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } fn zirFrameType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); return sema.failWithUseOfAsync(block, src); } @@ -21089,7 +21089,7 @@ fn zirFrameType(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A fn zirIntFromFloat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -21152,7 +21152,7 @@ fn zirRoundCast( const operand = sema.resolveInst(extra.rhs); - const round_op: Zir.Inst.RoundOp = @enumFromInt(extended.small); + const round_op: Zir.Inst.RoundOp = @fromBackingInt(@intCast(extended.small)); const mode: IntFromFloatMode = switch (round_op) { .round => .round, .floor => .floor, @@ -21266,7 +21266,7 @@ fn zirRoundCast( fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -21308,7 +21308,7 @@ fn zirFloatFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileErro fn zirPtrFromInt(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -21635,7 +21635,7 @@ fn zirPtrCastFull(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstDa } fn zirPtrCast(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -22336,7 +22336,7 @@ fn zirPtrCastNoDest(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.Inst fn zirTruncate(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; @@ -22391,7 +22391,7 @@ fn zirBitCount( ) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand = sema.resolveInst(inst_data.operand); @@ -22439,7 +22439,7 @@ fn zirBitCount( fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -22460,7 +22460,7 @@ fn zirByteSwap(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } fn zirBitReverse(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const operand_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand = sema.resolveInst(inst_data.operand); const operand_ty = sema.typeOf(operand); @@ -22484,7 +22484,7 @@ fn zirOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Ai } fn bitOffsetOf(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!u64 { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const src = block.src(.{ .node_offset_bin_op = inst_data.src_node }); const ty_src = block.builtinCallArgSrc(inst_data.src_node, 0); const field_name_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -23099,13 +23099,13 @@ fn zirCmpxchg( const success_order = try sema.resolveAtomicOrder(block, success_order_src, extra.success_order, .{ .simple = .atomic_order }); const failure_order = try sema.resolveAtomicOrder(block, failure_order_src, extra.failure_order, .{ .simple = .atomic_order }); - if (@intFromEnum(success_order) < @intFromEnum(std.lang.AtomicOrder.monotonic)) { + if (@backingInt(success_order) < @backingInt(std.lang.AtomicOrder.monotonic)) { return sema.fail(block, success_order_src, "success atomic ordering must be monotonic or stricter", .{}); } - if (@intFromEnum(failure_order) < @intFromEnum(std.lang.AtomicOrder.monotonic)) { + if (@backingInt(failure_order) < @backingInt(std.lang.AtomicOrder.monotonic)) { return sema.fail(block, failure_order_src, "failure atomic ordering must be monotonic or stricter", .{}); } - if (@intFromEnum(failure_order) > @intFromEnum(success_order)) { + if (@backingInt(failure_order) > @backingInt(success_order)) { return sema.fail(block, failure_order_src, "failure atomic ordering must be no stricter than success", .{}); } if (failure_order == .release or failure_order == .acq_rel) { @@ -23141,8 +23141,8 @@ fn zirCmpxchg( } else break :rs expected_src; } else ptr_src; - const flags: u32 = @as(u32, @intFromEnum(success_order)) | - (@as(u32, @intFromEnum(failure_order)) << 3); + const flags: u32 = @as(u32, @backingInt(success_order)) | + (@as(u32, @backingInt(failure_order)) << 3); try sema.requireRuntimeBlock(block, src, runtime_src); return block.addInst(.{ @@ -23162,7 +23162,7 @@ fn zirCmpxchg( fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); const scalar_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -23214,7 +23214,7 @@ fn zirSplat(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.I } fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const op_src = block.builtinCallArgSrc(inst_data.src_node, 0); const operand_src = block.builtinCallArgSrc(inst_data.src_node, 1); @@ -23282,7 +23282,7 @@ fn zirReduce(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. fn zirShuffle(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Shuffle, inst_data.payload_index).data; const elem_ty_src = block.builtinCallArgSrc(inst_data.src_node, 0); const mask_src = block.builtinCallArgSrc(inst_data.src_node, 3); @@ -23564,7 +23564,7 @@ fn zirSelect(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstData) C } fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.AtomicLoad, inst_data.payload_index).data; // zig fmt: off const elem_ty_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -23611,7 +23611,7 @@ fn zirAtomicLoad(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError! fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.AtomicRmw, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); // zig fmt: off @@ -23676,7 +23676,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A } else break :rs ptr_src; } else ptr_src; - const flags: u32 = @as(u32, @intFromEnum(order)) | (@as(u32, @intFromEnum(op)) << 3); + const flags: u32 = @as(u32, @backingInt(order)) | (@as(u32, @backingInt(op)) << 3); try sema.requireRuntimeBlock(block, src, runtime_src); return block.addInst(.{ @@ -23692,7 +23692,7 @@ fn zirAtomicRmw(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A } fn zirAtomicStore(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.AtomicStore, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); // zig fmt: off @@ -23726,7 +23726,7 @@ fn zirAtomicStore(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError } fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.MulAdd, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); @@ -23793,7 +23793,7 @@ fn zirMulAdd(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air. fn zirBuiltinCall(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { const pt = sema.pt; const zcu = pt.zcu; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const modifier_src = block.builtinCallArgSrc(inst_data.src_node, 0); const func_src = block.builtinCallArgSrc(inst_data.src_node, 1); const args_src = block.builtinCallArgSrc(inst_data.src_node, 2); @@ -24081,7 +24081,7 @@ fn zirMinMax( inst: Zir.Inst.Index, comptime air_tag: Air.Inst.Tag, ) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); const lhs_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -24262,10 +24262,10 @@ fn analyzeMinMax( }, else => unreachable, }; - if (@intFromEnum(want_strat) < @intFromEnum(cur_strat)) { + if (@backingInt(want_strat) < @backingInt(cur_strat)) { // `want_strat` overrides `cur_strat`. cur_strat = want_strat; - } else if (@intFromEnum(want_strat) == @intFromEnum(cur_strat)) { + } else if (@backingInt(want_strat) == @backingInt(cur_strat)) { // The behavior depends on the tag. switch (cur_strat) { .none, .comptime_float => {}, // no payload, so nop @@ -24470,7 +24470,7 @@ fn zirMemcpy( air_tag: Air.Inst.Tag, check_aliasing: bool, ) CompileError!void { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); const dest_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -24734,7 +24734,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; const src = block.nodeOffset(inst_data.src_node); const dest_src = block.builtinCallArgSrc(inst_data.src_node, 0); @@ -24830,7 +24830,7 @@ fn zirMemset(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!void } fn zirResume(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!Air.Inst.Ref { - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].un_node; const src = block.nodeOffset(inst_data.src_node); return sema.failWithUseOfAsync(block, src); } @@ -24843,7 +24843,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A const io = comp.io; const ip = &zcu.intern_pool; - const inst_data = sema.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = sema.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = sema.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index); const target = zcu.getTarget(); @@ -24863,7 +24863,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A const val = try sema.resolveGenericBody(block, cc_src, body, inst, cc_ty, .{ .simple = .@"callconv" }); break :blk try sema.analyzeValueAsCallconv(block, cc_src, val); } else if (extra.data.bits.has_cc_ref) blk: { - const cc_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); + const cc_ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_index])); extra_index += 1; const cc_ty = try sema.getStdLangType(cc_src, .CallingConvention); const uncoerced_cc = sema.resolveInst(cc_ref); @@ -24907,7 +24907,7 @@ fn zirFuncFancy(sema: *Sema, block: *Block, inst: Zir.Inst.Index) CompileError!A const ty = val.toType(); break :blk ty; } else if (extra.data.bits.has_ret_ty_ref) blk: { - const ret_ty_ref: Zir.Inst.Ref = @enumFromInt(sema.code.extra[extra_index]); + const ret_ty_ref: Zir.Inst.Ref = @fromBackingInt(@intCast(sema.code.extra[extra_index])); extra_index += 1; if (extra.data.bits.ret_ty_is_generic) break :blk .generic_poison; @@ -25330,9 +25330,9 @@ fn zirStdLangValue(sema: *Sema, block: *Block, extended: Zir.Inst.Extended.InstD const io = comp.io; const ip = &zcu.intern_pool; - const src_node: std.zig.Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: std.zig.Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); const src = block.nodeOffset(src_node); - const value: Zir.Inst.StdLangValue = @enumFromInt(extended.small); + const value: Zir.Inst.StdLangValue = @fromBackingInt(@intCast(extended.small)); const std_lang_type: Zcu.StdLangDecl = switch (value) { // zig fmt: off @@ -25387,10 +25387,10 @@ fn zirInplaceArithResultTy(sema: *Sema, extended: Zir.Inst.Extended.InstData) Co const pt = sema.pt; const zcu = pt.zcu; - const lhs = sema.resolveInst(@enumFromInt(extended.operand)); + const lhs = sema.resolveInst(@fromBackingInt(@intCast(extended.operand))); const lhs_ty = sema.typeOf(lhs); - const op: Zir.Inst.InplaceOp = @enumFromInt(extended.small); + const op: Zir.Inst.InplaceOp = @fromBackingInt(@intCast(extended.small)); const ty: Type = switch (op) { .add_eq => ty: { const ptr_size = lhs_ty.ptrSizeOrNull(zcu) orelse break :ty lhs_ty; @@ -25840,9 +25840,9 @@ fn addSafetyCheckExtra( fail_block.instructions.items.len); try sema.air_instructions.ensureUnusedCapacity(gpa, 3); - const block_inst: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); - const cond_br_inst: Air.Inst.Index = @enumFromInt(@intFromEnum(block_inst) + 1); - const br_inst: Air.Inst.Index = @enumFromInt(@intFromEnum(cond_br_inst) + 1); + const block_inst: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); + const cond_br_inst: Air.Inst.Index = @fromBackingInt(@intCast(@backingInt(block_inst) + 1)); + const br_inst: Air.Inst.Index = @fromBackingInt(@intCast(@backingInt(cond_br_inst) + 1)); sema.air_instructions.appendAssumeCapacity(.{ .tag = .block, .data = .{ .ty_pl = .{ @@ -25852,7 +25852,7 @@ fn addSafetyCheckExtra( }), } }, }); - sema.air_extra.appendAssumeCapacity(@intFromEnum(cond_br_inst)); + sema.air_extra.appendAssumeCapacity(@backingInt(cond_br_inst)); sema.air_instructions.appendAssumeCapacity(.{ .tag = .cond_br, @@ -25874,7 +25874,7 @@ fn addSafetyCheckExtra( }, }, }); - sema.air_extra.appendAssumeCapacity(@intFromEnum(br_inst)); + sema.air_extra.appendAssumeCapacity(@backingInt(br_inst)); sema.air_extra.appendSliceAssumeCapacity(@ptrCast(fail_block.instructions.items)); sema.air_instructions.appendAssumeCapacity(.{ @@ -26313,8 +26313,8 @@ fn analyzeSpirvRuntimeArrayLen( const struct_operand: Air.Inst.Ref, const field_index: u32 = sf: { if (runtime_array_ptr.toIndex()) |inst| { - const tag = sema.air_instructions.items(.tag)[@intFromEnum(inst)]; - const data = sema.air_instructions.items(.data)[@intFromEnum(inst)]; + const tag = sema.air_instructions.items(.tag)[@backingInt(inst)]; + const data = sema.air_instructions.items(.data)[@backingInt(inst)]; switch (tag) { .struct_field_ptr => { const extra = sema.getTmpAir().extraData(Air.StructField, data.ty_pl.payload).data; @@ -27592,7 +27592,7 @@ fn elemPtrVector( .is_volatile = vector_ptr_info.flags.is_volatile, .is_allowzero = vector_ptr_info.flags.is_allowzero, .address_space = vector_ptr_info.flags.address_space, - .vector_index = @enumFromInt(index), + .vector_index = @fromBackingInt(@intCast(index)), }, .packed_offset = .{ .host_size = @intCast(vector_len), @@ -29754,7 +29754,7 @@ fn storePtr2( /// Handles calling `validateRuntimeValue` if the store is runtime for any reason. fn checkComptimeKnownStore(sema: *Sema, block: *Block, store_inst_ref: Air.Inst.Ref, store_src: LazySrcLoc) !void { const store_inst = store_inst_ref.toIndex().?; - const inst_data = sema.air_instructions.items(.data)[@intFromEnum(store_inst)].bin_op; + const inst_data = sema.air_instructions.items(.data)[@backingInt(store_inst)].bin_op; const ptr = inst_data.lhs.toIndex() orelse return; const operand = inst_data.rhs; @@ -29788,7 +29788,7 @@ fn checkKnownAllocPtr(sema: *Sema, block: *Block, base_ptr: Air.Inst.Ref, new_pt const alloc_inst = sema.base_allocs.get(base_ptr_inst) orelse return; try sema.base_allocs.put(sema.gpa, new_ptr_inst, alloc_inst); - switch (sema.air_instructions.items(.tag)[@intFromEnum(new_ptr_inst)]) { + switch (sema.air_instructions.items(.tag)[@backingInt(new_ptr_inst)]) { .optional_payload_ptr_set, .errunion_payload_ptr_set => { const maybe_comptime_alloc = sema.maybe_comptime_allocs.getPtr(alloc_inst) orelse return; @@ -29805,7 +29805,7 @@ fn checkKnownAllocPtr(sema: *Sema, block: *Block, base_ptr: Air.Inst.Ref, new_pt }, .ptr_elem_ptr => { const tmp_air = sema.getTmpAir(); - const pl_idx = tmp_air.instructions.items(.data)[@intFromEnum(new_ptr_inst)].ty_pl.payload; + const pl_idx = tmp_air.instructions.items(.data)[@backingInt(new_ptr_inst)].ty_pl.payload; const bin = tmp_air.extraData(Air.Bin, pl_idx).data; const index_ref = bin.rhs; @@ -29826,12 +29826,12 @@ fn markMaybeComptimeAllocRuntime(sema: *Sema, block: *Block, alloc_inst: Air.Ins const slice = maybe_comptime_alloc.stores.slice(); for (slice.items(.inst), slice.items(.src)) |other_inst, other_src| { if (other_src.offset == .unneeded) { - switch (sema.air_instructions.items(.tag)[@intFromEnum(other_inst)]) { + switch (sema.air_instructions.items(.tag)[@backingInt(other_inst)]) { .set_union_tag, .optional_payload_ptr_set, .errunion_payload_ptr_set => continue, else => unreachable, // assertion failure } } - const other_data = sema.air_instructions.items(.data)[@intFromEnum(other_inst)].bin_op; + const other_data = sema.air_instructions.items(.data)[@backingInt(other_inst)].bin_op; const other_operand = other_data.rhs; try sema.validateRuntimeValue(block, other_src, other_operand); } @@ -32174,7 +32174,7 @@ const PeerResolveStrategy = enum { // Our merging should be order-independent. Thus, even though the union order is arbitrary, // by sorting the tags and switching first on the smaller, we have half as many cases to // worry about (since we avoid the duplicates). - const s0_is_a = @intFromEnum(a) <= @intFromEnum(b); + const s0_is_a = @backingInt(a) <= @backingInt(b); const s0 = if (s0_is_a) a else b; const s1 = if (s0_is_a) b else a; @@ -33839,7 +33839,7 @@ fn payloadToExtraItems(data: anytype) [@typeInfo(@TypeOf(data)).@"struct".field_ val.* = switch (field_type) { u32 => @field(data, field_name), i32, Air.CondBr.BranchHints, Air.Asm.Flags => @bitCast(@field(data, field_name)), - Air.Inst.Ref, InternPool.Index => @intFromEnum(@field(data, field_name)), + Air.Inst.Ref, InternPool.Index => @backingInt(@field(data, field_name)), else => @compileError("bad field type: " ++ @typeName(field_type)), }; } @@ -33853,8 +33853,8 @@ fn appendRefsAssumeCapacity(sema: *Sema, refs: []const Air.Inst.Ref) void { fn getBreakBlock(sema: *Sema, inst_index: Air.Inst.Index) ?Air.Inst.Index { const air_datas = sema.air_instructions.items(.data); const air_tags = sema.air_instructions.items(.tag); - switch (air_tags[@intFromEnum(inst_index)]) { - .br => return air_datas[@intFromEnum(inst_index)].br.block_inst, + switch (air_tags[@backingInt(inst_index)]) { + .br => return air_datas[@backingInt(inst_index)].br.block_inst, else => return null, } } @@ -34596,7 +34596,7 @@ pub fn flushExports(sema: *Sema) !void { try zcu.single_exports.ensureUnusedCapacity(gpa, 1); const export_idx: Zcu.Export.Index = zcu.free_exports.pop() orelse idx: { _ = try zcu.all_exports.addOne(gpa); - break :idx @enumFromInt(zcu.all_exports.items.len - 1); + break :idx @fromBackingInt(@intCast(zcu.all_exports.items.len - 1)); }; export_idx.ptr(zcu).* = sema.exports.items[0]; zcu.single_exports.putAssumeCapacityNoClobber(sema.owner, export_idx); @@ -34920,7 +34920,7 @@ pub fn setTypeName( io, pt.tid, "{f}__{s}_{d}", - .{ block.type_name_ctx.fmt(ip), anon_prefix, @intFromEnum(wip.index) }, + .{ block.type_name_ctx.fmt(ip), anon_prefix, @backingInt(wip.index) }, .no_embedded_nulls, ), .none); }, @@ -34935,7 +34935,7 @@ pub fn setTypeName( w.print("{f}(", .{block.type_name_ctx.fmt(ip)}) catch return error.OutOfMemory; var arg_i: usize = 0; - for (fn_info.param_body) |zir_inst| switch (zir_tags[@intFromEnum(zir_inst)]) { + for (fn_info.param_body) |zir_inst| switch (zir_tags[@backingInt(zir_inst)]) { .param, .param_comptime, .param_anytype, .param_anytype_comptime => { const arg = sema.inst_map.get(zir_inst).?; // If this is being called in a generic function then analyzeCall will @@ -34975,7 +34975,7 @@ pub fn setTypeName( const ref = inst.toRef(); const zir_tags = sema.code.instructions.items(.tag); const zir_data = sema.code.instructions.items(.data); - const var_name = for (@intFromEnum(inst)..zir_tags.len) |i| switch (zir_tags[i]) { + const var_name = for (@backingInt(inst)..zir_tags.len) |i| switch (zir_tags[i]) { .dbg_var_ptr, .dbg_var_val => if (zir_data[i].str_op.operand == ref) { break zir_data[i].str_op.getStr(sema.code); }, diff --git a/src/Sema/comptime_ptr_access.zig b/src/Sema/comptime_ptr_access.zig index 4df8dafbe03bddd71ca212af1cf1ebebfdfe1e04..bc56aed0818a8dd405d5935a5229ddfbaa2c4d50 100644 --- a/src/Sema/comptime_ptr_access.zig +++ b/src/Sema/comptime_ptr_access.zig @@ -40,7 +40,7 @@ pub fn loadComptimePtr(sema: *Sema, block: *Block, src: LazySrcLoc, ptr: Value) const result_val: Value = try .readFromPackedMemory(elem_ty, pt, buf, ptr_info.packed_offset.bit_offset); return .{ .success = .{ .interned = result_val.toIntern() } }; } - if (@intFromEnum(ptr_info.flags.vector_index) >= host_size) { + if (@backingInt(ptr_info.flags.vector_index) >= host_size) { return .exceeds_host_size; } const load_ty: Type = try pt.vectorType(.{ @@ -52,7 +52,7 @@ pub fn loadComptimePtr(sema: *Sema, block: *Block, src: LazySrcLoc, ptr: Value) .success => |mv| mv, }; const vector_val = try vector_mv.intern(pt, sema.arena); - const result_val = try vector_val.elemValue(pt, @intFromEnum(ptr_info.flags.vector_index)); + const result_val = try vector_val.elemValue(pt, @backingInt(ptr_info.flags.vector_index)); return .{ .success = .{ .interned = result_val.toIntern() } }; } @@ -115,7 +115,7 @@ pub fn storeComptimePtr( return storeComptimePtrInner(sema, block, src, ptr, new_backing_int_val); } - if (@intFromEnum(ptr_info.flags.vector_index) >= host_size) { + if (@backingInt(ptr_info.flags.vector_index) >= host_size) { return .exceeds_host_size; } const vec_ty: Type = try pt.vectorType(.{ @@ -133,7 +133,7 @@ pub fn storeComptimePtr( const elem_val = try old_vector_val.elemValue(pt, elem_index); elem.* = elem_val.toIntern(); } - elems_buf[@intFromEnum(ptr_info.flags.vector_index)] = store_val.toIntern(); + elems_buf[@backingInt(ptr_info.flags.vector_index)] = store_val.toIntern(); const new_vector_val = try pt.aggregateValue(vec_ty, elems_buf); return storeComptimePtrInner(sema, block, src, ptr, new_vector_val); } @@ -1076,7 +1076,7 @@ fn checkComptimeVarStore( alloc_index: ComptimeAllocIndex, ) !void { const runtime_index = sema.getComptimeAlloc(alloc_index).runtime_index; - if (@intFromEnum(runtime_index) < @intFromEnum(block.runtime_index)) { + if (@backingInt(runtime_index) < @backingInt(block.runtime_index)) { if (block.runtime_cond) |cond_src| { const msg = msg: { const msg = try sema.errMsg(src, "store to comptime variable depends on runtime condition", .{}); diff --git a/src/Sema/type_resolution.zig b/src/Sema/type_resolution.zig index 6cdd65667aae567a7939c7a1a7b95831cc39672e..ef8e24c86744023e52bef9d9c2d0f1f029936852 100644 --- a/src/Sema/type_resolution.zig +++ b/src/Sema/type_resolution.zig @@ -375,7 +375,7 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void { } struct_align = struct_align.maxStrict(field_align); if (struct_obj.layout == .auto) { - struct_obj.field_runtime_order.get(ip)[field_idx] = @enumFromInt(field_idx); + struct_obj.field_runtime_order.get(ip)[field_idx] = @fromBackingInt(@intCast(field_idx)); } switch (field_ty.classify(zcu)) { .one_possible_value => {}, @@ -428,8 +428,8 @@ pub fn resolveStructLayout(sema: *Sema, struct_ty: Type) CompileError!void { assert(b != .unresolved); if (a == .omitted) return false; if (b == .omitted) return true; - const a_align = ctx.aligns[@intFromEnum(a)]; - const b_align = ctx.aligns[@intFromEnum(b)]; + const a_align = ctx.aligns[@backingInt(a)]; + const b_align = ctx.aligns[@backingInt(b)]; return a_align.compare(.gt, b_align); } }; diff --git a/src/Type.zig b/src/Type.zig index 37476ceb060a007d1b21d0038307ddff842bbe87..e60726ced3ff48df988eff1505786071c596ff2a 100644 --- a/src/Type.zig +++ b/src/Type.zig @@ -476,7 +476,7 @@ pub fn print(ty: Type, writer: *std.Io.Writer, pt: Zcu.PerThread, ctx: ?*Compari }); } if (info.flags.vector_index != .none) { - try writer.print(":{d}", .{@intFromEnum(info.flags.vector_index)}); + try writer.print(":{d}", .{@backingInt(info.flags.vector_index)}); } try writer.writeAll(") "); } @@ -2660,7 +2660,7 @@ pub fn typeDeclSrcLine(ty: Type, zcu: *Zcu) ?u32 { .zig => file.zir.?, .zon => return 0, }; - const inst = zir.instructions.get(@intFromEnum(info.inst)); + const inst = zir.instructions.get(@backingInt(info.inst)); return switch (inst.tag) { .struct_init, .struct_init_ref => zir.extraData(Zir.Inst.StructInit, inst.data.pl_node.payload_index).data.abs_line, .struct_init_anon => zir.extraData(Zir.Inst.StructInitAnon, inst.data.pl_node.payload_index).data.abs_line, diff --git a/src/Value.zig b/src/Value.zig index adcd7abfce33e2a3c40e5d405e3dc49c67e0769d..dfc124659c3f6d9fb3be15430a5734ff2a3fe194 100644 --- a/src/Value.zig +++ b/src/Value.zig @@ -2373,7 +2373,7 @@ pub fn uninterpret(val: anytype, ty: Type, pt: Zcu.PerThread) error{ OutOfMemory try pt.nullValue(ty), .@"enum" => switch (interpret_mode) { - .direct => try pt.enumValue(ty, try uninterpret(@intFromEnum(val), ty.backingIntType(zcu), pt)), + .direct => try pt.enumValue(ty, try uninterpret(@backingInt(val), ty.backingIntType(zcu), pt)), .by_name => { const field_name_ip = try ip.getOrPutString(zcu.gpa, io, pt.tid, @tagName(val), .no_embedded_nulls); const field_idx = ty.enumFieldIndex(field_name_ip, zcu) orelse return error.TypeMismatch; diff --git a/src/Zcu.zig b/src/Zcu.zig index 0006a17e65bb923b5969c2c45da24aa29a05fa78..d3c180b63eb8854ec8598cdb3099bba7a41fb2b3 100644 --- a/src/Zcu.zig +++ b/src/Zcu.zig @@ -402,7 +402,7 @@ pub const ImportTableAdapter = struct { zcu: *const Zcu, pub fn hash(ctx: ImportTableAdapter, path: Compilation.Path) u32 { _ = ctx; - return @truncate(std.hash.Wyhash.hash(@intFromEnum(path.root), path.sub_path)); + return @truncate(std.hash.Wyhash.hash(@backingInt(path.root), path.sub_path)); } pub fn eql(ctx: ImportTableAdapter, a_path: Compilation.Path, b_file: File.Index, b_index: usize) bool { _ = b_index; @@ -414,7 +414,7 @@ pub const ImportTableAdapter = struct { pub const EmbedTableAdapter = struct { pub fn hash(ctx: EmbedTableAdapter, path: Compilation.Path) u32 { _ = ctx; - return @truncate(std.hash.Wyhash.hash(@intFromEnum(path.root), path.sub_path)); + return @truncate(std.hash.Wyhash.hash(@backingInt(path.root), path.sub_path)); } pub fn eql(ctx: EmbedTableAdapter, a_path: Compilation.Path, b_file: *EmbedFile, b_index: usize) bool { _ = ctx; @@ -614,7 +614,7 @@ pub const StdLangDecl = enum { .VaList => .va_list, .assembly, .@"assembly.Clobbers" => .assembly, else => { - if (@intFromEnum(decl) <= @intFromEnum(StdLangDecl.@"Type.Spirv.Image.Access")) { + if (@backingInt(decl) <= @backingInt(StdLangDecl.@"Type.Spirv.Image.Access")) { return .main; } else { return .panic; @@ -635,7 +635,7 @@ pub const StdLangDecl = enum { const name = @tagName(tag); const split = (comptime std.mem.lastIndexOfScalar(u8, name, '.')) orelse return .{ .direct = name }; const parent = @field(StdLangDecl, name[0..split]); - comptime assert(@intFromEnum(parent) < @intFromEnum(tag)); // dependencies ordered correctly + comptime assert(@backingInt(parent) < @backingInt(tag)); // dependencies ordered correctly return .{ .nested = .{ parent, name[split + 1 ..] } }; }, }; @@ -757,7 +757,7 @@ pub const Export = struct { _, pub fn ptr(i: Index, zcu: *const Zcu) *Export { - return &zcu.all_exports.items[@intFromEnum(i)]; + return &zcu.all_exports.items[@backingInt(i)]; } }; }; @@ -769,10 +769,10 @@ pub const CompileLogLine = struct { pub const Index = enum(u32) { _, pub fn get(idx: Index, zcu: *Zcu) *CompileLogLine { - return &zcu.compile_log_lines.items[@intFromEnum(idx)]; + return &zcu.compile_log_lines.items[@backingInt(idx)]; } pub fn toOptional(idx: Index) Optional { - return @enumFromInt(@intFromEnum(idx)); + return @fromBackingInt(@intCast(@backingInt(idx))); } pub const Optional = enum(u32) { none = std.math.maxInt(u32), @@ -780,7 +780,7 @@ pub const CompileLogLine = struct { pub fn unwrap(opt: Optional) ?Index { return switch (opt) { .none => null, - _ => @enumFromInt(@intFromEnum(opt)), + _ => @fromBackingInt(@intCast(@backingInt(opt))), }; } }; @@ -815,10 +815,10 @@ pub const InlineReferenceFrame = struct { pub const Index = enum(u32) { _, pub fn ptr(idx: Index, zcu: *Zcu) *InlineReferenceFrame { - return &zcu.inline_reference_frames.items[@intFromEnum(idx)]; + return &zcu.inline_reference_frames.items[@backingInt(idx)]; } pub fn toOptional(idx: Index) Optional { - return @enumFromInt(@intFromEnum(idx)); + return @fromBackingInt(@intCast(@backingInt(idx))); } pub const Optional = enum(u32) { none = std.math.maxInt(u32), @@ -826,7 +826,7 @@ pub const InlineReferenceFrame = struct { pub fn unwrap(opt: Optional) ?Index { return switch (opt) { .none => null, - _ => @enumFromInt(@intFromEnum(opt)), + _ => @fromBackingInt(@intCast(@backingInt(opt))), }; } }; @@ -869,7 +869,7 @@ pub const Namespace = struct { pub fn hash(ctx: NavNameContext, nav: InternPool.Nav.Index) u32 { const name = ctx.zcu.intern_pool.getNav(nav).name; - return std.hash.int(@intFromEnum(name)); + return std.hash.int(@backingInt(name)); } pub fn eql(ctx: NavNameContext, a_nav: InternPool.Nav.Index, b_nav: InternPool.Nav.Index, b_index: usize) bool { @@ -885,7 +885,7 @@ pub const Namespace = struct { pub fn hash(ctx: NameAdapter, s: InternPool.NullTerminatedString) u32 { _ = ctx; - return std.hash.int(@intFromEnum(s)); + return std.hash.int(@backingInt(s)); } pub fn eql(ctx: NameAdapter, a: InternPool.NullTerminatedString, b_nav: InternPool.Nav.Index, b_index: usize) bool { @@ -1235,7 +1235,7 @@ pub const EmbedFile = struct { pub const Index = enum(u32) { _, pub fn get(idx: Index, zcu: *const Zcu) *EmbedFile { - return zcu.embed_table.keys()[@intFromEnum(idx)]; + return zcu.embed_table.keys()[@backingInt(idx)]; } }; }; @@ -1625,7 +1625,7 @@ pub const SrcLoc = struct { // that contains this input. const node_tags = tree.nodes.items(.tag); for (node_tags, 0..) |node_tag, node_usize| { - const node: Ast.Node.Index = @enumFromInt(node_usize); + const node: Ast.Node.Index = @fromBackingInt(@intCast(node_usize)); switch (node_tag) { .for_simple, .@"for" => { const for_full = tree.fullFor(node).?; @@ -1665,7 +1665,7 @@ pub const SrcLoc = struct { var buf: [2]Ast.Node.Index = undefined; const call_full = tree.fullCall(buf[0..1], node) orelse { assert(tree.nodeTag(node) == .builtin_call); - const call_args_node: Ast.Node.Index = @enumFromInt(tree.extra_data[@intFromEnum(tree.nodeData(node).extra_range.end) - 1]); + const call_args_node: Ast.Node.Index = @fromBackingInt(@intCast(tree.extra_data[@backingInt(tree.nodeData(node).extra_range.end) - 1])); switch (tree.nodeTag(call_args_node)) { .array_init_one, .array_init_one_comma, @@ -2740,7 +2740,7 @@ pub const LazySrcLoc = struct { // Otherwise, make sure ZIR is loaded. const zir = file.zir.?; - const inst = zir.instructions.get(@intFromEnum(zir_inst)); + const inst = zir.instructions.get(@backingInt(zir_inst)); const base_node: Ast.Node.Index = switch (inst.tag) { .declaration => inst.data.declaration.src_node, .struct_init, .struct_init_ref => zir.extraData(Zir.Inst.StructInit, inst.data.pl_node.payload_index).data.abs_node, @@ -2789,7 +2789,7 @@ pub const LazySrcLoc = struct { if (lhs_resolved.file_scope != rhs_resolved.file_scope) { const lhs_path = lhs_resolved.file_scope.path; const rhs_path = rhs_resolved.file_scope.path; - return std.math.order(@intFromEnum(lhs_path.root), @intFromEnum(rhs_path.root)).differ() orelse + return std.math.order(@backingInt(lhs_path.root), @backingInt(rhs_path.root)).differ() orelse std.mem.order(u8, lhs_path.sub_path, rhs_path.sub_path).differ().?; } const prev_prot = zcu.comp.io.swapCancelProtection(.blocked); @@ -3009,10 +3009,10 @@ pub fn loadZirCacheBody(gpa: Allocator, header: Zir.Header, cache_br: *Io.Reader if (data_has_safety_tag) { const tags = zir.instructions.items(.tag); for (zir.instructions.items(.data), 0..) |*data, i| { - const union_tag = Zir.Inst.Tag.data_tags[@intFromEnum(tags[i])]; + const union_tag = Zir.Inst.Tag.data_tags[@backingInt(tags[i])]; const as_struct = @as(*HackDataLayout, @ptrCast(data)); as_struct.* = .{ - .safety_tag = @intFromEnum(union_tag), + .safety_tag = @backingInt(union_tag), .data = safety_buffer[i], }; } @@ -3408,8 +3408,8 @@ pub fn mapOldZirToNew( // updates. If they have, we need to ignore this mapping. These properties are essentially // everything passed into `InternPool.getDeclaredStructType` (likewise for unions, enums, // and opaques). - const old_tag = old_zir.instructions.items(.data)[@intFromEnum(match_item.old_inst)].extended.opcode; - const new_tag = new_zir.instructions.items(.data)[@intFromEnum(match_item.new_inst)].extended.opcode; + const old_tag = old_zir.instructions.items(.data)[@backingInt(match_item.old_inst)].extended.opcode; + const new_tag = new_zir.instructions.items(.data)[@backingInt(match_item.new_inst)].extended.opcode; if (old_tag != new_tag) continue; switch (old_tag) { .struct_decl => { @@ -3756,7 +3756,7 @@ pub fn resetUnit(zcu: *Zcu, unit: AnalUnit) void { exports: { const base: u32, const len: u32 = index: { if (zcu.single_exports.fetchSwapRemove(unit)) |kv| { - break :index .{ @intFromEnum(kv.value), 1 }; + break :index .{ @backingInt(kv.value), 1 }; } if (zcu.multi_exports.fetchSwapRemove(unit)) |kv| { break :index .{ kv.value.index, kv.value.len }; @@ -3764,7 +3764,7 @@ pub fn resetUnit(zcu: *Zcu, unit: AnalUnit) void { break :exports; }; for (zcu.all_exports.items[base..][0..len], base..) |exp, exp_index_usize| { - const exp_index: Export.Index = @enumFromInt(exp_index_usize); + const exp_index: Export.Index = @fromBackingInt(@intCast(exp_index_usize)); if (zcu.llvm_object) |llvm_object| { _ = llvm_object; // TODO: delete exports from LLVM } else if (zcu.comp.bin_file) |lf| { @@ -3780,7 +3780,7 @@ pub fn resetUnit(zcu: *Zcu, unit: AnalUnit) void { break :exports; }; for (base..base + len) |exp_index| { - zcu.free_exports.appendAssumeCapacity(@enumFromInt(exp_index)); + zcu.free_exports.appendAssumeCapacity(@fromBackingInt(@intCast(exp_index))); } } @@ -3836,7 +3836,7 @@ pub fn resetUnit(zcu: *Zcu, unit: AnalUnit) void { pub fn addInlineReferenceFrame(zcu: *Zcu, frame: InlineReferenceFrame) Allocator.Error!Zcu.InlineReferenceFrame.Index { const frame_idx: InlineReferenceFrame.Index = zcu.free_inline_reference_frames.pop() orelse idx: { _ = try zcu.inline_reference_frames.addOne(zcu.gpa); - break :idx @enumFromInt(zcu.inline_reference_frames.items.len - 1); + break :idx @fromBackingInt(@intCast(zcu.inline_reference_frames.items.len - 1)); }; frame_idx.ptr(zcu).* = frame; return frame_idx; @@ -4251,7 +4251,7 @@ fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.array_hash_map.Auto(Ana if (!gop.found_existing) { refs_log.debug("type '{f}': ref comptime %{}", .{ Type.fromInterned(ty).containerTypeName(ip).fmt(ip), - @intFromEnum(ip.getComptimeUnit(cu).zir_index.resolve(ip) orelse continue), + @backingInt(ip.getComptimeUnit(cu).zir_index.resolve(ip) orelse continue), }); gop.value_ptr.* = referencer; } @@ -4285,7 +4285,7 @@ fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.array_hash_map.Auto(Ana if (!gop.found_existing) { refs_log.debug("type '{f}': ref test %{}", .{ Type.fromInterned(ty).containerTypeName(ip).fmt(ip), - @intFromEnum(inst_info.inst), + @backingInt(inst_info.inst), }); gop.value_ptr.* = referencer; } @@ -4308,7 +4308,7 @@ fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.array_hash_map.Auto(Ana if (!gop.found_existing) { refs_log.debug("type '{f}': ref named %{}", .{ Type.fromInterned(ty).containerTypeName(ip).fmt(ip), - @intFromEnum(inst_info.inst), + @backingInt(inst_info.inst), }); gop.value_ptr.* = referencer; } @@ -4325,7 +4325,7 @@ fn resolveReferencesInner(zcu: *Zcu) Allocator.Error!std.array_hash_map.Auto(Ana if (!gop.found_existing) { refs_log.debug("type '{f}': ref named %{}", .{ Type.fromInterned(ty).containerTypeName(ip).fmt(ip), - @intFromEnum(inst_info.inst), + @backingInt(inst_info.inst), }); gop.value_ptr.* = referencer; } @@ -4494,16 +4494,16 @@ fn formatAnalUnit(data: FormatAnalUnit, writer: *Io.Writer) Io.Writer.Error!void const cu = ip.getComptimeUnit(cu_id); if (cu.zir_index.resolveFull(ip)) |resolved| { const file_path = zcu.fileByIndex(resolved.file).path; - return writer.print("comptime(inst=('{f}', %{}) [{}])", .{ file_path.fmt(zcu.comp), @intFromEnum(resolved.inst), @intFromEnum(cu_id) }); + return writer.print("comptime(inst=('{f}', %{}) [{}])", .{ file_path.fmt(zcu.comp), @backingInt(resolved.inst), @backingInt(cu_id) }); } else { - return writer.print("comptime(inst= [{}])", .{@intFromEnum(cu_id)}); + return writer.print("comptime(inst= [{}])", .{@backingInt(cu_id)}); } }, - .nav_val, .nav_ty => |nav, tag| return writer.print("{t}('{f}' [{}])", .{ tag, ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }), - .type_layout, .struct_defaults => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @intFromEnum(ty) }), + .nav_val, .nav_ty => |nav, tag| return writer.print("{t}('{f}' [{}])", .{ tag, ip.getNav(nav).fqn.fmt(ip), @backingInt(nav) }), + .type_layout, .struct_defaults => |ty, tag| return writer.print("{t}('{f}' [{}])", .{ tag, Type.fromInterned(ty).containerTypeName(ip).fmt(ip), @backingInt(ty) }), .func => |func| { const nav = zcu.funcInfo(func).owner_nav; - return writer.print("func('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(func) }); + return writer.print("func('{f}' [{}])", .{ ip.getNav(nav).fqn.fmt(ip), @backingInt(func) }); }, .memoized_state => return writer.writeAll("memoized_state"), } @@ -4519,7 +4519,7 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void return writer.writeAll("inst()"); }; const file_path = zcu.fileByIndex(info.file).path; - return writer.print("inst('{f}', %{d})", .{ file_path.fmt(zcu.comp), @intFromEnum(info.inst) }); + return writer.print("inst('{f}', %{d})", .{ file_path.fmt(zcu.comp), @backingInt(info.inst) }); }, .nav_val, .nav_ty => |nav, tag| { const fqn = ip.getNav(nav).fqn; @@ -4546,14 +4546,14 @@ fn formatDependee(data: FormatDependee, writer: *Io.Writer) Io.Writer.Error!void return writer.writeAll("namespace()"); }; const file_path = zcu.fileByIndex(info.file).path; - return writer.print("namespace('{f}', %{d})", .{ file_path.fmt(zcu.comp), @intFromEnum(info.inst) }); + return writer.print("namespace('{f}', %{d})", .{ file_path.fmt(zcu.comp), @backingInt(info.inst) }); }, .namespace_name => |k| { const info = k.namespace.resolveFull(ip) orelse { return writer.print("namespace(, '{f}')", .{k.name.fmt(ip)}); }; const file_path = zcu.fileByIndex(info.file).path; - return writer.print("namespace('{f}', %{d}, '{f}')", .{ file_path.fmt(zcu.comp), @intFromEnum(info.inst), k.name.fmt(ip) }); + return writer.print("namespace('{f}', %{d}, '{f}')", .{ file_path.fmt(zcu.comp), @backingInt(info.inst), k.name.fmt(ip) }); }, .memoized_state => return writer.writeAll("memoized_state"), } @@ -5276,7 +5276,7 @@ pub const CodegenTaskPool = struct { @memset(task_funcs, .none); var free: std.ArrayList(Index) = try .initCapacity(arena, max_funcs_in_flight); - for (0..max_funcs_in_flight) |index| free.appendAssumeCapacity(@enumFromInt(index)); + for (0..max_funcs_in_flight) |index| free.appendAssumeCapacity(@fromBackingInt(@intCast(index))); return .{ .available_air_bytes = max_air_bytes_in_flight, @@ -5349,10 +5349,10 @@ pub const CodegenTaskPool = struct { errdefer comptime unreachable; assert(zcu.pending_codegen_jobs.fetchAdd(1, .monotonic) > 0); // the "Code Generation" node is still active - assert(pool.task_funcs[@intFromEnum(index)] == .none); - pool.task_funcs[@intFromEnum(index)] = func_index; - pool.task_air_bytes[@intFromEnum(index)] = actual_air_bytes; - pool.task_futures[@intFromEnum(index)] = if (move_air) io.async( + assert(pool.task_funcs[@backingInt(index)] == .none); + pool.task_funcs[@backingInt(index)] = func_index; + pool.task_air_bytes[@backingInt(index)] = actual_air_bytes; + pool.task_futures[@backingInt(index)] = if (move_air) io.async( workerCodegenOwnedAir, .{ zcu, func_index, air.* }, ) else io.async( @@ -5373,14 +5373,14 @@ pub const CodegenTaskPool = struct { zcu: *const Zcu, ) PerThread.RunCodegenError!struct { InternPool.Index, codegen.AnyMir } { const io = zcu.comp.io; - const func = pool.task_funcs[@intFromEnum(index)]; + const func = pool.task_funcs[@backingInt(index)]; assert(func != .none); - const effective_air_bytes = pool.task_air_bytes[@intFromEnum(index)]; - const result = pool.task_futures[@intFromEnum(index)].await(io); + const effective_air_bytes = pool.task_air_bytes[@backingInt(index)]; + const result = pool.task_futures[@backingInt(index)].await(io); - pool.task_funcs[@intFromEnum(index)] = .none; - pool.task_air_bytes[@intFromEnum(index)] = undefined; - pool.task_futures[@intFromEnum(index)] = undefined; + pool.task_funcs[@backingInt(index)] = .none; + pool.task_air_bytes[@backingInt(index)] = undefined; + pool.task_futures[@backingInt(index)] = undefined; { pool.mutex.lockUncancelable(io); diff --git a/src/Zcu/PerThread.zig b/src/Zcu/PerThread.zig index a839c03685ae6b64389e7b72751ed5e109a87399..cabb5ea749fc8a939ac67f624e25cae8cee87546 100644 --- a/src/Zcu/PerThread.zig +++ b/src/Zcu/PerThread.zig @@ -73,7 +73,7 @@ pub const Id = if (InternPool.single_threaded) enum { pub fn allocate(arena: Allocator, n: usize) Allocator.Error!void { assert(available_tids.items.len == 0); try available_tids.ensureTotalCapacityPrecise(arena, n - 1); - for (1..n) |tid| available_tids.appendAssumeCapacity(@enumFromInt(tid)); + for (1..n) |tid| available_tids.appendAssumeCapacity(@fromBackingInt(@intCast(tid))); switch (build_options.io_mode) { .threaded => { // Called from the main thread, so mark ourselves as such. @@ -194,7 +194,7 @@ pub fn update( // because `workerUpdateEmbedFile` can't invalidate it. The different here is that one // `@embedFile` can't trigger analysis of a new `@embedFile`! for (0.., zcu.embed_table.keys()) |ef_index_usize, ef| { - const ef_index: Zcu.EmbedFile.Index = @enumFromInt(ef_index_usize); + const ef_index: Zcu.EmbedFile.Index = @fromBackingInt(@intCast(ef_index_usize)); astgen_group.async(io, workerUpdateEmbedFile, .{ comp, ef_index, ef, }); @@ -390,7 +390,7 @@ fn workerUpdateFile( // Discover all imports in the file. Imports of modules we ignore for now since we don't // know which module we're in, but imports of file paths might need us to queue up other // AstGen jobs. - const imports_index = file.zir.?.extra[@intFromEnum(Zir.ExtraIndex.imports)]; + const imports_index = file.zir.?.extra[@backingInt(Zir.ExtraIndex.imports)]; if (imports_index != 0) { const extra = file.zir.?.extraData(Zir.Inst.Imports, imports_index); var import_i: u32 = 0; @@ -853,7 +853,7 @@ fn updateZirRefs(pt: Zcu.PerThread) (Io.Cancelable || Allocator.Error)!void { const old_inst = tracked_inst.inst.unwrap() orelse continue; // we can't continue tracking lost insts const tracked_inst_index = (InternPool.TrackedInst.Index.Unwrapped{ - .tid = @enumFromInt(tid), + .tid = @fromBackingInt(@intCast(tid)), .index = @intCast(tracked_inst_unwrapped_index), }).wrap(ip); const new_inst = updated_file.inst_map.get(old_inst) orelse { @@ -868,8 +868,8 @@ fn updateZirRefs(pt: Zcu.PerThread) (Io.Cancelable || Allocator.Error)!void { const old_zir = file.prev_zir.?.*; const new_zir = file.zir.?; - const old_tag = old_zir.instructions.items(.tag)[@intFromEnum(old_inst)]; - const old_data = old_zir.instructions.items(.data)[@intFromEnum(old_inst)]; + const old_tag = old_zir.instructions.items(.tag)[@backingInt(old_inst)]; + const old_data = old_zir.instructions.items(.data)[@backingInt(old_inst)]; switch (old_tag) { .declaration => { @@ -1882,7 +1882,7 @@ fn analyzeNavVal( }); if (zir_decl.linkage == .@"export") { - const export_src = block.src(.{ .token_offset = @enumFromInt(@intFromBool(zir_decl.is_pub)) }); + const export_src = block.src(.{ .token_offset = @fromBackingInt(@intCast(@intFromBool(zir_decl.is_pub))) }); const name_slice = zir.nullTerminatedString(zir_decl.name); const name_ip = try ip.getOrPutString(gpa, io, pt.tid, name_slice, .no_embedded_nulls); try sema.analyzeExportSelfNav(&block, export_src, name_ip); @@ -2623,7 +2623,7 @@ fn computeAliveFiles(pt: Zcu.PerThread) Allocator.Error!bool { if (file.status != .success) continue; // ZIR not valid if there was a file failure const zir = file.zir.?; - const imports_index = zir.extra[@intFromEnum(Zir.ExtraIndex.imports)]; + const imports_index = zir.extra[@backingInt(Zir.ExtraIndex.imports)]; if (imports_index == 0) continue; // this Zig file has no imports const extra = zir.extraData(Zir.Inst.Imports, imports_index); var extra_index = extra.end; @@ -2794,7 +2794,7 @@ pub fn updateBuiltinModule(pt: Zcu.PerThread, opts: Builtin) Allocator.Error!voi assert(!file.zir.?.hasCompileErrors()); { // Check that it has only one import, which is 'std'. - const imports_idx = file.zir.?.extra[@intFromEnum(Zir.ExtraIndex.imports)]; + const imports_idx = file.zir.?.extra[@backingInt(Zir.ExtraIndex.imports)]; assert(imports_idx != 0); // there is an import const extra = file.zir.?.extraData(Zir.Inst.Imports, imports_idx); assert(extra.data.imports_len == 1); // there is exactly one import @@ -2838,11 +2838,11 @@ pub fn embedFile( const gop = try zcu.embed_table.getOrPutAdapted(gpa, path, Zcu.EmbedTableAdapter{}); if (gop.found_existing) { path.deinit(gpa); // we're not using this key - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } errdefer _ = zcu.embed_table.pop(); gop.key_ptr.* = try pt.newEmbedFile(path); - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } const embed_file: *Zcu.EmbedFile, const embed_file_idx: Zcu.EmbedFile.Index = ef: { @@ -2851,11 +2851,11 @@ pub fn embedFile( const gop = try zcu.embed_table.getOrPutAdapted(gpa, path, Zcu.EmbedTableAdapter{}); if (gop.found_existing) { path.deinit(gpa); // we're not using this key - break :ef .{ gop.key_ptr.*, @enumFromInt(gop.index) }; + break :ef .{ gop.key_ptr.*, @fromBackingInt(@intCast(gop.index)) }; } else { errdefer _ = zcu.embed_table.pop(); gop.key_ptr.* = try pt.newEmbedFile(path); - break :ef .{ gop.key_ptr.*, @enumFromInt(gop.index) }; + break :ef .{ gop.key_ptr.*, @fromBackingInt(@intCast(gop.index)) }; } }; @@ -3394,7 +3394,7 @@ fn analyzeFuncBodyInner( gop.value_ptr.* = .fromValue(opv); continue; } - const arg_index: Air.Inst.Index = @enumFromInt(sema.air_instructions.len); + const arg_index: Air.Inst.Index = @fromBackingInt(@intCast(sema.air_instructions.len)); gop.value_ptr.* = arg_index.toRef(); inner_block.instructions.appendAssumeCapacity(arg_index); sema.air_instructions.appendAssumeCapacity(.{ @@ -3441,7 +3441,7 @@ fn analyzeFuncBodyInner( for (sema.unresolved_inferred_allocs.keys()) |ptr_inst| { // The lack of a resolve_inferred_alloc means that this instruction // is unused so it just has to be a no-op. - sema.air_instructions.set(@intFromEnum(ptr_inst), .{ + sema.air_instructions.set(@backingInt(ptr_inst), .{ .tag = .alloc, .data = .{ .ty = .ptr_const_comptime_int }, }); @@ -3466,7 +3466,7 @@ fn analyzeFuncBodyInner( .body_len = @intCast(inner_block.instructions.items.len), }); sema.air_extra.appendSliceAssumeCapacity(@ptrCast(inner_block.instructions.items)); - sema.air_extra.items[@intFromEnum(Air.ExtraIndex.main_block)] = main_block_index; + sema.air_extra.items[@backingInt(Air.ExtraIndex.main_block)] = main_block_index; // Resolving inferred error sets is done *before* setting the function // state to success, so that "unable to resolve inferred error set" errors @@ -3640,7 +3640,7 @@ pub fn processExports(pt: Zcu.PerThread) !void { }, }; if (!found_existing) value_ptr.* = .empty; - try value_ptr.append(gpa, @enumFromInt(export_idx)); + try value_ptr.append(gpa, @fromBackingInt(@intCast(export_idx))); } } @@ -3994,7 +3994,7 @@ pub fn ptrType(pt: Zcu.PerThread, info: InternPool.Key.PtrType) Allocator.Error! canon_info.packed_offset.host_size = 0; } }, - _ => assert(@intFromEnum(info.flags.vector_index) < info.packed_offset.host_size), + _ => assert(@backingInt(info.flags.vector_index) < info.packed_offset.host_size), } return .fromInterned(try pt.intern(.{ .ptr_type = canon_info })); diff --git a/src/codegen.zig b/src/codegen.zig index 6872fbe84c4d0f1d3889bab30e3d65b6c9308968..a691b36a4811f7cf127de20aa50d33e2b6e8d700 100644 --- a/src/codegen.zig +++ b/src/codegen.zig @@ -793,7 +793,7 @@ fn lowerNavRef( @panic("TODO add out_reloc for this"); } else { try wasm.func_table_fixups.append(gpa, .{ - .table_index = @enumFromInt(gop.index), + .table_index = @fromBackingInt(@intCast(gop.index)), .offset = @intCast(w.end), }); } @@ -855,7 +855,7 @@ pub fn genNavRef( .internal => { const sym_index = try zo.getOrCreateMetadataForNav(zcu, nav_index); if (is_threadlocal) zo.symbol(sym_index).flags.is_tls = true; - return @enumFromInt(sym_index); + return @fromBackingInt(@intCast(sym_index)); }, .strong, .weak => { const sym_index = try elf_file.getGlobalSymbol(nav.name.toSlice(ip), lib_name.toSlice(ip)); @@ -866,7 +866,7 @@ pub fn genNavRef( .link_once => unreachable, } if (is_threadlocal) zo.symbol(sym_index).flags.is_tls = true; - return @enumFromInt(sym_index); + return @fromBackingInt(@intCast(sym_index)); }, .link_once => unreachable, } @@ -878,7 +878,7 @@ pub fn genNavRef( .internal => { const sym_index = try zo.getOrCreateMetadataForNav(macho_file, nav_index); if (is_threadlocal) zo.symbols.items[sym_index].flags.tlv = true; - return @enumFromInt(sym_index); + return @fromBackingInt(@intCast(sym_index)); }, .strong, .weak => { const sym_index = try macho_file.getGlobalSymbol(nav.name.toSlice(ip), lib_name.toSlice(ip)); @@ -889,12 +889,12 @@ pub fn genNavRef( .link_once => unreachable, } if (is_threadlocal) zo.symbols.items[sym_index].flags.tlv = true; - return @enumFromInt(sym_index); + return @fromBackingInt(@intCast(sym_index)); }, .link_once => unreachable, } } else if (lf.cast(.coff2)) |coff| { - return @enumFromInt(@intFromEnum(try coff.navSymbol(zcu, nav_index))); + return @fromBackingInt(@intCast(@backingInt(try coff.navSymbol(zcu, nav_index)))); } else { std.debug.panic("TODO genNavRef for '{t}'", .{lf.tag}); } diff --git a/src/codegen/aarch64.zig b/src/codegen/aarch64.zig index 690c9a49747c292c8a25df1983fc1074b91f8b39..a6eaac253ffd654ef418d6fbcff4577de9b0c4e9 100644 --- a/src/codegen/aarch64.zig +++ b/src/codegen/aarch64.zig @@ -72,8 +72,8 @@ pub fn generate( const air_main_body = air.getMainBody(); var param_it: Select.CallAbiIterator = .init; const air_args = for (air_main_body, 0..) |air_inst_index, body_index| { - if (air.instructions.items(.tag)[@intFromEnum(air_inst_index)] != .arg) break air_main_body[0..body_index]; - const arg = air.instructions.items(.data)[@intFromEnum(air_inst_index)].arg; + if (air.instructions.items(.tag)[@backingInt(air_inst_index)] != .arg) break air_main_body[0..body_index]; + const arg = air.instructions.items(.data)[@backingInt(air_inst_index)].arg; const param_ty = arg.ty.toType(); const param_vi = param_vi: { if (arg.zir_param_index >= named_params_len) { @@ -82,17 +82,17 @@ pub fn generate( } break :param_vi try param_it.param(&isel, param_ty); }; - tracking_log.debug("${d} <- %{d}", .{ @intFromEnum(param_vi.?), @intFromEnum(air_inst_index) }); + tracking_log.debug("${d} <- %{d}", .{ @backingInt(param_vi.?), @backingInt(air_inst_index) }); try isel.live_values.putNoClobber(gpa, air_inst_index, param_vi.?); } else unreachable; const saved_gra_start = if (mod.strip) param_it.ngrn else Select.CallAbiIterator.ngrn_start; const saved_gra_end = if (is_sysv_var_args) Select.CallAbiIterator.ngrn_end else param_it.ngrn; - const saved_gra_len = @intFromEnum(saved_gra_end) - @intFromEnum(saved_gra_start); + const saved_gra_len = @backingInt(saved_gra_end) - @backingInt(saved_gra_start); const saved_vra_start = if (mod.strip) param_it.nsrn else Select.CallAbiIterator.nsrn_start; const saved_vra_end = if (is_sysv_var_args) Select.CallAbiIterator.nsrn_end else param_it.nsrn; - const saved_vra_len = @intFromEnum(saved_vra_end) - @intFromEnum(saved_vra_start); + const saved_vra_len = @backingInt(saved_vra_end) - @backingInt(saved_vra_start); const frame_record = 2; const named_stack_args: Select.Value.Indirect = .{ @@ -106,13 +106,13 @@ pub fn generate( .__stack = stack_var_args, .__gr_top = gr_top, .__vr_top = vr_top, - .__gr_offs = @as(i32, @intFromEnum(Select.CallAbiIterator.ngrn_end) - @intFromEnum(param_it.ngrn)) * -8, - .__vr_offs = @as(i32, @intFromEnum(Select.CallAbiIterator.nsrn_end) - @intFromEnum(param_it.nsrn)) * -16, + .__gr_offs = @as(i32, @backingInt(Select.CallAbiIterator.ngrn_end) - @backingInt(param_it.ngrn)) * -8, + .__vr_offs = @as(i32, @backingInt(Select.CallAbiIterator.nsrn_end) - @backingInt(param_it.nsrn)) * -16, } } else .{ .other = stack_var_args }; // translate arg locations from caller-based to callee-based for (air_args) |air_inst_index| { - assert(air.instructions.items(.tag)[@intFromEnum(air_inst_index)] == .arg); + assert(air.instructions.items(.tag)[@backingInt(air_inst_index)] == .arg); const arg_vi = isel.live_values.get(air_inst_index).?; const passed_vi = switch (arg_vi.parent(&isel)) { .unallocated, .stack_slot => arg_vi, @@ -125,9 +125,9 @@ pub fn generate( const first_passed_part_vi = part_it.next().?; const hint_ra = first_passed_part_vi.hint(&isel).?; passed_vi.setParent(&isel, .{ .stack_slot = if (hint_ra.isVector()) - vr_top.withOffset(@as(i8, -16) * (@intFromEnum(saved_vra_end) - @intFromEnum(hint_ra))) + vr_top.withOffset(@as(i8, -16) * (@backingInt(saved_vra_end) - @backingInt(hint_ra))) else - gr_top.withOffset(@as(i8, -8) * (@intFromEnum(saved_gra_end) - @intFromEnum(hint_ra))) }); + gr_top.withOffset(@as(i8, -8) * (@backingInt(saved_gra_end) - @backingInt(hint_ra))) }); }, .stack_slot => |stack_slot| { assert(stack_slot.base == .sp); @@ -140,7 +140,7 @@ pub fn generate( ret: { var ret_it: Select.CallAbiIterator = .init; const ret_vi = try ret_it.ret(&isel, .fromInterned(func_type.return_type)) orelse break :ret; - tracking_log.debug("${d} <- %main", .{@intFromEnum(ret_vi)}); + tracking_log.debug("${d} <- %main", .{@backingInt(ret_vi)}); try isel.live_values.putNoClobber(gpa, Select.Block.main, ret_vi); } diff --git a/src/codegen/aarch64/Disassemble.zig b/src/codegen/aarch64/Disassemble.zig index e2d00e3bb3ec070320b9744d1f06855fee169760..76e2b89f4f962cbed82cdb8a2695f15f066b5cb2 100644 --- a/src/codegen/aarch64/Disassemble.zig +++ b/src/codegen/aarch64/Disassemble.zig @@ -363,7 +363,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr return writer.print("{f}{s}{f}{s}#0x{d}{s}.{c}0x{x}", .{ fmtCase(group.op, dis.case), dis.mnemonic_operands_separator, - group.Rt.decode(.{}).general(@enumFromInt(group.b5)).fmtCase(dis.case), + group.Rt.decode(.{}).general(@fromBackingInt(@intCast(group.b5))).fmtCase(dis.case), dis.operands_separator, @as(u6, group.b5) << 5 | @as(u6, group.b40) << 0, @@ -383,7 +383,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr const decoded = integer.decode(); if (decoded == .unallocated) break :unallocated; const group = integer.group; - const sf: aarch64.encoding.Register.GeneralSize = @enumFromInt(group.opc >> 1); + const sf: aarch64.encoding.Register.GeneralSize = @fromBackingInt(@intCast(group.opc >> 1)); return writer.print("{f}{s}{f}{s}{f}{s}[{f}]{s}#{s}0x{x}", .{ fmtCase(decoded, dis.case), dis.mnemonic_operands_separator, @@ -394,7 +394,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr group.Rn.decode(.{ .sp = true }).x().fmtCase(dis.case), dis.operands_separator, if (group.imm7 < 0) "-" else "", - @as(u10, @abs(group.imm7)) << (@as(u2, 2) + @intFromEnum(sf)), + @as(u10, @abs(group.imm7)) << (@as(u2, 2) + @backingInt(sf)), }); }, .vector => |vector| { @@ -412,7 +412,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr group.Rn.decode(.{ .sp = true }).x().fmtCase(dis.case), dis.operands_separator, if (group.imm7 < 0) "-" else "", - @as(u11, @abs(group.imm7)) << (@as(u3, 2) + @intFromEnum(vs)), + @as(u11, @abs(group.imm7)) << (@as(u3, 2) + @backingInt(vs)), }); }, }, @@ -421,7 +421,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr const decoded = integer.decode(); if (decoded == .unallocated) break :unallocated; const group = integer.group; - const sf: aarch64.encoding.Register.GeneralSize = @enumFromInt(group.opc >> 1); + const sf: aarch64.encoding.Register.GeneralSize = @fromBackingInt(@intCast(group.opc >> 1)); try writer.print("{f}{s}{f}{s}{f}{s}[{f}", .{ fmtCase(decoded, dis.case), dis.mnemonic_operands_separator, @@ -434,7 +434,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr if (group.imm7 != 0) try writer.print("{s}#{s}0x{x}", .{ dis.operands_separator, if (group.imm7 < 0) "-" else "", - @as(u10, @abs(group.imm7)) << (@as(u2, 2) + @intFromEnum(sf)), + @as(u10, @abs(group.imm7)) << (@as(u2, 2) + @backingInt(sf)), }); return writer.writeByte(']'); }, @@ -455,7 +455,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr if (group.imm7 != 0) try writer.print("{s}#{s}0x{x}", .{ dis.operands_separator, if (group.imm7 < 0) "-" else "", - @as(u11, @abs(group.imm7)) << (@as(u3, 2) + @intFromEnum(vs)), + @as(u11, @abs(group.imm7)) << (@as(u3, 2) + @backingInt(vs)), }); return writer.writeByte(']'); }, @@ -465,7 +465,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr const decoded = integer.decode(); if (decoded == .unallocated) break :unallocated; const group = integer.group; - const sf: aarch64.encoding.Register.GeneralSize = @enumFromInt(group.opc >> 1); + const sf: aarch64.encoding.Register.GeneralSize = @fromBackingInt(@intCast(group.opc >> 1)); return writer.print("{f}{s}{f}{s}{f}{s}[{f}{s}#{s}0x{x}]!", .{ fmtCase(decoded, dis.case), dis.mnemonic_operands_separator, @@ -476,7 +476,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr group.Rn.decode(.{ .sp = true }).x().fmtCase(dis.case), dis.operands_separator, if (group.imm7 < 0) "-" else "", - @as(u10, @abs(group.imm7)) << (@as(u2, 2) + @intFromEnum(sf)), + @as(u10, @abs(group.imm7)) << (@as(u2, 2) + @backingInt(sf)), }); }, .vector => |vector| { @@ -494,7 +494,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr group.Rn.decode(.{ .sp = true }).x().fmtCase(dis.case), dis.operands_separator, if (group.imm7 < 0) "-" else "", - @as(u11, @abs(group.imm7)) << (@as(u3, 2) + @intFromEnum(vs)), + @as(u11, @abs(group.imm7)) << (@as(u3, 2) + @backingInt(vs)), }); }, }, @@ -597,7 +597,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr fmtCase(group.option, dis.case), }); if (group.S) try writer.print(" #{d}", .{ - @intFromEnum(group.size), + @backingInt(group.size), }); } return writer.writeByte(']'); @@ -627,7 +627,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr }); if (group.imm12 > 0) try writer.print("{s}#0x{x}", .{ dis.operands_separator, - @as(u15, group.imm12) << @intFromEnum(group.size), + @as(u15, group.imm12) << @backingInt(group.size), }); return writer.writeByte(']'); }, @@ -969,10 +969,10 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr else fmtCase(decoded, dis.case), dis.mnemonic_operands_separator, - group.Rd.decode(.{ .V = true }).scalar(@enumFromInt(elem_size)).fmtCase(dis.case), + group.Rd.decode(.{ .V = true }).scalar(@fromBackingInt(@intCast(elem_size))).fmtCase(dis.case), dis.operands_separator, group.Rn.decode(.{ .V = true }).element( - @enumFromInt(elem_size), + @fromBackingInt(@intCast(elem_size)), @intCast(group.imm5 >> (elem_size + 1)), ).fmtCase(dis.case), }); @@ -1066,11 +1066,11 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr .unallocated => unreachable, .dup => |dup| group.Rd.decode(.{ .V = true }).vector(.wrap(.{ .size = dup.Q, - .elem_size = @enumFromInt(elem_size), + .elem_size = @fromBackingInt(@intCast(elem_size)), })), inline .smov, .umov => |mov| group.Rd.decode(.{}).general(mov.Q), .ins => group.Rd.decode(.{ .V = true }).element( - @enumFromInt(elem_size), + @fromBackingInt(@intCast(elem_size)), @intCast(group.imm5 >> (elem_size + 1)), ), }.fmtCase(dis.case), @@ -1079,7 +1079,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr .unallocated => unreachable, .dup => |dup| switch (dup.imm4) { .element => group.Rn.decode(.{ .V = true }).element( - @enumFromInt(elem_size), + @fromBackingInt(@intCast(elem_size)), @intCast(group.imm5 >> (elem_size + 1)), ), .general => group.Rn.decode(.{}).general(switch (elem_size) { @@ -1090,12 +1090,12 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr _ => unreachable, }, .smov, .umov => group.Rn.decode(.{ .V = true }).element( - @enumFromInt(elem_size), + @fromBackingInt(@intCast(elem_size)), @intCast(group.imm5 >> (elem_size + 1)), ), .ins => |ins| switch (ins.op) { .element => group.Rn.decode(.{ .V = true }).element( - @enumFromInt(elem_size), + @fromBackingInt(@intCast(elem_size)), @intCast(group.imm4 >> @intCast(elem_size)), ), .general => group.Rn.decode(.{}).general(switch (elem_size) { @@ -1263,7 +1263,7 @@ pub fn printInstruction(dis: Disassemble, inst: aarch64.encoding.Instruction, wr .size = group.Q, .elem_size = switch (group.o2) { 0b1 => .half, - 0b0 => DataProcessingVector.Sz.toSize(@enumFromInt(group.op)), + 0b0 => DataProcessingVector.Sz.toSize(@fromBackingInt(@intCast(group.op))), }, })).fmtCase(dis.case), }); @@ -1404,7 +1404,7 @@ pub const RegisterFormatter = struct { .r30, => |alias| try writer.print("{c}{d}", .{ data.case.convert(size.prefix()), - @intFromEnum(alias.encode(.{})), + @backingInt(alias.encode(.{})), }), .zr => try writer.print("{c}{f}", .{ data.case.convert(size.prefix()), @@ -1420,7 +1420,7 @@ pub const RegisterFormatter = struct { }, .scalar => |size| try writer.print("{c}{d}", .{ data.case.convert(size.prefix()), - @intFromEnum(data.reg.alias.encode(.{ .V = true })), + @backingInt(data.reg.alias.encode(.{ .V = true })), }), .vector => |arrangement| try writer.print("{f}.{f}", .{ fmtCase(data.reg.alias, data.case), @@ -1433,7 +1433,7 @@ pub const RegisterFormatter = struct { }), .scalable => try writer.print("{c}{d}", .{ data.case.convert('z'), - @intFromEnum(data.reg.alias.encode(.{ .V = true })), + @backingInt(data.reg.alias.encode(.{ .V = true })), }), } } diff --git a/src/codegen/aarch64/Mir.zig b/src/codegen/aarch64/Mir.zig index 04ba3efc7e2a304285dfb1cdaad4dd173ae89a4c..7b976acde1c5401ef294ede213416828c55d26a9 100644 --- a/src/codegen/aarch64/Mir.zig +++ b/src/codegen/aarch64/Mir.zig @@ -122,11 +122,11 @@ pub fn emit( zcu, atom_index, if (lf.cast(.elf)) |ef| - @enumFromInt(ef.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(ef, pt, lazy_reloc.symbol) catch |err| - return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)})) + @fromBackingInt(@intCast(ef.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(ef, pt, lazy_reloc.symbol) catch |err| + return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)}))) else if (lf.cast(.macho)) |mf| - @enumFromInt(mf.getZigObject().?.getOrCreateMetadataForLazySymbol(mf, pt, lazy_reloc.symbol) catch |err| - return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)})) + @fromBackingInt(@intCast(mf.getZigObject().?.getOrCreateMetadataForLazySymbol(mf, pt, lazy_reloc.symbol) catch |err| + return zcu.codegenFail(func.owner_nav, "{s} creating lazy symbol", .{@errorName(err)}))) else return zcu.codegenFail(func.owner_nav, "external symbols unimplemented for {t}", .{lf.tag}), mir.body[lazy_reloc.reloc.label], @@ -139,9 +139,9 @@ pub fn emit( zcu, atom_index, if (lf.cast(.elf)) |ef| - @enumFromInt(try ef.getGlobalSymbol(std.mem.span(global_reloc.name), null)) + @fromBackingInt(@intCast(try ef.getGlobalSymbol(std.mem.span(global_reloc.name), null))) else if (lf.cast(.macho)) |mf| - @enumFromInt(try mf.getGlobalSymbol(std.mem.span(global_reloc.name), null)) + @fromBackingInt(@intCast(try mf.getGlobalSymbol(std.mem.span(global_reloc.name), null))) else return zcu.codegenFail(func.owner_nav, "external symbols unimplemented for {t}", .{lf.tag}), mir.body[global_reloc.reloc.label], @@ -189,7 +189,7 @@ fn emitReloc( else => unreachable, .data_processing_immediate => |decoded| if (lf.cast(.elf)) |ef| { const zo = ef.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(atom_index)).atom(ef).?; + const atom = zo.symbol(@backingInt(atom_index)).atom(ef).?; const r_type: std.elf.R_AARCH64 = switch (decoded.decode()) { else => unreachable, .pc_relative_addressing => |pc_relative_addressing| switch (pc_relative_addressing.group.op) { @@ -212,12 +212,12 @@ fn emitReloc( }; try atom.addReloc(gpa, .{ .r_offset = offset, - .r_info = @as(u64, @intFromEnum(sym_index)) << 32 | @intFromEnum(r_type), + .r_info = @as(u64, @backingInt(sym_index)) << 32 | @backingInt(r_type), .r_addend = @bitCast(addend), }, zo); } else if (lf.cast(.macho)) |mf| { const zo = mf.getZigObject().?; - const atom = zo.symbols.items[@intFromEnum(atom_index)].getAtom(mf).?; + const atom = zo.symbols.items[@backingInt(atom_index)].getAtom(mf).?; switch (decoded.decode()) { else => unreachable, .pc_relative_addressing => |pc_relative_addressing| switch (pc_relative_addressing.group.op) { @@ -225,7 +225,7 @@ fn emitReloc( .adrp => try atom.addReloc(mf, .{ .tag = .@"extern", .offset = offset, - .target = @intFromEnum(sym_index), + .target = @backingInt(sym_index), .addend = @bitCast(addend), .type = switch (kind) { .direct => .page, @@ -235,7 +235,7 @@ fn emitReloc( .pcrel = true, .has_subtractor = false, .length = 2, - .symbolnum = @intCast(@intFromEnum(sym_index)), + .symbolnum = @intCast(@backingInt(sym_index)), }, }), }, @@ -243,7 +243,7 @@ fn emitReloc( .add => try atom.addReloc(mf, .{ .tag = .@"extern", .offset = offset, - .target = @intFromEnum(sym_index), + .target = @backingInt(sym_index), .addend = @bitCast(addend), .type = switch (kind) { .direct => .pageoff, @@ -253,7 +253,7 @@ fn emitReloc( .pcrel = false, .has_subtractor = false, .length = 2, - .symbolnum = @intCast(@intFromEnum(sym_index)), + .symbolnum = @intCast(@backingInt(sym_index)), }, }), .sub => unreachable, @@ -262,36 +262,36 @@ fn emitReloc( }, .branch_exception_generating_system => |decoded| if (lf.cast(.elf)) |ef| { const zo = ef.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(atom_index)).atom(ef).?; + const atom = zo.symbol(@backingInt(atom_index)).atom(ef).?; const r_type: std.elf.R_AARCH64 = switch (decoded.decode().unconditional_branch_immediate.group.op) { .b => .JUMP26, .bl => .CALL26, }; try atom.addReloc(gpa, .{ .r_offset = offset, - .r_info = @as(u64, @intFromEnum(sym_index)) << 32 | @intFromEnum(r_type), + .r_info = @as(u64, @backingInt(sym_index)) << 32 | @backingInt(r_type), .r_addend = @bitCast(addend), }, zo); } else if (lf.cast(.macho)) |mf| { const zo = mf.getZigObject().?; - const atom = zo.symbols.items[@intFromEnum(atom_index)].getAtom(mf).?; + const atom = zo.symbols.items[@backingInt(atom_index)].getAtom(mf).?; try atom.addReloc(mf, .{ .tag = .@"extern", .offset = offset, - .target = @intFromEnum(sym_index), + .target = @backingInt(sym_index), .addend = @bitCast(addend), .type = .branch, .meta = .{ .pcrel = true, .has_subtractor = false, .length = 2, - .symbolnum = @intCast(@intFromEnum(sym_index)), + .symbolnum = @intCast(@backingInt(sym_index)), }, }); }, .load_store => |decoded| if (lf.cast(.elf)) |ef| { const zo = ef.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(atom_index)).atom(ef).?; + const atom = zo.symbol(@backingInt(atom_index)).atom(ef).?; const r_type: std.elf.R_AARCH64 = switch (decoded.decode().register_unsigned_immediate.decode()) { .integer => |integer| switch (integer.decode()) { .unallocated, .prfm => unreachable, @@ -332,16 +332,16 @@ fn emitReloc( }; try atom.addReloc(gpa, .{ .r_offset = offset, - .r_info = @as(u64, @intFromEnum(sym_index)) << 32 | @intFromEnum(r_type), + .r_info = @as(u64, @backingInt(sym_index)) << 32 | @backingInt(r_type), .r_addend = @bitCast(addend), }, zo); } else if (lf.cast(.macho)) |mf| { const zo = mf.getZigObject().?; - const atom = zo.symbols.items[@intFromEnum(atom_index)].getAtom(mf).?; + const atom = zo.symbols.items[@backingInt(atom_index)].getAtom(mf).?; try atom.addReloc(mf, .{ .tag = .@"extern", .offset = offset, - .target = @intFromEnum(sym_index), + .target = @backingInt(sym_index), .addend = @bitCast(addend), .type = switch (kind) { .direct => .pageoff, @@ -351,7 +351,7 @@ fn emitReloc( .pcrel = false, .has_subtractor = false, .length = 2, - .symbolnum = @intCast(@intFromEnum(sym_index)), + .symbolnum = @intCast(@backingInt(sym_index)), }, }); }, diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig index 9a832f2c858698f1f790c82f138cd583ecf91a95..30387bfe8a37719577b57391f6f270e71e8238e2 100644 --- a/src/codegen/aarch64/Select.zig +++ b/src/codegen/aarch64/Select.zig @@ -52,9 +52,9 @@ pub const Block = struct { live_registers: LiveRegisters, target_label: u32, - pub const main: Air.Inst.Index = @enumFromInt( + pub const main: Air.Inst.Index = @fromBackingInt(@intCast( std.math.maxInt(@typeInfo(Air.Inst.Index).@"enum".tag_type), - ); + )); fn branch(target_block: *const Block, isel: *Select) !void { if (isel.instructions.items.len > target_block.target_label) { @@ -72,19 +72,19 @@ pub const Loop = struct { live_registers: LiveRegisters, repeat_list: u32, - pub const invalid: Air.Inst.Index = @enumFromInt( + pub const invalid: Air.Inst.Index = @fromBackingInt(@intCast( std.math.maxInt(@typeInfo(Air.Inst.Index).@"enum".tag_type), - ); + )); pub const Index = enum(u32) { _, fn inst(li: Loop.Index, isel: *Select) Air.Inst.Index { - return isel.loops.keys()[@intFromEnum(li)]; + return isel.loops.keys()[@backingInt(li)]; } fn get(li: Loop.Index, isel: *Select) *Loop { - return &isel.loops.values()[@intFromEnum(li)]; + return &isel.loops.values()[@backingInt(li)]; } }; @@ -133,7 +133,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { var air_body_index: usize = 0; var air_inst_index = air_body[air_body_index]; const initial_def_order_len = isel.def_order.count(); - air_tag: switch (air_tags[@intFromEnum(air_inst_index)]) { + air_tag: switch (air_tags[@backingInt(air_inst_index)]) { // No "scalarize" legalizations are enabled, so these instructions never appear. .legalize_vec_elem_val => unreachable, .legalize_vec_store_elem => unreachable, @@ -152,7 +152,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .add, .add_safe, @@ -209,7 +209,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .slice_elem_val, .ptr_elem_val, => { - const bin_op = air_data[@intFromEnum(air_inst_index)].bin_op; + const bin_op = air_data[@backingInt(air_inst_index)].bin_op; try isel.analyzeUse(bin_op.lhs); try isel.analyzeUse(bin_op.rhs); @@ -217,7 +217,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .ptr_add, .ptr_sub, @@ -229,7 +229,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .slice_elem_ptr, .ptr_elem_ptr, => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const bin_op = isel.air.extraData(Air.Bin, ty_pl.payload).data; try isel.analyzeUse(bin_op.lhs); @@ -238,17 +238,17 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .alloc => { - const ty = air_data[@intFromEnum(air_inst_index)].ty; + const ty = air_data[@backingInt(air_inst_index)].ty; isel.stack_align = isel.stack_align.maxStrict(ty.ptrAlignment(zcu)); try isel.def_order.putNoClobber(gpa, air_inst_index, {}); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .inferred_alloc, .inferred_alloc_comptime, @@ -260,7 +260,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .spirv_runtime_array_len, => unreachable, .ret_ptr => { - const ty = air_data[@intFromEnum(air_inst_index)].ty; + const ty = air_data[@backingInt(air_inst_index)].ty; if (isel.live_values.get(Block.main)) |ret_vi| switch (ret_vi.parent(isel)) { .unallocated, .stack_slot => isel.stack_align = isel.stack_align.maxStrict(ty.ptrAlignment(zcu)), @@ -271,10 +271,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .assembly => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const unwrapped_asm = isel.air.unwrapAsm(air_inst_index); for (unwrapped_asm.outputs) |operand| if (operand != .none) try isel.analyzeUse(operand); @@ -282,7 +282,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .not, .clz, @@ -327,14 +327,14 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .c_va_arg, .c_va_copy, => { - const ty_op = air_data[@intFromEnum(air_inst_index)].ty_op; + const ty_op = air_data[@backingInt(air_inst_index)].ty_op; try isel.analyzeUse(ty_op.operand); try isel.def_order.putNoClobber(gpa, air_inst_index, {}); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .bit_cast, .ptr_cast, @@ -345,7 +345,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .int_from_error, .union_from_enum, => { - const ty_op = air_data[@intFromEnum(air_inst_index)].ty_op; + const ty_op = air_data[@backingInt(air_inst_index)].ty_op; maybe_noop: { if (ty_op.ty.toInterned().? != isel.air.typeOf(ty_op.operand, ip).toIntern()) break :maybe_noop; if (true) break :maybe_noop; @@ -360,7 +360,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .bit_cast_safe => unreachable, // legalized inline .block, .dbg_inline_block => |air_tag| { @@ -388,7 +388,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .loop => { const air_body_block = isel.air.unwrapBlock(air_inst_index); @@ -397,7 +397,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { const initial_dom_len = isel.dom_len; isel.dom_start = @intCast(isel.dom.items.len); isel.dom_len = @intCast(isel.blocks.count()); - try isel.active_loops.append(gpa, @enumFromInt(isel.loops.count())); + try isel.active_loops.append(gpa, @fromBackingInt(@intCast(isel.loops.count()))); try isel.loops.putNoClobber(gpa, air_inst_index, .{ .def_order = @intCast(isel.def_order.count()), .dom = isel.dom_start, @@ -420,7 +420,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { }, .repeat, .trap, .unreach => air_body_index += 1, .br => { - const br = air_data[@intFromEnum(air_inst_index)].br; + const br = air_data[@backingInt(air_inst_index)].br; const block_index = isel.blocks.getIndex(br.block_inst).?; if (block_index < isel.dom_len) isel.dom.items[isel.dom_start + block_index / @bitSizeOf(DomInt)] |= @as(DomInt, 1) << @truncate(block_index); try isel.analyzeUse(br.operand); @@ -430,7 +430,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .breakpoint, .dbg_stmt, .dbg_empty_stmt, .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline, .c_va_end => { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .call, .call_always_tail, @@ -486,7 +486,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { var ret_it: CallAbiIterator = .init; if (try ret_it.ret(isel, isel.air.typeOfIndex(air_inst_index, ip))) |ret_vi| { - tracking_log.debug("${d} <- %{d}", .{ @intFromEnum(ret_vi), @intFromEnum(air_inst_index) }); + tracking_log.debug("${d} <- %{d}", .{ @backingInt(ret_vi), @backingInt(air_inst_index) }); switch (ret_vi.parent(isel)) { .unallocated, .stack_slot => {}, .value, .constant => unreachable, @@ -504,7 +504,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .sqrt, .sin, @@ -534,17 +534,17 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .error_name, .cmp_lte_errors_len, => { - const un_op = air_data[@intFromEnum(air_inst_index)].un_op; + const un_op = air_data[@backingInt(air_inst_index)].un_op; try isel.analyzeUse(un_op); try isel.def_order.putNoClobber(gpa, air_inst_index, {}); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .cmp_vector, .cmp_vector_optimized => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const extra = isel.air.extraData(Air.VectorCmp, ty_pl.payload).data; try isel.analyzeUse(extra.lhs); @@ -553,7 +553,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .cond_br => { const cond_br = isel.air.unwrapCondBr(air_inst_index); @@ -583,7 +583,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { const initial_dom_len = isel.dom_len; isel.dom_start = @intCast(isel.dom.items.len); isel.dom_len = @intCast(isel.blocks.count()); - try isel.active_loops.append(gpa, @enumFromInt(isel.loops.count())); + try isel.active_loops.append(gpa, @fromBackingInt(@intCast(isel.loops.count()))); try isel.loops.putNoClobber(gpa, air_inst_index, .{ .def_order = @intCast(isel.def_order.count()), .dom = isel.dom_start, @@ -609,7 +609,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; }, .switch_dispatch => { - const br = air_data[@intFromEnum(air_inst_index)].br; + const br = air_data[@backingInt(air_inst_index)].br; try isel.analyzeUse(br.operand); @@ -624,7 +624,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .try_ptr, .try_ptr_cold => { const unwrapped_try = isel.air.unwrapTryPtr(air_inst_index); @@ -635,10 +635,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .ret, .ret_safe, .ret_load => { - const un_op = air_data[@intFromEnum(air_inst_index)].un_op; + const un_op = air_data[@backingInt(air_inst_index)].un_op; isel.returns = true; const block_index = 0; @@ -661,17 +661,17 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { .atomic_store_release, .atomic_store_seq_cst, => { - const bin_op = air_data[@intFromEnum(air_inst_index)].bin_op; + const bin_op = air_data[@backingInt(air_inst_index)].bin_op; try isel.analyzeUse(bin_op.lhs); try isel.analyzeUse(bin_op.rhs); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .struct_field_ptr, .agg_field_val => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const extra = isel.air.extraData(Air.StructField, ty_pl.payload).data; try isel.analyzeUse(extra.struct_operand); @@ -679,10 +679,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .slice_len => { - const ty_op = air_data[@intFromEnum(air_inst_index)].ty_op; + const ty_op = air_data[@backingInt(air_inst_index)].ty_op; try isel.analyzeUse(ty_op.operand); try isel.def_order.putNoClobber(gpa, air_inst_index, {}); @@ -694,10 +694,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .slice_ptr => { - const ty_op = air_data[@intFromEnum(air_inst_index)].ty_op; + const ty_op = air_data[@backingInt(air_inst_index)].ty_op; try isel.analyzeUse(ty_op.operand); try isel.def_order.putNoClobber(gpa, air_inst_index, {}); @@ -709,17 +709,17 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .reduce, .reduce_optimized => { - const reduce = air_data[@intFromEnum(air_inst_index)].reduce; + const reduce = air_data[@backingInt(air_inst_index)].reduce; try isel.analyzeUse(reduce.operand); try isel.def_order.putNoClobber(gpa, air_inst_index, {}); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .shuffle_one => { const extra = isel.air.unwrapShuffleOne(zcu, air_inst_index); @@ -729,7 +729,7 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .shuffle_two => { const extra = isel.air.unwrapShuffleTwo(zcu, air_inst_index); @@ -740,10 +740,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .select, .mul_add => { - const pl_op = air_data[@intFromEnum(air_inst_index)].pl_op; + const pl_op = air_data[@backingInt(air_inst_index)].pl_op; const bin_op = isel.air.extraData(Air.Bin, pl_op.payload).data; try isel.analyzeUse(pl_op.operand); @@ -753,10 +753,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .cmpxchg_weak, .cmpxchg_strong => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const extra = isel.air.extraData(Air.Cmpxchg, ty_pl.payload).data; try isel.analyzeUse(extra.ptr); @@ -766,20 +766,20 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .atomic_load => { - const atomic_load = air_data[@intFromEnum(air_inst_index)].atomic_load; + const atomic_load = air_data[@backingInt(air_inst_index)].atomic_load; try isel.analyzeUse(atomic_load.ptr); try isel.def_order.putNoClobber(gpa, air_inst_index, {}); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .atomic_rmw => { - const pl_op = air_data[@intFromEnum(air_inst_index)].pl_op; + const pl_op = air_data[@backingInt(air_inst_index)].pl_op; const extra = isel.air.extraData(Air.AtomicRmw, pl_op.payload).data; try isel.analyzeUse(extra.operand); @@ -787,10 +787,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .aggregate_init => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const elements: []const Air.Inst.Ref = @ptrCast(isel.air.extra.items[ty_pl.payload..][0..@intCast(ty_pl.ty.toType().arrayLen(zcu))]); for (elements) |element| try isel.analyzeUse(element); @@ -798,10 +798,10 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .union_init => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const extra = isel.air.extraData(Air.UnionInit, ty_pl.payload).data; try isel.analyzeUse(extra.init); @@ -809,19 +809,19 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .prefetch => { - const prefetch = air_data[@intFromEnum(air_inst_index)].prefetch; + const prefetch = air_data[@backingInt(air_inst_index)].prefetch; try isel.analyzeUse(prefetch.ptr); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .field_parent_ptr => { - const ty_pl = air_data[@intFromEnum(air_inst_index)].ty_pl; + const ty_pl = air_data[@backingInt(air_inst_index)].ty_pl; const extra = isel.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; try isel.analyzeUse(extra.field_ptr); @@ -829,16 +829,16 @@ pub fn analyze(isel: *Select, air_body: []const Air.Inst.Index) !void { air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, .set_err_return_trace => { - const un_op = air_data[@intFromEnum(air_inst_index)].un_op; + const un_op = air_data[@backingInt(air_inst_index)].un_op; try isel.analyzeUse(un_op); air_body_index += 1; air_inst_index = air_body[air_body_index]; - continue :air_tag air_tags[@intFromEnum(air_inst_index)]; + continue :air_tag air_tags[@backingInt(air_inst_index)]; }, } assert(air_body_index == air_body.len); @@ -923,11 +923,11 @@ pub fn body(isel: *Select, air_body: []const Air.Inst.Index) error{ OutOfMemory, inst_index: Air.Inst.Index, fn tag(it: *@This(), inst_index: Air.Inst.Index) Air.Inst.Tag { - return it.tag_items[@intFromEnum(inst_index)]; + return it.tag_items[@backingInt(inst_index)]; } fn data(it: *@This(), inst_index: Air.Inst.Index) Air.Inst.Data { - return it.data_items[@intFromEnum(inst_index)]; + return it.data_items[@backingInt(inst_index)]; } fn next(it: *@This()) ?Air.Inst.Tag { @@ -7619,7 +7619,7 @@ pub fn layout( // callee saved gr area save_ra = .r19; - while (save_ra != .r29) : (save_ra = @enumFromInt(@intFromEnum(save_ra) + 1)) { + while (save_ra != .r29) : (save_ra = @fromBackingInt(@intCast(@backingInt(save_ra) + 1))) { if (!isel.saved_registers.contains(save_ra)) continue; saves_size = std.mem.alignForward(u10, saves_size, 8); saves_buf[saves_len] = .{ @@ -7641,7 +7641,7 @@ pub fn layout( // callee saved vr area save_ra = .v8; - while (save_ra != .v16) : (save_ra = @enumFromInt(@intFromEnum(save_ra) + 1)) { + while (save_ra != .v16) : (save_ra = @fromBackingInt(@intCast(@backingInt(save_ra) + 1))) { if (!isel.saved_registers.contains(save_ra)) continue; saves_size = std.mem.alignForward(u10, saves_size, 8); saves_buf[saves_len] = .{ @@ -7681,7 +7681,7 @@ pub fn layout( // incoming vr arguments save_ra = if (mod.strip) incoming.nsrn else CallAbiIterator.nsrn_start; - while (save_ra != if (is_sysv_var_args) CallAbiIterator.nsrn_end else incoming.nsrn) : (save_ra = @enumFromInt(@intFromEnum(save_ra) + 1)) { + while (save_ra != if (is_sysv_var_args) CallAbiIterator.nsrn_end else incoming.nsrn) : (save_ra = @fromBackingInt(@intCast(@backingInt(save_ra) + 1))) { saves_size = std.mem.alignForward(u10, saves_size, 16); saves_buf[saves_len] = .{ .class = .vector, @@ -7736,7 +7736,7 @@ pub fn layout( 1 => saves_size += 8, } save_ra = if (mod.strip) incoming.ngrn else CallAbiIterator.ngrn_start; - while (save_ra != if (is_sysv_var_args) CallAbiIterator.ngrn_end else incoming.ngrn) : (save_ra = @enumFromInt(@intFromEnum(save_ra) + 1)) { + while (save_ra != if (is_sysv_var_args) CallAbiIterator.ngrn_end else incoming.ngrn) : (save_ra = @fromBackingInt(@intCast(@backingInt(save_ra) + 1))) { saves_size = std.mem.alignForward(u10, saves_size, 8); saves_buf[saves_len] = .{ .class = .integer, @@ -7917,7 +7917,7 @@ fn fmtDom(isel: *Select, inst: Air.Inst.Index, start: u32, len: u32) struct { start: u32, len: u32, pub fn format(data: @This(), writer: *std.Io.Writer) std.Io.Writer.Error!void { - try writer.print("%{d} -> {{", .{@intFromEnum(data.inst)}); + try writer.print("%{d} -> {{", .{@backingInt(data.inst)}); var first = true; for (data.isel.blocks.keys()[0..data.len], 0..) |block_inst_index, dom_index| { if (@as(u1, @truncate(data.isel.dom.items[ @@ -7930,7 +7930,7 @@ fn fmtDom(isel: *Select, inst: Air.Inst.Index, start: u32, len: u32) struct { } switch (block_inst_index) { Block.main => try writer.writeAll(" %main"), - else => try writer.print(" %{d}", .{@intFromEnum(block_inst_index)}), + else => try writer.print(" %{d}", .{@backingInt(block_inst_index)}), } } if (!first) try writer.writeByte(' '); @@ -7949,7 +7949,7 @@ fn fmtLoopLive(isel: *Select, loop_inst: Air.Inst.Index) struct { const live_insts = data.isel.loop_live.list.items[loops[loop_index].live..loops[loop_index + 1].live]; - try writer.print("%{d} <- {{", .{@intFromEnum(data.inst)}); + try writer.print("%{d} <- {{", .{@backingInt(data.inst)}); var first = true; for (live_insts) |live_inst| { if (first) { @@ -7957,7 +7957,7 @@ fn fmtLoopLive(isel: *Select, loop_inst: Air.Inst.Index) struct { } else { try writer.writeByte(','); } - try writer.print(" %{d}", .{@intFromEnum(live_inst)}); + try writer.print(" %{d}", .{@backingInt(live_inst)}); } if (!first) try writer.writeByte(' '); try writer.writeByte('}'); @@ -8090,7 +8090,7 @@ fn movImmediate(isel: *Select, dst_reg: Register, src_imm: u64) !void { .doubleword => .xzr, }, .{ .immediate = .{ - .N = @enumFromInt(elem_width >> 6), + .N = @fromBackingInt(@intCast(elem_width >> 6)), .immr = hi + mid_masked, .imms = ((((lo + hi) & smask) | mid_masked) - 1) | -%@as(u6, @truncate(elem_width)) << 1, } }, @@ -8107,18 +8107,18 @@ fn movImmediate(isel: *Select, dst_reg: Register, src_imm: u64) !void { try isel.emit(if (remaining_parts > 0) .movk( dst_reg, parts[part_index], - .{ .lsl = @enumFromInt(part_index) }, + .{ .lsl = @fromBackingInt(@intCast(part_index)) }, ) else switch (fill_part) { else => unreachable, min_part => .movz( dst_reg, parts[part_index], - .{ .lsl = @enumFromInt(part_index) }, + .{ .lsl = @fromBackingInt(@intCast(part_index)) }, ), max_part => .movn( dst_reg, ~parts[part_index], - .{ .lsl = @enumFromInt(part_index) }, + .{ .lsl = @fromBackingInt(@intCast(part_index)) }, ), }); } @@ -8954,7 +8954,7 @@ pub const Value = struct { _, fn get(vi: Value.Index, isel: *Select) *Value { - return &isel.values.items[@intFromEnum(vi)]; + return &isel.values.items[@backingInt(vi)]; } fn setAlignment(vi: Value.Index, isel: *Select, new_alignment: InternPool.Alignment) void { @@ -9099,15 +9099,15 @@ pub const Value = struct { assert(parts_len > 1); const value = vi.get(isel); assert(value.flags.parts_len_minus_one == 0); - value.parts = @enumFromInt(isel.values.items.len); + value.parts = @fromBackingInt(@intCast(isel.values.items.len)); value.flags.parts_len_minus_one = @intCast(parts_len - 1); } fn addPart(vi: Value.Index, isel: *Select, part_offset: u64, part_size: u64) Value.Index { const part_vi = isel.initValueAdvanced(vi.alignment(isel), part_offset, part_size); tracking_log.debug("${d} <- ${d}[{d}]", .{ - @intFromEnum(part_vi), - @intFromEnum(vi), + @backingInt(part_vi), + @backingInt(vi), part_offset, }); part_vi.setParent(isel, .{ .value = vi }); @@ -9132,7 +9132,7 @@ pub const Value = struct { const end_vi = vi.partAtOffset(isel, part_size - 1 + part_offset); return .{ .vi = start_vi, - .remaining = @intCast(@intFromEnum(end_vi) - @intFromEnum(start_vi) + 1), + .remaining = @intCast(@backingInt(end_vi) - @backingInt(start_vi) + 1), }; } comptime { @@ -9148,7 +9148,7 @@ pub const Value = struct { last += 1; while (true) { const mid = (first + last) / 2; - const mid_vi: Value.Index = @enumFromInt(@intFromEnum(value.parts) + mid); + const mid_vi: Value.Index = @fromBackingInt(@intCast(@backingInt(value.parts) + mid)); if (mid == first) return mid_vi; if (offset < mid_vi.get(isel).offset_from_parent) last = mid else first = mid; } @@ -10042,7 +10042,7 @@ pub const Value = struct { fn allocStackSlot(vi: Value.Index, isel: *Select) Value.Indirect { const offset = vi.alignment(isel).forward(isel.stack_size); isel.stack_size = @intCast(offset + vi.size(isel)); - tracking_log.debug("${d} -> [sp, #0x{x}]", .{ @intFromEnum(vi), @abs(offset) }); + tracking_log.debug("${d} -> [sp, #0x{x}]", .{ @backingInt(vi), @abs(offset) }); return .{ .base = .sp, .offset = @intCast(offset), @@ -10145,7 +10145,7 @@ pub const Value = struct { pub fn next(it: *PartIterator) ?Value.Index { if (it.remaining == 0) return null; it.remaining -= 1; - defer it.vi = @enumFromInt(@intFromEnum(it.vi) + 1); + defer it.vi = @fromBackingInt(@intCast(@backingInt(it.vi) + 1)); return it.vi; } @@ -11229,7 +11229,7 @@ fn initValueAdvanced( } }, .parts = undefined, }; - return @enumFromInt(isel.values.items.len); + return @fromBackingInt(@intCast(isel.values.items.len)); } const WhichValues = enum { only_referenced, all }; pub fn dumpValues(isel: *Select, which: WhichValues) void { @@ -11278,9 +11278,9 @@ fn dumpValuesInner(isel: *Select, which: WhichValues) !void { defer roots.deinit(gpa); { try roots.ensureTotalCapacity(gpa, isel.values.items.len); - var vi: Value.Index = @enumFromInt(isel.values.items.len); - while (@intFromEnum(vi) > 0) { - vi = @enumFromInt(@intFromEnum(vi) - 1); + var vi: Value.Index = @fromBackingInt(@intCast(isel.values.items.len)); + while (@backingInt(vi) > 0) { + vi = @fromBackingInt(@intCast(@backingInt(vi) - 1)); if (which == .only_referenced and vi.get(isel).refs == 0) continue; while (true) switch (vi.parent(isel)) { .unallocated, .stack_slot, .constant => break, @@ -11296,14 +11296,14 @@ fn dumpValuesInner(isel: *Select, which: WhichValues) !void { const vi = root_entry.key; const value = vi.get(isel); try stderr.splatByteAll(' ', 2 * (@as(usize, 1) + root_entry.value)); - try stderr.print("${d}", .{@intFromEnum(vi)}); + try stderr.print("${d}", .{@backingInt(vi)}); { var first = true; if (reverse_live_values.get(vi)) |aiis| for (aiis.items) |aii| { if (aii == Block.main) { try stderr.print("{s}%main", .{if (first) " <- " else ", "}); } else { - try stderr.print("{s}%{d}", .{ if (first) " <- " else ", ", @intFromEnum(aii) }); + try stderr.print("{s}%{d}", .{ if (first) " <- " else ", ", @backingInt(aii) }); } first = false; }; @@ -11324,8 +11324,8 @@ fn dumpValuesInner(isel: *Select, which: WhichValues) !void { if (value.offset_from_parent != 0) try stderr.print("+0x{x}", .{value.offset_from_parent}); try stderr.writeByte(']'); }, - .value => try stderr.print(" ${d}+0x{x}", .{ @intFromEnum(value.parent_payload.value), value.offset_from_parent }), - .address => try stderr.print(" ${d}[0x{x}]", .{ @intFromEnum(value.parent_payload.address), value.offset_from_parent }), + .value => try stderr.print(" ${d}+0x{x}", .{ @backingInt(value.parent_payload.value), value.offset_from_parent }), + .address => try stderr.print(" ${d}[0x{x}]", .{ @backingInt(value.parent_payload.address), value.offset_from_parent }), .constant => try stderr.print(" <{f}, {f}>", .{ isel.fmtType(value.parent_payload.constant.typeOf(zcu)), isel.fmtConstant(value.parent_payload.constant), @@ -11350,7 +11350,7 @@ fn dumpValuesInner(isel: *Select, which: WhichValues) !void { var part_index = value.flags.parts_len_minus_one; if (part_index > 0) while (true) : (part_index -= 1) { roots.putAssumeCapacityNoClobber( - @enumFromInt(@intFromEnum(value.parts) + part_index), + @fromBackingInt(@intCast(@backingInt(value.parts) + part_index)), root_entry.value + 1, ); if (part_index == 0) break; @@ -11517,7 +11517,7 @@ const TryAllocRegResult = union(enum) { fn tryAllocIntReg(isel: *Select) TryAllocRegResult { var failed_result: TryAllocRegResult = .out_of_registers; var ra: Register.Alias = .r0; - while (true) : (ra = @enumFromInt(@intFromEnum(ra) + 1)) { + while (true) : (ra = @fromBackingInt(@intCast(@backingInt(ra) + 1))) { if (ra == .r18) continue; // The Platform Register if (ra == Register.Alias.fp) continue; const live_vi = isel.live_registers.getPtr(ra); @@ -11555,7 +11555,7 @@ fn allocIntReg(isel: *Select) !Register.Alias { fn tryAllocVecReg(isel: *Select) TryAllocRegResult { var failed_result: TryAllocRegResult = .out_of_registers; var ra: Register.Alias = .v0; - while (true) : (ra = @enumFromInt(@intFromEnum(ra) + 1)) { + while (true) : (ra = @fromBackingInt(@intCast(@backingInt(ra) + 1))) { const live_vi = isel.live_registers.getPtr(ra); switch (live_vi.*) { _ => switch (failed_result) { @@ -11632,8 +11632,8 @@ fn use(isel: *Select, air_ref: Air.Inst.Ref) !Value.Index { const ty = isel.air.typeOf(air_ref, ip); const vi = isel.initValue(ty); tracking_log.debug("${d} <- %{d}", .{ - @intFromEnum(vi), - @intFromEnum(air_inst_index), + @backingInt(vi), + @backingInt(air_inst_index), }); live_gop.value_ptr.* = vi.ref(isel); break :vi_ty .{ vi, ty }; @@ -11642,7 +11642,7 @@ fn use(isel: *Select, air_ref: Air.Inst.Ref) !Value.Index { const ty = constant.typeOf(zcu); const vi = isel.initValue(ty); tracking_log.debug("${d} <- <{f}, {f}>", .{ - @intFromEnum(vi), + @backingInt(vi), isel.fmtType(ty), isel.fmtConstant(constant), }); @@ -11857,8 +11857,8 @@ fn merge( } const call = struct { - const param_reg: Value.Index = @enumFromInt(@intFromEnum(Value.Index.allocating) - 2); - const callee_clobbered_reg: Value.Index = @enumFromInt(@intFromEnum(Value.Index.allocating) - 1); + const param_reg: Value.Index = @fromBackingInt(@intCast(@backingInt(Value.Index.allocating) - 2)); + const callee_clobbered_reg: Value.Index = @fromBackingInt(@intCast(@backingInt(Value.Index.allocating) - 1)); const caller_saved_regs: LiveRegisters = .init(.{ .r0 = param_reg, .r1 = param_reg, @@ -12454,7 +12454,7 @@ pub const CallAbiIterator = struct { wip_vi.setAlignment(isel, natural_alignment.maxStrict(.@"8")); if (it.ngrn == ngrn_end) return it.stack(isel, wip_vi); wip_vi.setHint(isel, it.ngrn); - it.ngrn = @enumFromInt(@intFromEnum(it.ngrn) + 1); + it.ngrn = @fromBackingInt(@intCast(@backingInt(it.ngrn) + 1)); } fn integers(it: *CallAbiIterator, isel: *Select, wip_vi: Value.Index, part_sizes: [2]u64) void { @@ -12463,11 +12463,11 @@ pub const CallAbiIterator = struct { assert(natural_alignment.order(.@"16").compare(.lte)); wip_vi.setAlignment(isel, natural_alignment.maxStrict(.@"8")); // C.8 - if (natural_alignment == .@"16") it.ngrn = @enumFromInt(std.mem.alignForward( + if (natural_alignment == .@"16") it.ngrn = @fromBackingInt(@intCast(std.mem.alignForward( @typeInfo(Register.Alias).@"enum".tag_type, - @intFromEnum(it.ngrn), + @backingInt(it.ngrn), 2, - )); + ))); if (it.ngrn == ngrn_end) return it.stack(isel, wip_vi); wip_vi.setParts(isel, part_sizes.len); for (0.., part_sizes) |part_index, part_size| @@ -12482,7 +12482,7 @@ pub const CallAbiIterator = struct { wip_vi.setIsVector(isel); if (it.nsrn == nsrn_end) return it.stack(isel, wip_vi); wip_vi.setHint(isel, it.nsrn); - it.nsrn = @enumFromInt(@intFromEnum(it.nsrn) + 1); + it.nsrn = @fromBackingInt(@intCast(@backingInt(it.nsrn) + 1)); } fn vectors( @@ -12497,7 +12497,7 @@ pub const CallAbiIterator = struct { const natural_alignment = wip_vi.alignment(isel); assert(natural_alignment.order(.@"16").compare(.lte)); wip_vi.setAlignment(isel, natural_alignment.maxStrict(.@"8")); - if (@intFromEnum(it.nsrn) > @intFromEnum(nsrn_end) - parts_len) return it.stack(isel, wip_vi); + if (@backingInt(it.nsrn) > @backingInt(nsrn_end) - parts_len) return it.stack(isel, wip_vi); if (parts_len == 1) return it.vector(isel, wip_vi); wip_vi.setParts(isel, parts_len); const fdt_size = @as(u64, 1) << fdt_log2_size; diff --git a/src/codegen/aarch64/encoding.zig b/src/codegen/aarch64/encoding.zig index c2b8d61828f1d919847bf53456b9173af4376c5b..c25d2fe507fcfe67a53e35a7e912fd8300d5aaa8 100644 --- a/src/codegen/aarch64/encoding.zig +++ b/src/codegen/aarch64/encoding.zig @@ -34,11 +34,11 @@ pub const Register = struct { quad = 4, pub fn n(ss: ScalarSize) ScalarSize { - return @enumFromInt(@intFromEnum(ss) - 1); + return @fromBackingInt(@intCast(@backingInt(ss) - 1)); } pub fn w(ss: ScalarSize) ScalarSize { - return @enumFromInt(@intFromEnum(ss) + 1); + return @fromBackingInt(@intCast(@backingInt(ss) + 1)); } pub fn prefix(ss: ScalarSize) u8 { @@ -68,10 +68,10 @@ pub const Register = struct { elem_size: Instruction.DataProcessingVector.Size, }; pub fn wrap(unwrapped: Unwrapped) Arrangement { - return @enumFromInt(@as(@typeInfo(Arrangement).@"enum".tag_type, @bitCast(unwrapped))); + return @fromBackingInt(@intCast(@as(@typeInfo(Arrangement).@"enum".tag_type, @bitCast(unwrapped)))); } pub fn unwrap(arrangement: Arrangement) Unwrapped { - return @bitCast(@intFromEnum(arrangement)); + return @bitCast(@backingInt(arrangement)); } pub fn len(arrangement: Arrangement) u5 { @@ -395,9 +395,9 @@ pub const Register = struct { pub fn decode(enc: Encoded, opts: struct { sp: bool = false, V: bool = false }) Alias { return switch (opts.V) { - false => @enumFromInt(@intFromEnum(Alias.r0) + @intFromEnum(enc) + - @intFromBool(opts.sp and enc == comptime Alias.sp.encode(.{ .sp = true }))), - true => @enumFromInt(@intFromEnum(Alias.v0) + @intFromEnum(enc)), + false => @fromBackingInt(@intCast(@backingInt(Alias.r0) + @backingInt(enc) + + @intFromBool(opts.sp and enc == comptime Alias.sp.encode(.{ .sp = true })))), + true => @fromBackingInt(@intCast(@backingInt(Alias.v0) + @backingInt(enc))), }; } }; @@ -503,38 +503,38 @@ pub const Register = struct { pub fn alias(ra: Alias, fa: Format.Alias) Register { switch (fa) { - .general => assert(@intFromEnum(ra) >= @intFromEnum(Alias.r0) and @intFromEnum(ra) <= @intFromEnum(Alias.sp)), + .general => assert(@backingInt(ra) >= @backingInt(Alias.r0) and @backingInt(ra) <= @backingInt(Alias.sp)), .other => switch (ra) { else => unreachable, .pc, .fpcr, .fpsr, .ffr => {}, }, - .vector => assert(@intFromEnum(ra) >= @intFromEnum(Alias.v0) and @intFromEnum(ra) <= @intFromEnum(Alias.v31)), - .predicate => assert(@intFromEnum(ra) >= @intFromEnum(Alias.p0) and @intFromEnum(ra) <= @intFromEnum(Alias.p15)), + .vector => assert(@backingInt(ra) >= @backingInt(Alias.v0) and @backingInt(ra) <= @backingInt(Alias.v31)), + .predicate => assert(@backingInt(ra) >= @backingInt(Alias.p0) and @backingInt(ra) <= @backingInt(Alias.p15)), } return .{ .alias = ra, .format = .{ .alias = fa } }; } pub fn general(ra: Alias, gs: GeneralSize) Register { - assert(@intFromEnum(ra) >= @intFromEnum(Alias.r0) and @intFromEnum(ra) <= @intFromEnum(Alias.sp)); + assert(@backingInt(ra) >= @backingInt(Alias.r0) and @backingInt(ra) <= @backingInt(Alias.sp)); return .{ .alias = ra, .format = .{ .general = gs } }; } pub fn scalar(ra: Alias, ss: ScalarSize) Register { - assert(@intFromEnum(ra) >= @intFromEnum(Alias.v0) and @intFromEnum(ra) <= @intFromEnum(Alias.v31)); + assert(@backingInt(ra) >= @backingInt(Alias.v0) and @backingInt(ra) <= @backingInt(Alias.v31)); return .{ .alias = ra, .format = .{ .scalar = ss } }; } pub fn vector(ra: Alias, arrangement: Arrangement) Register { - assert(@intFromEnum(ra) >= @intFromEnum(Alias.v0) and @intFromEnum(ra) <= @intFromEnum(Alias.v31)); + assert(@backingInt(ra) >= @backingInt(Alias.v0) and @backingInt(ra) <= @backingInt(Alias.v31)); return .{ .alias = ra, .format = .{ .vector = arrangement } }; } pub fn element(ra: Alias, ss: ScalarSize, index: u4) Register { - assert(@intFromEnum(ra) >= @intFromEnum(Alias.v0) and @intFromEnum(ra) <= @intFromEnum(Alias.v31)); + assert(@backingInt(ra) >= @backingInt(Alias.v0) and @backingInt(ra) <= @backingInt(Alias.v31)); return .{ .alias = ra, .format = .{ .element = .{ .size = ss, .index = index } } }; } pub fn z(ra: Alias) Register { - assert(@intFromEnum(ra) >= @intFromEnum(Alias.v0) and @intFromEnum(ra) <= @intFromEnum(Alias.v31)); + assert(@backingInt(ra) >= @backingInt(Alias.v0) and @backingInt(ra) <= @backingInt(Alias.v31)); return .{ .alias = ra, .format = .scalable }; } pub fn p(ra: Alias) Register { - assert(@intFromEnum(ra) >= @intFromEnum(Alias.p0) and @intFromEnum(ra) <= @intFromEnum(Alias.p15)); + assert(@backingInt(ra) >= @backingInt(Alias.p0) and @backingInt(ra) <= @backingInt(Alias.p15)); return .{ .alias = ra, .format = .{ .scalar = .predicate } }; } @@ -700,7 +700,7 @@ pub const Register = struct { } pub fn encode(ra: Alias, comptime opts: struct { sp: bool = false, V: bool = false }) Encoded { - return @enumFromInt(@as(u5, switch (ra) { + return @fromBackingInt(@intCast(@as(u5, switch (ra) { .r0 => if (opts.V) unreachable else 0, .r1 => if (opts.V) unreachable else 1, .r2 => if (opts.V) unreachable else 2, @@ -770,7 +770,7 @@ pub const Register = struct { .fpcr, .fpsr => unreachable, .p0, .p1, .p2, .p3, .p4, .p5, .p6, .p7, .p8, .p9, .p10, .p11, .p12, .p13, .p14, .p15 => unreachable, .ffr => unreachable, - })); + }))); } }; @@ -806,21 +806,21 @@ pub const Register = struct { else => null, 'r' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| switch (n) { 0...30 => .{ - .alias = @enumFromInt(@intFromEnum(Alias.r0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.r0) + n)), .format = .{ .alias = .general }, }, 31 => null, } else |_| null, 'x' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| switch (n) { 0...30 => .{ - .alias = @enumFromInt(@intFromEnum(Alias.r0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.r0) + n)), .format = .{ .general = .doubleword }, }, 31 => null, } else |_| if (toLowerEqlAssertLower(reg, "xzr")) .xzr else null, 'w' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| switch (n) { 0...30 => .{ - .alias = @enumFromInt(@intFromEnum(Alias.r0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.r0) + n)), .format = .{ .general = .word }, }, 31 => null, @@ -839,27 +839,27 @@ pub const Register = struct { 'f' => return if (toLowerEqlAssertLower(reg, "fp")) .fp else null, 'p' => return if (toLowerEqlAssertLower(reg, "pc")) .pc else null, 'v' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| .{ - .alias = @enumFromInt(@intFromEnum(Alias.v0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.v0) + n)), .format = .{ .alias = .vector }, } else |_| null, 'q' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| .{ - .alias = @enumFromInt(@intFromEnum(Alias.v0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.v0) + n)), .format = .{ .scalar = .quad }, } else |_| null, 'd' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| .{ - .alias = @enumFromInt(@intFromEnum(Alias.v0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.v0) + n)), .format = .{ .scalar = .double }, } else |_| null, 's' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| .{ - .alias = @enumFromInt(@intFromEnum(Alias.v0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.v0) + n)), .format = .{ .scalar = .single }, } else |_| if (toLowerEqlAssertLower(reg, "sp")) .sp else null, 'h' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| .{ - .alias = @enumFromInt(@intFromEnum(Alias.v0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.v0) + n)), .format = .{ .scalar = .half }, } else |_| null, 'b' => if (std.fmt.parseInt(u5, reg[1..], 10)) |n| .{ - .alias = @enumFromInt(@intFromEnum(Alias.v0) + n), + .alias = @fromBackingInt(@intCast(@backingInt(Alias.v0) + n)), .format = .{ .scalar = .byte }, } else |_| null, }; @@ -1363,7 +1363,7 @@ pub const ConditionCode = enum(u4) { pub const cc: ConditionCode = .lo; pub fn invert(cond: ConditionCode) ConditionCode { - return @enumFromInt(@intFromEnum(cond) ^ 0b0001); + return @fromBackingInt(@intCast(@backingInt(cond) ^ 0b0001)); } }; @@ -2772,7 +2772,7 @@ pub const Instruction = packed union { /// C6.2.37 BR pub const Br = packed struct { - Rm: Register.Encoded = @enumFromInt(0), + Rm: Register.Encoded = @fromBackingInt(@intCast(0)), Rn: Register.Encoded, M: bool = false, A: bool = false, @@ -2786,7 +2786,7 @@ pub const Instruction = packed union { /// C6.2.35 BLR pub const Blr = packed struct { - Rm: Register.Encoded = @enumFromInt(0), + Rm: Register.Encoded = @fromBackingInt(@intCast(0)), Rn: Register.Encoded, M: bool = false, A: bool = false, @@ -2800,7 +2800,7 @@ pub const Instruction = packed union { /// C6.2.254 RET pub const Ret = packed struct { - Rm: Register.Encoded = @enumFromInt(0), + Rm: Register.Encoded = @fromBackingInt(@intCast(0)), Rn: Register.Encoded, M: bool = false, A: bool = false, @@ -11131,11 +11131,11 @@ pub const Instruction = packed union { double = 0b11, pub fn n(s: Size) Size { - return @enumFromInt(@intFromEnum(s) - 1); + return @fromBackingInt(@intCast(@backingInt(s) - 1)); } pub fn w(s: Size) Size { - return @enumFromInt(@intFromEnum(s) + 1); + return @fromBackingInt(@intCast(@backingInt(s) + 1)); } pub fn toScalarSize(s: Size) Register.ScalarSize { @@ -12379,12 +12379,12 @@ pub const Instruction = packed union { switch (d.format) { else => unreachable, .scalar => |elem_size| { - assert(@intFromEnum(elem_size) <= @intFromEnum(Register.ScalarSize.double) and elem_size == n.format.element.size); + assert(@backingInt(elem_size) <= @backingInt(Register.ScalarSize.double) and elem_size == n.format.element.size); return .{ .data_processing_vector = .{ .simd_scalar_copy = .{ .dup = .{ .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{ .V = true }), - .imm5 = @shlExact(@as(u5, n.format.element.index) << 1 | @as(u5, 0b1), @intFromEnum(elem_size)), + .imm5 = @shlExact(@as(u5, n.format.element.index) << 1 | @as(u5, 0b1), @backingInt(elem_size)), }, } } }; }, @@ -12400,7 +12400,7 @@ pub const Instruction = packed union { .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{ .V = true }), .imm4 = .element, - .imm5 = @shlExact(@as(u5, element.index) << 1 | @as(u5, 0b1), @intFromEnum(elem_size)), + .imm5 = @shlExact(@as(u5, element.index) << 1 | @as(u5, 0b1), @backingInt(elem_size)), .Q = arrangement.size(), }, } } }; @@ -12415,7 +12415,7 @@ pub const Instruction = packed union { .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{}), .imm4 = .general, - .imm5 = @shlExact(@as(u5, 0b1), @intFromEnum(elem_size)), + .imm5 = @shlExact(@as(u5, 0b1), @backingInt(elem_size)), .Q = arrangement.size(), }, } } }; @@ -12867,7 +12867,7 @@ pub const Instruction = packed union { .fcmp = .{ .opc0 = .register, .Rn = n.alias.encode(.{ .V = true }), - .Rm = @enumFromInt(0b00000), + .Rm = @fromBackingInt(@intCast(0b00000)), .ftype = .fromScalarSize(ftype), }, } } }, @@ -12892,7 +12892,7 @@ pub const Instruction = packed union { .fcmpe = .{ .opc0 = .zero, .Rn = n.alias.encode(.{ .V = true }), - .Rm = @enumFromInt(0b00000), + .Rm = @fromBackingInt(@intCast(0b00000)), .ftype = .fromScalarSize(ftype), }, } } }, @@ -14194,8 +14194,8 @@ pub const Instruction = packed union { .ins = .{ .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{ .V = true }), - .imm4 = .{ .element = element.index << @intCast(@intFromEnum(elem_size)) }, - .imm5 = (@as(u5, d.format.element.index) << 1 | @as(u5, 0b1) << 0) << @intFromEnum(elem_size), + .imm4 = .{ .element = element.index << @intCast(@backingInt(elem_size)) }, + .imm5 = (@as(u5, d.format.element.index) << 1 | @as(u5, 0b1) << 0) << @backingInt(elem_size), .op = .element, }, } } }; @@ -14211,7 +14211,7 @@ pub const Instruction = packed union { .Rd = d.alias.encode(.{ .V = true }), .Rn = n.alias.encode(.{}), .imm4 = .{ .general = .general }, - .imm5 = (@as(u5, d.format.element.index) << 1 | @as(u5, 0b1) << 0) << @intFromEnum(elem_size), + .imm5 = (@as(u5, d.format.element.index) << 1 | @as(u5, 0b1) << 0) << @backingInt(elem_size), .op = .general, }, } } }; @@ -14246,7 +14246,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{}), .Rn = post_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{}), - .imm7 = @intCast(@shrExact(post_index.index, @as(u2, 2) + @intFromEnum(sf))), + .imm7 = @intCast(@shrExact(post_index.index, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -14258,7 +14258,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{}), .Rn = pre_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{}), - .imm7 = @intCast(@shrExact(pre_index.index, @as(u2, 2) + @intFromEnum(sf))), + .imm7 = @intCast(@shrExact(pre_index.index, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -14270,7 +14270,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{}), .Rn = signed_offset.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{}), - .imm7 = @intCast(@shrExact(signed_offset.offset, @as(u2, 2) + @intFromEnum(sf))), + .imm7 = @intCast(@shrExact(signed_offset.offset, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -14288,7 +14288,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{ .V = true }), .Rn = post_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{ .V = true }), - .imm7 = @intCast(@shrExact(post_index.index, @intFromEnum(vs))), + .imm7 = @intCast(@shrExact(post_index.index, @backingInt(vs))), .opc = .encode(vs), }, } } } }; @@ -14300,7 +14300,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{ .V = true }), .Rn = signed_offset.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{ .V = true }), - .imm7 = @intCast(@shrExact(signed_offset.offset, @intFromEnum(vs))), + .imm7 = @intCast(@shrExact(signed_offset.offset, @backingInt(vs))), .opc = .encode(vs), }, } } } }; @@ -14312,7 +14312,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{ .V = true }), .Rn = pre_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{ .V = true }), - .imm7 = @intCast(@shrExact(pre_index.index, @intFromEnum(vs))), + .imm7 = @intCast(@shrExact(pre_index.index, @backingInt(vs))), .opc = .encode(vs), }, } } } }; @@ -14377,7 +14377,7 @@ pub const Instruction = packed union { .ldr = .{ .Rt = t.alias.encode(.{}), .Rn = unsigned_offset.base.alias.encode(.{ .sp = true }), - .imm12 = @intCast(@shrExact(unsigned_offset.offset, @as(u2, 2) + @intFromEnum(sf))), + .imm12 = @intCast(@shrExact(unsigned_offset.offset, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -14455,7 +14455,7 @@ pub const Instruction = packed union { .ldr = .{ .Rt = t.alias.encode(.{ .V = true }), .Rn = unsigned_offset.base.alias.encode(.{ .sp = true }), - .imm12 = @intCast(@shrExact(unsigned_offset.offset, @intFromEnum(vs))), + .imm12 = @intCast(@shrExact(unsigned_offset.offset, @backingInt(vs))), .opc1 = .encode(vs), .size = .encode(vs), }, @@ -14705,7 +14705,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = post_index.base.alias.encode(.{ .sp = true }), .imm9 = post_index.index, - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14716,7 +14716,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = pre_index.base.alias.encode(.{ .sp = true }), .imm9 = pre_index.index, - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14727,7 +14727,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = unsigned_offset.base.alias.encode(.{ .sp = true }), .imm12 = unsigned_offset.offset, - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14745,7 +14745,7 @@ pub const Instruction = packed union { }, .option = extended_register_explicit.option, .Rm = extended_register_explicit.index.alias.encode(.{}), - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14787,7 +14787,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = post_index.base.alias.encode(.{ .sp = true }), .imm9 = post_index.index, - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14798,7 +14798,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = pre_index.base.alias.encode(.{ .sp = true }), .imm9 = pre_index.index, - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14809,7 +14809,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = unsigned_offset.base.alias.encode(.{ .sp = true }), .imm12 = @intCast(@shrExact(unsigned_offset.offset, 1)), - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14828,7 +14828,7 @@ pub const Instruction = packed union { }, .option = extended_register_explicit.option, .Rm = extended_register_explicit.index.alias.encode(.{}), - .opc0 = ~@intFromEnum(sf), + .opc0 = ~@backingInt(sf), }, } } } }; }, @@ -14984,7 +14984,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = n.alias.encode(.{ .sp = true }), .imm9 = simm, - .opc0 = ~@intFromEnum(t.format.general), + .opc0 = ~@backingInt(t.format.general), }, } } } }; } @@ -14996,7 +14996,7 @@ pub const Instruction = packed union { .Rt = t.alias.encode(.{}), .Rn = n.alias.encode(.{ .sp = true }), .imm9 = simm, - .opc0 = ~@intFromEnum(t.format.general), + .opc0 = ~@backingInt(t.format.general), }, } } } }; } @@ -15778,7 +15778,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{}), .Rn = post_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{}), - .imm7 = @intCast(@shrExact(post_index.index, @as(u2, 2) + @intFromEnum(sf))), + .imm7 = @intCast(@shrExact(post_index.index, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -15790,7 +15790,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{}), .Rn = pre_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{}), - .imm7 = @intCast(@shrExact(pre_index.index, @as(u2, 2) + @intFromEnum(sf))), + .imm7 = @intCast(@shrExact(pre_index.index, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -15802,7 +15802,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{}), .Rn = signed_offset.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{}), - .imm7 = @intCast(@shrExact(signed_offset.offset, @as(u2, 2) + @intFromEnum(sf))), + .imm7 = @intCast(@shrExact(signed_offset.offset, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -15820,7 +15820,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{ .V = true }), .Rn = post_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{ .V = true }), - .imm7 = @intCast(@shrExact(post_index.index, @intFromEnum(vs))), + .imm7 = @intCast(@shrExact(post_index.index, @backingInt(vs))), .opc = .encode(vs), }, } } } }; @@ -15832,7 +15832,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{ .V = true }), .Rn = signed_offset.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{ .V = true }), - .imm7 = @intCast(@shrExact(signed_offset.offset, @intFromEnum(vs))), + .imm7 = @intCast(@shrExact(signed_offset.offset, @backingInt(vs))), .opc = .encode(vs), }, } } } }; @@ -15844,7 +15844,7 @@ pub const Instruction = packed union { .Rt = t1.alias.encode(.{ .V = true }), .Rn = pre_index.base.alias.encode(.{ .sp = true }), .Rt2 = t2.alias.encode(.{ .V = true }), - .imm7 = @intCast(@shrExact(pre_index.index, @intFromEnum(vs))), + .imm7 = @intCast(@shrExact(pre_index.index, @backingInt(vs))), .opc = .encode(vs), }, } } } }; @@ -15893,7 +15893,7 @@ pub const Instruction = packed union { .str = .{ .Rt = t.alias.encode(.{}), .Rn = unsigned_offset.base.alias.encode(.{ .sp = true }), - .imm12 = @intCast(@shrExact(unsigned_offset.offset, @as(u2, 2) + @intFromEnum(sf))), + .imm12 = @intCast(@shrExact(unsigned_offset.offset, @as(u2, 2) + @backingInt(sf))), .sf = sf, }, } } } }; @@ -15931,7 +15931,7 @@ pub const Instruction = packed union { .str = .{ .Rt = t.alias.encode(.{ .V = true }), .Rn = unsigned_offset.base.alias.encode(.{ .sp = true }), - .imm12 = @intCast(@shrExact(unsigned_offset.offset, @intFromEnum(vs))), + .imm12 = @intCast(@shrExact(unsigned_offset.offset, @backingInt(vs))), .opc1 = .encode(vs), .size = .encode(vs), }, diff --git a/src/codegen/c.zig b/src/codegen/c.zig index bf1d0ab00fb16a94f4144f3d6d6dd5f7a54fac67..0dc4ae6f3997ae55f4b068f725d5a02b3dea50a7 100644 --- a/src/codegen/c.zig +++ b/src/codegen/c.zig @@ -1657,10 +1657,10 @@ pub const DeclGen = struct { switch (name) { .nav => |nav| try renderNavName(w, nav, ip), .nav_never_tail => |nav| try w.print("zig_never_tail_{f}__{d}", .{ - fmtIdentUnsolo(ip.getNav(nav).name.toSlice(ip)), @intFromEnum(nav), + fmtIdentUnsolo(ip.getNav(nav).name.toSlice(ip)), @backingInt(nav), }), .nav_never_inline => |nav| try w.print("zig_never_inline_{f}__{d}", .{ - fmtIdentUnsolo(ip.getNav(nav).name.toSlice(ip)), @intFromEnum(nav), + fmtIdentUnsolo(ip.getNav(nav).name.toSlice(ip)), @backingInt(nav), }), .@"export" => |@"export"| try w.print("{f}", .{fmtIdentSolo(@"export".extern_name.toSlice(ip))}), } @@ -2121,7 +2121,7 @@ pub fn genTagNameFn( try w.print("static {s} zig_tagName_{f}__{d}({s} tag) {{\n", .{ slice_const_u8_sentinel_0_type_name, fmtIdentUnsolo(loaded_enum.name.toSlice(ip)), - @intFromEnum(enum_ty.toIntern()), + @backingInt(enum_ty.toIntern()), enum_type_name, }); for (loaded_enum.field_names.get(ip), 0..) |field_name, field_index| { @@ -2636,7 +2636,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) Error!void { if (f.liveness.isUnused(inst) and !f.air.mustLower(inst, ip)) continue; - const result_value = switch (air_tags[@intFromEnum(inst)]) { + const result_value = switch (air_tags[@backingInt(inst)]) { // zig fmt: off .inferred_alloc, .inferred_alloc_comptime => unreachable, @@ -2948,7 +2948,7 @@ fn genBodyInner(f: *Function, body: []const Air.Inst.Index) Error!void { } fn airSliceField(f: *Function, inst: Air.Inst.Index, is_ptr: bool, field_name: []const u8) !CValue { - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const operand = try f.resolveInst(ty_op.operand); @@ -2970,7 +2970,7 @@ fn airSliceField(f: *Function, inst: Air.Inst.Index, is_ptr: bool, field_name: [ fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue { const zcu = f.dg.pt.zcu; const inst_ty = f.typeOfIndex(inst); - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; assert(inst_ty.hasRuntimeBits(zcu)); const ptr = try f.resolveInst(bin_op.lhs); @@ -2996,7 +2996,7 @@ fn airPtrElemVal(f: *Function, inst: Air.Inst.Index) !CValue { fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data; const inst_ty = f.typeOfIndex(inst); @@ -3028,7 +3028,7 @@ fn airPtrElemPtr(f: *Function, inst: Air.Inst.Index) !CValue { fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue { const zcu = f.dg.pt.zcu; const inst_ty = f.typeOfIndex(inst); - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; assert(inst_ty.hasRuntimeBits(zcu)); const slice = try f.resolveInst(bin_op.lhs); @@ -3050,7 +3050,7 @@ fn airSliceElemVal(f: *Function, inst: Air.Inst.Index) !CValue { fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data; const inst_ty = f.typeOfIndex(inst); @@ -3077,7 +3077,7 @@ fn airSliceElemPtr(f: *Function, inst: Air.Inst.Index) !CValue { fn airArrayElemVal(f: *Function, inst: Air.Inst.Index) !CValue { const zcu = f.dg.pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const inst_ty = f.typeOfIndex(inst); assert(inst_ty.hasRuntimeBits(zcu)); @@ -3098,7 +3098,7 @@ fn airArrayElemVal(f: *Function, inst: Air.Inst.Index) !CValue { } fn airLegalizeVecStoreElem(f: *Function, inst: Air.Inst.Index) !CValue { - const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = f.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = f.air.extraData(Air.Bin, pl_op.payload).data; const vec_ptr = try f.resolveInst(pl_op.operand); @@ -3209,7 +3209,7 @@ fn airArg(f: *Function, inst: Air.Inst.Index) !CValue { fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const ptr_ty = f.typeOf(ty_op.operand); const ptr_scalar_ty = ptr_ty.scalarType(zcu); @@ -3243,7 +3243,7 @@ fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue { else => |index| { try w.writeByte('&'); try f.writeCValue(w, operand, .other); - try w.print("[{d}]", .{@intFromEnum(index)}); + try w.print("[{d}]", .{@backingInt(index)}); }, } try w.writeAll(", sizeof("); @@ -3256,7 +3256,7 @@ fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue { .none => try f.writeCValueDeref(w, operand), else => |index| { try f.writeCValue(w, operand, .other); - try w.print("[{d}]", .{@intFromEnum(index)}); + try w.print("[{d}]", .{@backingInt(index)}); }, } } @@ -3269,13 +3269,13 @@ fn airLoad(f: *Function, inst: Air.Inst.Index) !CValue { fn airRet(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !void { const pt = f.dg.pt; const zcu = pt.zcu; - const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = f.air.instructions.items(.data)[@backingInt(inst)].un_op; const w = &f.code.writer; const op_inst = un_op.toIndex(); const op_ty = f.typeOf(un_op); const ret_ty = if (is_ptr) op_ty.childType(zcu) else op_ty; - if (op_inst != null and f.air.instructions.items(.tag)[@intFromEnum(op_inst.?)] == .call_always_tail) { + if (op_inst != null and f.air.instructions.items(.tag)[@backingInt(op_inst.?)] == .call_always_tail) { try reap(f, inst, &.{un_op}); _ = try airCall(f, op_inst.?, .always_tail); } else if (ret_ty.hasRuntimeBits(zcu)) { @@ -3301,7 +3301,7 @@ fn airRet(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !void { fn airIntCast(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try f.resolveInst(ty_op.operand); try reap(f, inst, &.{ty_op.operand}); @@ -3332,7 +3332,7 @@ fn airIntCast(f: *Function, inst: Air.Inst.Index) !CValue { fn airTrunc(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try f.resolveInst(ty_op.operand); try reap(f, inst, &.{ty_op.operand}); @@ -3419,7 +3419,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; // *a = b; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = f.typeOf(bin_op.lhs); const ptr_scalar_ty = ptr_ty.scalarType(zcu); @@ -3482,7 +3482,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue { else => |index| { try w.writeByte('&'); try f.writeCValue(w, ptr_val, .other); - try w.print("[{d}]", .{@intFromEnum(index)}); + try w.print("[{d}]", .{@backingInt(index)}); }, } try w.writeAll(", &"); @@ -3508,7 +3508,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue { .none => try f.writeCValueDeref(w, ptr_val), else => |index| { try f.writeCValue(w, ptr_val, .other); - try w.print("[{d}]", .{@intFromEnum(index)}); + try w.print("[{d}]", .{@backingInt(index)}); }, } try w.writeAll(" = "); @@ -3522,7 +3522,7 @@ fn airStore(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue { fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info: BuiltinInfo) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try f.resolveInst(bin_op.lhs); @@ -3584,7 +3584,7 @@ fn airOverflow(f: *Function, inst: Air.Inst.Index, operation: []const u8, info: fn airNot(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = f.typeOf(ty_op.operand); const scalar_ty = operand_ty.scalarType(zcu); if (scalar_ty.toIntern() != .bool_type) return try airUnBuiltinCall(f, inst, ty_op.operand, "not", .bits); @@ -3619,7 +3619,7 @@ fn airBinOp( ) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const operand_ty = f.typeOf(bin_op.lhs); const scalar_ty = operand_ty.scalarType(zcu); if ((scalar_ty.isInt(zcu) and scalar_ty.bitSize(zcu) > 64) or scalar_ty.isRuntimeFloat()) @@ -3715,7 +3715,7 @@ fn airEquality( ) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const operand_ty = f.typeOf(bin_op.lhs); if (operand_ty.isAbiInt(zcu)) { @@ -3799,7 +3799,7 @@ fn airEquality( } fn airCmpLteErrorsLen(f: *Function, inst: Air.Inst.Index) !CValue { - const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = f.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try f.resolveInst(un_op); try reap(f, inst, &.{un_op}); @@ -3817,7 +3817,7 @@ fn airCmpLteErrorsLen(f: *Function, inst: Air.Inst.Index) !CValue { fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try f.resolveInst(bin_op.lhs); @@ -3857,7 +3857,7 @@ fn airPtrAddSub(f: *Function, inst: Air.Inst.Index, operator: u8) !CValue { fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8, operation: []const u8) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const inst_ty = f.typeOfIndex(inst); const inst_scalar_ty = inst_ty.scalarType(zcu); @@ -3897,7 +3897,7 @@ fn airMinMax(f: *Function, inst: Air.Inst.Index, operator: u8, operation: []cons } fn airSlice(f: *Function, inst: Air.Inst.Index) !CValue { - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = f.air.extraData(Air.Bin, ty_pl.payload).data; const ptr = try f.resolveInst(bin_op.lhs); @@ -4014,13 +4014,13 @@ fn airCall( .never_tail => { try f.need_never_tail_funcs.put(gpa, fn_nav, {}); try w.print("zig_never_tail_{f}__{d}", .{ - fmtIdentUnsolo(ip.getNav(fn_nav).name.toSlice(ip)), @intFromEnum(fn_nav), + fmtIdentUnsolo(ip.getNav(fn_nav).name.toSlice(ip)), @backingInt(fn_nav), }); }, .never_inline => { try f.need_never_inline_funcs.put(gpa, fn_nav, {}); try w.print("zig_never_inline_{f}__{d}", .{ - fmtIdentUnsolo(ip.getNav(fn_nav).name.toSlice(ip)), @intFromEnum(fn_nav), + fmtIdentUnsolo(ip.getNav(fn_nav).name.toSlice(ip)), @backingInt(fn_nav), }); }, else => unreachable, @@ -4056,7 +4056,7 @@ fn airCall( } fn airDbgStmt(f: *Function, inst: Air.Inst.Index) !CValue { - const dbg_stmt = f.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = f.air.instructions.items(.data)[@backingInt(inst)].dbg_stmt; const w = &f.code.writer; // TODO re-evaluate whether to emit these or not. If we naively emit // these directives, the output file will report bogus line numbers because @@ -4093,9 +4093,9 @@ fn airDbgInlineBlock(f: *Function, inst: Air.Inst.Index) !CValue { fn airDbgVar(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const tag = f.air.instructions.items(.tag)[@intFromEnum(inst)]; - const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; - const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const tag = f.air.instructions.items(.tag)[@backingInt(inst)]; + const pl_op = f.air.instructions.items(.data)[@backingInt(inst)].pl_op; + const name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); const operand_is_undef = if (pl_op.operand.toInterned()) |ip_index| Value.fromInterned(ip_index).isUndef(zcu) else false; if (!operand_is_undef) _ = try f.resolveInst(pl_op.operand); @@ -4236,7 +4236,7 @@ fn lowerTry( } fn airBr(f: *Function, inst: Air.Inst.Index) !void { - const branch = f.air.instructions.items(.data)[@intFromEnum(inst)].br; + const branch = f.air.instructions.items(.data)[@backingInt(inst)].br; const block = f.blocks.get(branch.block_inst).?; const result = block.result; const w = &f.code.writer; @@ -4263,14 +4263,14 @@ fn airBr(f: *Function, inst: Air.Inst.Index) !void { } fn airRepeat(f: *Function, inst: Air.Inst.Index) !void { - const repeat = f.air.instructions.items(.data)[@intFromEnum(inst)].repeat; - try f.code.writer.print("goto zig_loop_{d};\n", .{@intFromEnum(repeat.loop_inst)}); + const repeat = f.air.instructions.items(.data)[@backingInt(inst)].repeat; + try f.code.writer.print("goto zig_loop_{d};\n", .{@backingInt(repeat.loop_inst)}); } fn airSwitchDispatch(f: *Function, inst: Air.Inst.Index) !void { const pt = f.dg.pt; const zcu = pt.zcu; - const br = f.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = f.air.instructions.items(.data)[@backingInt(inst)].br; const w = &f.code.writer; if (br.operand.toInterned()) |cond_ip_index| { @@ -4294,7 +4294,7 @@ fn airSwitchDispatch(f: *Function, inst: Air.Inst.Index) !void { } } } else switch_br.cases_len; - try w.print("goto zig_switch_{d}_dispatch_{d};\n", .{ @intFromEnum(br.block_inst), target_case_idx }); + try w.print("goto zig_switch_{d}_dispatch_{d};\n", .{ @backingInt(br.block_inst), target_case_idx }); return; } @@ -4306,7 +4306,7 @@ fn airSwitchDispatch(f: *Function, inst: Air.Inst.Index) !void { try f.writeCValue(w, cond, .other); try w.writeByte(';'); try f.newline(); - try w.print("goto zig_switch_{d}_loop;\n", .{@intFromEnum(br.block_inst)}); + try w.print("goto zig_switch_{d}_loop;\n", .{@backingInt(br.block_inst)}); } fn airPtrCast(f: *Function, inst: Air.Inst.Index) Error!CValue { @@ -4325,7 +4325,7 @@ fn airPtrCast(f: *Function, inst: Air.Inst.Index) Error!CValue { // For slice casts we need to assign both fields. - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try f.resolveInst(ty_op.operand); const w = &f.code.writer; @@ -4352,7 +4352,7 @@ fn airPtrCast(f: *Function, inst: Air.Inst.Index) Error!CValue { fn airSimpleCast(f: *Function, inst: Air.Inst.Index) Error!CValue { const zcu = f.dg.pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const dest_ty = f.typeOfIndex(inst); const operand_ty = f.typeOf(ty_op.operand); const operand = try f.resolveInst(ty_op.operand); @@ -4378,7 +4378,7 @@ fn airSimpleCast(f: *Function, inst: Air.Inst.Index) Error!CValue { fn airNopCast(f: *Function, inst: Air.Inst.Index) Error!CValue { const zcu = f.dg.pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const dest_ty = f.typeOfIndex(inst); const operand_ty = f.typeOf(ty_op.operand); const operand = try f.resolveInst(ty_op.operand); @@ -4393,7 +4393,7 @@ fn airNopCast(f: *Function, inst: Air.Inst.Index) Error!CValue { fn airUnionFromEnum(f: *Function, inst: Air.Inst.Index) Error!CValue { const zcu = f.dg.pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const dest_ty = f.typeOfIndex(inst); const operand_ty = f.typeOf(ty_op.operand); const operand = try f.resolveInst(ty_op.operand); @@ -4418,7 +4418,7 @@ fn airBitCast(f: *Function, inst: Air.Inst.Index) Error!CValue { const zcu = pt.zcu; const w = &f.code.writer; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const dest_ty = f.typeOfIndex(inst); const operand = try f.resolveInst(ty_op.operand); @@ -4594,7 +4594,7 @@ fn airLoop(f: *Function, inst: Air.Inst.Index) !void { // this label. Since we need a label for arbitrary `repeat` // anyway, there's actually no need to use a "real" looping // construct at all! - try w.print("zig_loop_{d}:", .{@intFromEnum(inst)}); + try w.print("zig_loop_{d}:", .{@backingInt(inst)}); try f.newline(); try genBodyInner(f, block.body); // no need to restore state, we're noreturn } @@ -4647,7 +4647,7 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void const cond_val = if (is_dispatch_loop) cond: { const new_local = try f.allocLocal(inst, cond_ty); try f.copyCValue(new_local, init_condition); - try w.print("zig_switch_{d}_loop:", .{@intFromEnum(inst)}); + try w.print("zig_switch_{d}_loop:", .{@backingInt(inst)}); try f.newline(); try f.loop_switch_conds.put(gpa, inst, new_local.new_local); break :cond new_local; @@ -4757,7 +4757,7 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void f.indent(); try f.newline(); if (is_dispatch_loop) { - try w.print("zig_switch_{d}_dispatch_{d}:;", .{ @intFromEnum(inst), case.idx }); + try w.print("zig_switch_{d}_dispatch_{d}:;", .{ @backingInt(inst), case.idx }); try f.newline(); } try genBodyResolveState(f, inst, liveness.deaths[case.idx], case.body, true); @@ -4781,7 +4781,7 @@ fn airSwitchBr(f: *Function, inst: Air.Inst.Index, is_dispatch_loop: bool) !void try lowerSwitchToConditions(f, inst, cond_val, lowered_cond_ty, switch_br, liveness, is_dispatch_loop, true); } if (is_dispatch_loop) { - try w.print("zig_switch_{d}_dispatch_{d}: ", .{ @intFromEnum(inst), switch_br.cases_len }); + try w.print("zig_switch_{d}_dispatch_{d}: ", .{ @backingInt(inst), switch_br.cases_len }); } const else_body = it.elseBody(); if (else_body.len > 0) { @@ -4838,7 +4838,7 @@ fn lowerSwitchToConditions( f.indent(); try f.newline(); if (is_dispatch_loop) { - try w.print("zig_switch_{d}_dispatch_{d}: ", .{ @intFromEnum(inst), case.idx }); + try w.print("zig_switch_{d}_dispatch_{d}: ", .{ @backingInt(inst), case.idx }); } try genBodyResolveState(f, inst, liveness.deaths[case.idx], case.body, true); try f.outdent(); @@ -4850,7 +4850,7 @@ fn lowerSwitchToConditions( if (!only_ranges) { if (is_dispatch_loop) { - try w.print("zig_switch_{d}_dispatch_{d}: ", .{ @intFromEnum(inst), switch_br.cases_len }); + try w.print("zig_switch_{d}_dispatch_{d}: ", .{ @backingInt(inst), switch_br.cases_len }); } const else_body = it.elseBody(); if (else_body.len > 0) { @@ -5210,7 +5210,7 @@ fn airIsNull( ) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = f.air.instructions.items(.data)[@backingInt(inst)].un_op; const w = &f.code.writer; const operand = try f.resolveInst(un_op); @@ -5268,7 +5268,7 @@ fn airIsNull( fn airOptionalPayload(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const operand_ty = f.typeOf(ty_op.operand); @@ -5305,7 +5305,7 @@ fn airOptionalPayload(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue fn airOptionalPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const w = &f.code.writer; const operand = try f.resolveInst(ty_op.operand); try reap(f, inst, &.{ty_op.operand}); @@ -5418,7 +5418,7 @@ fn fieldLocation( } fn airStructFieldPtr(f: *Function, inst: Air.Inst.Index) !CValue { - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = f.air.extraData(Air.StructField, ty_pl.payload).data; const container_ptr_val = try f.resolveInst(extra.struct_operand); @@ -5428,7 +5428,7 @@ fn airStructFieldPtr(f: *Function, inst: Air.Inst.Index) !CValue { } fn airStructFieldPtrIndex(f: *Function, inst: Air.Inst.Index, index: u8) !CValue { - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const container_ptr_val = try f.resolveInst(ty_op.operand); try reap(f, inst, &.{ty_op.operand}); @@ -5439,7 +5439,7 @@ fn airStructFieldPtrIndex(f: *Function, inst: Air.Inst.Index, index: u8) !CValue fn airFieldParentPtr(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = f.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; const container_ptr_ty = f.typeOfIndex(inst); @@ -5535,7 +5535,7 @@ fn airAggFieldVal(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = f.air.extraData(Air.StructField, ty_pl.payload).data; const inst_ty = f.typeOfIndex(inst); @@ -5573,7 +5573,7 @@ fn airAggFieldVal(f: *Function, inst: Air.Inst.Index) !CValue { fn airUnwrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const operand = try f.resolveInst(ty_op.operand); @@ -5599,7 +5599,7 @@ fn airUnwrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue { fn airUnwrapErrUnionPay(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const operand = try f.resolveInst(ty_op.operand); @@ -5635,7 +5635,7 @@ fn airUnwrapErrUnionPay(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValu fn airWrapOptional(f: *Function, inst: Air.Inst.Index) !CValue { const zcu = f.dg.pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); @@ -5673,7 +5673,7 @@ fn airWrapOptional(f: *Function, inst: Air.Inst.Index) !CValue { fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const payload_ty = inst_ty.errorUnionPayload(zcu); @@ -5703,7 +5703,7 @@ fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue { fn airErrUnionPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const w = &f.code.writer; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const operand = try f.resolveInst(ty_op.operand); @@ -5746,7 +5746,7 @@ fn airSaveErrReturnTraceIndex(f: *Function, inst: Air.Inst.Index) !CValue { fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const payload_ty = inst_ty.errorUnionPayload(zcu); @@ -5774,7 +5774,7 @@ fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue { fn airIsErr(f: *Function, inst: Air.Inst.Index, is_ptr: bool, operator: []const u8) !CValue { const pt = f.dg.pt; - const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = f.air.instructions.items(.data)[@backingInt(inst)].un_op; const w = &f.code.writer; const operand = try f.resolveInst(un_op); @@ -5798,7 +5798,7 @@ fn airIsErr(f: *Function, inst: Air.Inst.Index, is_ptr: bool, operator: []const fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try f.resolveInst(ty_op.operand); try reap(f, inst, &.{ty_op.operand}); @@ -5835,7 +5835,7 @@ fn airArrayToSlice(f: *Function, inst: Air.Inst.Index) !CValue { fn airFloatCast(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const inst_scalar_ty = inst_ty.scalarType(zcu); @@ -5939,7 +5939,7 @@ fn airBinBuiltinCall( ) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const operand_ty = f.typeOf(bin_op.lhs); const is_big = lowersToBigInt(operand_ty, zcu); @@ -6052,7 +6052,7 @@ fn airCmpBuiltinCall( fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = f.air.extraData(Air.Cmpxchg, ty_pl.payload).data; const inst_ty = f.typeOfIndex(inst); const ptr = try f.resolveInst(extra.ptr); @@ -6151,7 +6151,7 @@ fn airCmpxchg(f: *Function, inst: Air.Inst.Index, flavor: [*:0]const u8) !CValue fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = f.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = f.air.extraData(Air.AtomicRmw, pl_op.payload).data; const inst_ty = f.typeOfIndex(inst); const ptr_ty = f.typeOf(pl_op.operand); @@ -6208,7 +6208,7 @@ fn airAtomicRmw(f: *Function, inst: Air.Inst.Index) !CValue { fn airAtomicLoad(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const atomic_load = f.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; + const atomic_load = f.air.instructions.items(.data)[@backingInt(inst)].atomic_load; const ptr = try f.resolveInst(atomic_load.ptr); try reap(f, inst, &.{atomic_load.ptr}); const ptr_ty = f.typeOf(atomic_load.ptr); @@ -6246,7 +6246,7 @@ fn airAtomicLoad(f: *Function, inst: Air.Inst.Index) !CValue { fn airAtomicStore(f: *Function, inst: Air.Inst.Index, order: [*:0]const u8) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = f.typeOf(bin_op.lhs); const ty = ptr_ty.childType(zcu); const ptr = try f.resolveInst(bin_op.lhs); @@ -6283,7 +6283,7 @@ fn airAtomicStore(f: *Function, inst: Air.Inst.Index, order: [*:0]const u8) !CVa fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dest_ty = f.typeOf(bin_op.lhs); const dest_slice = try f.resolveInst(bin_op.lhs); const value = try f.resolveInst(bin_op.rhs); @@ -6389,7 +6389,7 @@ fn airMemset(f: *Function, inst: Air.Inst.Index, safety: bool) !CValue { fn airMemcpy(f: *Function, inst: Air.Inst.Index, function_paren: []const u8) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dest_ptr = try f.resolveInst(bin_op.lhs); const src_ptr = try f.resolveInst(bin_op.rhs); const dest_ty = f.typeOf(bin_op.lhs); @@ -6431,7 +6431,7 @@ fn airMemcpy(f: *Function, inst: Air.Inst.Index, function_paren: []const u8) !CV fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const bin_op = f.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = f.air.instructions.items(.data)[@backingInt(inst)].bin_op; const union_ptr = try f.resolveInst(bin_op.lhs); const new_tag = try f.resolveInst(bin_op.rhs); try reap(f, inst, &.{ bin_op.lhs, bin_op.rhs }); @@ -6452,7 +6452,7 @@ fn airSetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue { fn airGetUnionTag(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try f.resolveInst(ty_op.operand); try reap(f, inst, &.{ty_op.operand}); @@ -6476,7 +6476,7 @@ fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue { const zcu = f.dg.pt.zcu; const ip = &zcu.intern_pool; const gpa = zcu.comp.gpa; - const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = f.air.instructions.items(.data)[@backingInt(inst)].un_op; const inst_ty = f.typeOfIndex(inst); const enum_ty = f.typeOf(un_op); @@ -6489,7 +6489,7 @@ fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue { try f.need_tag_name_funcs.put(gpa, enum_ty.toIntern(), {}); try w.print(" = zig_tagName_{f}__{d}(", .{ fmtIdentUnsolo(enum_ty.containerTypeName(ip).toSlice(ip)), - @intFromEnum(enum_ty.toIntern()), + @backingInt(enum_ty.toIntern()), }); try f.writeCValue(w, operand, .other); try w.writeAll(");"); @@ -6499,7 +6499,7 @@ fn airTagName(f: *Function, inst: Air.Inst.Index) !CValue { } fn airErrorName(f: *Function, inst: Air.Inst.Index) !CValue { - const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = f.air.instructions.items(.data)[@backingInt(inst)].un_op; const w = &f.code.writer; const inst_ty = f.typeOfIndex(inst); @@ -6516,7 +6516,7 @@ fn airErrorName(f: *Function, inst: Air.Inst.Index) !CValue { } fn airSplat(f: *Function, inst: Air.Inst.Index) !CValue { - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try f.resolveInst(ty_op.operand); try reap(f, inst, &.{ty_op.operand}); @@ -6538,7 +6538,7 @@ fn airSplat(f: *Function, inst: Air.Inst.Index) !CValue { } fn airSelect(f: *Function, inst: Air.Inst.Index) !CValue { - const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = f.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = f.air.extraData(Air.Bin, pl_op.payload).data; const pred = try f.resolveInst(pl_op.operand); @@ -6645,7 +6645,7 @@ fn airShuffleTwo(f: *Function, inst: Air.Inst.Index) !CValue { fn airReduce(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const reduce = f.air.instructions.items(.data)[@intFromEnum(inst)].reduce; + const reduce = f.air.instructions.items(.data)[@backingInt(inst)].reduce; const scalar_ty = f.typeOfIndex(inst); const operand = try f.resolveInst(reduce.operand); @@ -6784,7 +6784,7 @@ fn airAggregateInit(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const inst_ty = f.typeOfIndex(inst); const len: usize = @intCast(inst_ty.arrayLen(zcu)); const elements: []const Air.Inst.Ref = @ptrCast(f.air.extra.items[ty_pl.payload..][0..len]); @@ -6860,7 +6860,7 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const ty_pl = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = f.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = f.air.extraData(Air.UnionInit, ty_pl.payload).data; const field_index = extra.field_index; @@ -6904,7 +6904,7 @@ fn airUnionInit(f: *Function, inst: Air.Inst.Index) !CValue { fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const prefetch = f.air.instructions.items(.data)[@intFromEnum(inst)].prefetch; + const prefetch = f.air.instructions.items(.data)[@backingInt(inst)].prefetch; const ptr_ty = f.typeOf(prefetch.ptr); const ptr = try f.resolveInst(prefetch.ptr); @@ -6918,7 +6918,7 @@ fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue { try f.writeCValueMember(w, ptr, .{ .identifier = "ptr" }) else try f.writeCValue(w, ptr, .other); - try w.print(", {d}, {d});", .{ @intFromEnum(prefetch.rw), prefetch.locality }); + try w.print(", {d}, {d});", .{ @backingInt(prefetch.rw), prefetch.locality }); try f.newline(); }, // The available prefetch intrinsics do not accept a cache argument; only @@ -6930,7 +6930,7 @@ fn airPrefetch(f: *Function, inst: Air.Inst.Index) !CValue { } fn airWasmMemorySize(f: *Function, inst: Air.Inst.Index) !CValue { - const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = f.air.instructions.items(.data)[@backingInt(inst)].pl_op; const w = &f.code.writer; const inst_ty = f.typeOfIndex(inst); @@ -6945,7 +6945,7 @@ fn airWasmMemorySize(f: *Function, inst: Air.Inst.Index) !CValue { } fn airWasmMemoryGrow(f: *Function, inst: Air.Inst.Index) !CValue { - const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = f.air.instructions.items(.data)[@backingInt(inst)].pl_op; const w = &f.code.writer; const inst_ty = f.typeOfIndex(inst); @@ -6965,7 +6965,7 @@ fn airWasmMemoryGrow(f: *Function, inst: Air.Inst.Index) !CValue { fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue { const pt = f.dg.pt; const zcu = pt.zcu; - const pl_op = f.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = f.air.instructions.items(.data)[@backingInt(inst)].pl_op; const bin_op = f.air.extraData(Air.Bin, pl_op.payload).data; const mulend1 = try f.resolveInst(bin_op.lhs); @@ -7000,7 +7000,7 @@ fn airMulAdd(f: *Function, inst: Air.Inst.Index) !CValue { } fn airRuntimeNavPtr(f: *Function, inst: Air.Inst.Index) !CValue { - const ty_nav = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav; + const ty_nav = f.air.instructions.items(.data)[@backingInt(inst)].ty_nav; const w = &f.code.writer; const local = try f.allocLocal(inst, .fromInterned(ty_nav.ty)); try f.writeCValue(w, local, .other); @@ -7032,7 +7032,7 @@ fn airCVaStart(f: *Function, inst: Air.Inst.Index) !CValue { } fn airCVaArg(f: *Function, inst: Air.Inst.Index) !CValue { - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const va_list = try f.resolveInst(ty_op.operand); @@ -7051,7 +7051,7 @@ fn airCVaArg(f: *Function, inst: Air.Inst.Index) !CValue { } fn airCVaEnd(f: *Function, inst: Air.Inst.Index) !CValue { - const un_op = f.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = f.air.instructions.items(.data)[@backingInt(inst)].un_op; const va_list = try f.resolveInst(un_op); try reap(f, inst, &.{un_op}); @@ -7065,7 +7065,7 @@ fn airCVaEnd(f: *Function, inst: Air.Inst.Index) !CValue { } fn airCVaCopy(f: *Function, inst: Air.Inst.Index) !CValue { - const ty_op = f.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = f.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = f.typeOfIndex(inst); const va_list = try f.resolveInst(ty_op.operand); @@ -7830,9 +7830,9 @@ fn freeLocal(f: *Function, inst: ?Air.Inst.Index, local_index: LocalIndex, ref_i const local = f.locals.items[local_index]; if (inst) |i| { if (ref_inst) |operand| { - log.debug("%{d}: freeing t{d} (operand %{d})", .{ @intFromEnum(i), local_index, operand }); + log.debug("%{d}: freeing t{d} (operand %{d})", .{ @backingInt(i), local_index, operand }); } else { - log.debug("%{d}: freeing t{d}", .{ @intFromEnum(i), local_index }); + log.debug("%{d}: freeing t{d}", .{ @backingInt(i), local_index }); } } else { if (ref_inst) |operand| { @@ -7915,11 +7915,11 @@ fn renderNavName(w: *Writer, nav_index: InternPool.Nav.Index, ip: *const InternP const fqn_slice = ip.getNav(nav_index).fqn.toSlice(ip); try w.print("{f}__{d}", .{ fmtIdentUnsolo(fqn_slice[0..@min(fqn_slice.len, 100)]), - @intFromEnum(nav_index), + @backingInt(nav_index), }); } } fn renderUavName(w: *Writer, uav: Value) !void { - try w.print("__anon_{d}", .{@intFromEnum(uav.toIntern())}); + try w.print("__anon_{d}", .{@backingInt(uav.toIntern())}); } diff --git a/src/codegen/c/type.zig b/src/codegen/c/type.zig index 8588c1dd030849f586a2c5ad719087ab6e4412e7..8e86c0da93dabcda0bdfec08c406bbe0dab4f04d 100644 --- a/src/codegen/c/type.zig +++ b/src/codegen/c/type.zig @@ -904,7 +904,7 @@ pub const CType = union(enum) { }, .error_set => switch (ty.toIntern()) { .anyerror_type => try w.writeAll("anyerror"), - else => try w.print("error_{d}", .{@intFromEnum(ty.toIntern())}), + else => try w.print("error_{d}", .{@backingInt(ty.toIntern())}), }, .optional => try w.print("opt_{f}", .{fmtZigType(ty.optionalChild(zcu), zcu)}), .error_union => try w.print("errunion_{f}", .{fmtZigType(ty.errorUnionPayload(zcu), zcu)}), @@ -944,7 +944,7 @@ pub const CType = union(enum) { .array => if (ty.sentinel(zcu)) |s| try w.print("arr_{d}s{d}_{f}", .{ ty.arrayLen(zcu), - @intFromEnum(s.toIntern()), + @backingInt(s.toIntern()), fmtZigType(ty.childType(zcu), zcu), }) else try w.print("arr_{d}_{f}", .{ ty.arrayLen(zcu), diff --git a/src/codegen/llvm.zig b/src/codegen/llvm.zig index 59a27d8b408f62cd189bbad84ca30e68bd1b5235..fc1c494828fc8d8f141be115c54231bcbe38814c 100644 --- a/src/codegen/llvm.zig +++ b/src/codegen/llvm.zig @@ -1739,14 +1739,14 @@ pub const Object = struct { assert(zcu.intern_pool.typeOf(val) == .type_type); { - assert(@intFromEnum(index) == o.lazy_abi_aligns.items.len); + assert(@backingInt(index) == o.lazy_abi_aligns.items.len); try o.lazy_abi_aligns.ensureUnusedCapacity(gpa, 1); const fwd_ref = try o.builder.alignmentForwardReference(); o.lazy_abi_aligns.appendAssumeCapacity(fwd_ref); } if (!o.builder.strip) { - assert(@intFromEnum(index) == o.debug_types.items.len); + assert(@backingInt(index) == o.debug_types.items.len); try o.debug_types.ensureUnusedCapacity(gpa, 1); const fwd_ref = try o.builder.debugForwardReference(); o.debug_types.appendAssumeCapacity(fwd_ref); @@ -1766,13 +1766,13 @@ pub const Object = struct { const ty: Type = .fromInterned(val); { - const fwd_ref = o.lazy_abi_aligns.items[@intFromEnum(index)]; + const fwd_ref = o.lazy_abi_aligns.items[@backingInt(index)]; o.builder.resolveAlignmentForwardReference(fwd_ref, .fromByteUnits(1)); } if (!o.builder.strip) { assert(val != .anyerror_type); - const fwd_ref = o.debug_types.items[@intFromEnum(index)]; + const fwd_ref = o.debug_types.items[@backingInt(index)]; const name_str = try o.builder.metadataStringFmt("{f}", .{ty.fmt(pt)}); // If `ty` is a function, use a dummy *function* type to prevent existing debug // subprograms from becoming ill-formed. @@ -1793,12 +1793,12 @@ pub const Object = struct { const ty: Type = .fromInterned(val); { - const fwd_ref = o.lazy_abi_aligns.items[@intFromEnum(index)]; + const fwd_ref = o.lazy_abi_aligns.items[@backingInt(index)]; o.builder.resolveAlignmentForwardReference(fwd_ref, ty.abiAlignment(zcu).toLlvm()); } if (!o.builder.strip) { - const fwd_ref = o.debug_types.items[@intFromEnum(index)]; + const fwd_ref = o.debug_types.items[@backingInt(index)]; if (val == .anyerror_type) { // Don't lower this now; it will be populated in `emit` instead. assert(o.debug_anyerror_fwd_ref == fwd_ref.toOptional()); @@ -1845,7 +1845,7 @@ pub const Object = struct { pub fn getDebugType(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error!Builder.Metadata { assert(!o.builder.strip); const index = try o.type_pool.get(pt, .{ .llvm = o }, ty.toIntern()); - return o.debug_types.items[@intFromEnum(index)]; + return o.debug_types.items[@backingInt(index)]; } /// In codegen logic, instead of calling this directly, use `getDebugType` to get a forward @@ -3958,7 +3958,7 @@ pub const Object = struct { errdefer assert(o.uav_map.remove(.{ .val = uav_val, .@"addrspace" = @"addrspace" })); const llvm_ty = try o.lowerType(uav_ty, .in_memory); - const llvm_name = try o.builder.strtabStringFmt("__anon_{d}", .{@intFromEnum(uav_val)}); + const llvm_name = try o.builder.strtabStringFmt("__anon_{d}", .{@backingInt(uav_val)}); const llvm_variable = try o.builder.addVariable(llvm_name, llvm_ty, llvm_addrspace); gop.value_ptr.* = llvm_variable; try llvm_variable.setInitializer(try o.lowerValue(uav_val, .in_memory), &o.builder); @@ -4195,7 +4195,7 @@ pub const Object = struct { pub fn lazyAbiAlignment(o: *Object, pt: Zcu.PerThread, ty: Type) Allocator.Error!Builder.Alignment.Lazy { const index = try o.type_pool.get(pt, .{ .llvm = o }, ty.toIntern()); - return o.lazy_abi_aligns.items[@intFromEnum(index)]; + return o.lazy_abi_aligns.items[@backingInt(index)]; } pub fn getIsNamedEnumValueFunction(o: *Object, enum_ty: Type) Allocator.Error!Builder.Function.Index { diff --git a/src/codegen/llvm/FuncGen.zig b/src/codegen/llvm/FuncGen.zig index 6e737fa482f6eb121062e9516b7028f65aefd576..d8b8eede7c09febaf5485ef0c013fff94934d8ef 100644 --- a/src/codegen/llvm/FuncGen.zig +++ b/src/codegen/llvm/FuncGen.zig @@ -351,7 +351,7 @@ fn genBody(self: *FuncGen, body: []const Air.Inst.Index, coverage_point: Air.Cov for (body) |inst| { if (self.liveness.isUnused(inst) and !self.air.mustLower(inst, ip)) continue; - const val: Builder.Value = switch (air_tags[@intFromEnum(inst)]) { + const val: Builder.Value = switch (air_tags[@backingInt(inst)]) { // zig fmt: off // Required due to `.scalarize_bit_cast_vector_non_elementwise` being enabled. @@ -1061,7 +1061,7 @@ fn airRet(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error!vo const o = self.object; const zcu = o.zcu; const ip = &zcu.intern_pool; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const ret_ty = self.typeOf(un_op); @@ -1136,7 +1136,7 @@ fn airRetLoad(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!void { const o = self.object; const zcu = o.zcu; const ip = &zcu.intern_pool; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const ptr_ty = self.typeOf(un_op); const ret_ty = ptr_ty.childType(zcu); const fn_info = zcu.typeToFunc(.fromInterned(ip.getNav(self.nav_index).resolved.?.type)).?; @@ -1162,7 +1162,7 @@ fn airRetLoad(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!void { } fn airCVaArg(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const list = try self.resolveInst(ty_op.operand); const arg_ty = ty_op.ty.toType(); const llvm_arg_ty = try self.object.lowerType(arg_ty, .by_value); @@ -1173,7 +1173,7 @@ fn airCVaArg(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airCVaCopy(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const src_list = try self.resolveInst(ty_op.operand); const va_list_ty = ty_op.ty.toType(); @@ -1187,7 +1187,7 @@ fn airCVaCopy(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Valu } fn airCVaEnd(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const src_list = try self.resolveInst(un_op); _ = try self.wip.callIntrinsic(.normal, .none, .va_end, &.{src_list.typeOfWip(&self.wip)}, &.{src_list}, ""); @@ -1214,7 +1214,7 @@ fn airCmp( op: math.CompareOperator, fast: Builder.FastMathKind, ) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const operand_ty = self.typeOf(bin_op.lhs); @@ -1223,7 +1223,7 @@ fn airCmp( } fn airCmpVector(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.VectorCmp, ty_pl.payload).data; const lhs = try self.resolveInst(extra.lhs); @@ -1236,7 +1236,7 @@ fn airCmpVector(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind fn airCmpLteErrorsLen(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const errors_len_ptr = try o.getErrorsLen(); const errors_len_val = try self.load(errors_len_ptr.toValue(&o.builder), .none, .anyerror, .normal); @@ -1392,7 +1392,7 @@ fn lowerBlock( fn airBr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!void { const zcu = self.object.zcu; - const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br; + const branch = self.air.instructions.items(.data)[@backingInt(inst)].br; const block = self.blocks.get(branch.block_inst).?; // Add the values to the lists only if the break provides a value. @@ -1408,7 +1408,7 @@ fn airBr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!void { } fn airRepeat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!void { - const repeat = self.air.instructions.items(.data)[@intFromEnum(inst)].repeat; + const repeat = self.air.instructions.items(.data)[@backingInt(inst)].repeat; const loop_bb = self.loops.get(repeat.loop_inst).?; loop_bb.ptr(&self.wip).incoming += 1; _ = try self.wip.br(loop_bb); @@ -1603,7 +1603,7 @@ fn lowerSwitchDispatch( } fn airSwitchDispatch(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!void { - const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = self.air.instructions.items(.data)[@backingInt(inst)].br; const dispatch_info = self.switch_dispatch_info.get(br.block_inst).?; return self.lowerSwitchDispatch(br.block_inst, br.operand, dispatch_info); } @@ -1850,7 +1850,7 @@ fn airSwitchBr(self: *FuncGen, inst: Air.Inst.Index, is_dispatch_loop: bool) Tod const table_val = try o.builder.arrayConst(table_llvm_ty, table_elems); const table_variable = try o.builder.addVariable( - try o.builder.strtabStringFmt("__jmptab_{d}", .{@intFromEnum(inst)}), + try o.builder.strtabStringFmt("__jmptab_{d}", .{@backingInt(inst)}), table_llvm_ty, .default, ); @@ -2018,7 +2018,7 @@ fn airLoop(self: *FuncGen, inst: Air.Inst.Index) TodoError!void { fn airArrayToSlice(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = self.typeOf(ty_op.operand); const array_ty = operand_ty.childType(zcu); const llvm_usize = try o.lowerType(.usize, .by_value); @@ -2031,7 +2031,7 @@ fn airArrayToSlice(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder fn airFloatFromInt(self: *FuncGen, inst: Air.Inst.Index) TodoError!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const operand_ty = self.typeOf(ty_op.operand); @@ -2100,7 +2100,7 @@ fn airIntFromFloat( const o = self.object; const zcu = o.zcu; const target = zcu.getTarget(); - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const operand_ty = self.typeOf(ty_op.operand); @@ -2188,21 +2188,21 @@ fn sliceOrArrayLenInBytes(fg: *FuncGen, ptr: Builder.Value, ty: Type) Allocator. } fn airSliceField(self: *FuncGen, inst: Air.Inst.Index, index: u32) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); return self.wip.extractValue(operand, &.{index}, ""); } fn airPtrSliceFieldPtr(self: *FuncGen, inst: Air.Inst.Index, index: u1) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const slice_ptr = try self.resolveInst(ty_op.operand); return self.ptraddConst(slice_ptr, index * Type.usize.abiSize(zcu)); } fn airSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const slice_ty = self.typeOf(bin_op.lhs); const slice = try self.resolveInst(bin_op.lhs); const index = try self.resolveInst(bin_op.rhs); @@ -2219,7 +2219,7 @@ fn airSliceElemVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder fn airSliceElemPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const slice_ty = self.typeOf(bin_op.lhs); @@ -2232,7 +2232,7 @@ fn airSliceElemPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder fn airArrayElemVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const array_ty = self.typeOf(bin_op.lhs); const array_llvm_val = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -2247,7 +2247,7 @@ fn airArrayElemVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder } fn airLegalizeVecElemVal(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const bin_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = fg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const vec = try fg.resolveInst(bin_op.lhs); const index = try fg.resolveInst(bin_op.rhs); return fg.wip.extractElement(vec, index, ""); @@ -2255,7 +2255,7 @@ fn airLegalizeVecElemVal(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Bui fn airLegalizeVecStoreElem(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = fg.object.zcu; - const pl_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = fg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = fg.air.extraData(Air.Bin, pl_op.payload).data; const ptr_ty = fg.typeOf(pl_op.operand); @@ -2276,7 +2276,7 @@ fn airLegalizeVecStoreElem(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!B fn airPtrElemVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = self.typeOf(bin_op.lhs); const elem_ty = ptr_ty.indexableElem(zcu); const base_ptr = try self.resolveInst(bin_op.lhs); @@ -2294,7 +2294,7 @@ fn airPtrElemVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.V fn airPtrElemPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_ty = self.typeOf(bin_op.lhs); const elem_ty = ptr_ty.indexableElem(zcu); @@ -2307,7 +2307,7 @@ fn airPtrElemPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.V } fn airStructFieldPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data; const struct_ptr = try self.resolveInst(struct_field.struct_operand); const struct_ptr_ty = self.typeOf(struct_field.struct_operand); @@ -2319,7 +2319,7 @@ fn airStructFieldPtrIndex( inst: Air.Inst.Index, field_index: u32, ) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const struct_ptr = try self.resolveInst(ty_op.operand); const struct_ptr_ty = self.typeOf(ty_op.operand); return self.fieldPtr(struct_ptr, struct_ptr_ty, field_index); @@ -2328,7 +2328,7 @@ fn airStructFieldPtrIndex( fn airAggFieldVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const struct_field = self.air.extraData(Air.StructField, ty_pl.payload).data; const struct_ty = self.typeOf(struct_field.struct_operand); const struct_llvm_val = try self.resolveInst(struct_field.struct_operand); @@ -2386,7 +2386,7 @@ fn airAggFieldVal(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder. fn airFieldParentPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; const field_ptr = try self.resolveInst(extra.field_ptr); @@ -2409,7 +2409,7 @@ fn airFieldParentPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Build } fn airNot(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); return self.wip.not(operand, ""); @@ -2421,7 +2421,7 @@ fn airUnreach(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!void { } fn airDbgStmt(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = self.air.instructions.items(.data)[@backingInt(inst)].dbg_stmt; self.prev_dbg_line = @intCast(self.base_line + dbg_stmt.line + 1); self.prev_dbg_column = @intCast(dbg_stmt.column + 1); @@ -2445,9 +2445,9 @@ fn airDbgVarPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Va const o = self.object; const pt = self.pt; const zcu = o.zcu; - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const operand = try self.resolveInst(pl_op.operand); - const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); const ptr_ty = self.typeOf(pl_op.operand); const debug_local_var = try o.builder.debugLocalVar( @@ -2477,10 +2477,10 @@ fn airDbgVarPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Va fn airDbgVarVal(self: *FuncGen, inst: Air.Inst.Index, is_arg: bool) Allocator.Error!Builder.Value { const o = self.object; const pt = self.pt; - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const operand = try self.resolveInst(pl_op.operand); const operand_ty = self.typeOf(pl_op.operand); - const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); const name_slice = name.toSlice(self.air); const metadata_name = if (name_slice.len > 0) try o.builder.metadataString(name_slice) else null; const debug_local_var = if (is_arg) try o.builder.debugParameter( @@ -2933,7 +2933,7 @@ fn airIsNonNull( ) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const operand_ty = self.typeOf(un_op); const optional_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty; @@ -2981,7 +2981,7 @@ fn airIsErr( ) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const operand_ty = self.typeOf(un_op); const err_union_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty; @@ -3021,7 +3021,7 @@ fn airIsErr( } fn airOptionalPayloadPtr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); // If `Type.optionalReprIsPayload`, then the address should be the same. Otherwise, optional // layouts always put the payload at offset 0, so... the address should still be the same. @@ -3033,7 +3033,7 @@ fn airOptionalPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) Allocator.Erro const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const optional_ptr_ty = self.typeOf(ty_op.operand); const optional_ty = optional_ptr_ty.childType(zcu); @@ -3073,7 +3073,7 @@ fn airOptionalPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) Allocator.Erro fn airOptionalPayload(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const optional_ty = self.typeOf(ty_op.operand); const payload_ty = self.typeOfIndex(inst); @@ -3090,7 +3090,7 @@ fn airOptionalPayload(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Buil fn airErrUnionPayload(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = fg.object; const zcu = o.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try fg.resolveInst(ty_op.operand); const err_union_ty = fg.typeOf(ty_op.operand); const payload_ty = fg.typeOfIndex(inst); @@ -3106,7 +3106,7 @@ fn airErrUnionPayload(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builde fn airErrUnionPayloadPtr(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = fg.object; const zcu = o.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try fg.resolveInst(ty_op.operand); const payload_ty = fg.typeOfIndex(inst).childType(zcu); return fg.ptraddConst(operand, codegen.errUnionPayloadOffset(payload_ty, zcu)); @@ -3119,7 +3119,7 @@ fn airErrUnionErr( ) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const operand_ty = self.typeOf(ty_op.operand); const err_union_ty = if (operand_is_ptr) operand_ty.childType(zcu) else operand_ty; @@ -3149,7 +3149,7 @@ fn airErrUnionErr( fn airErrUnionPayloadPtrSet(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const err_union_ptr_ty = self.typeOf(ty_op.operand); const err_union_ty = err_union_ptr_ty.childType(zcu); @@ -3181,7 +3181,7 @@ fn airErrReturnTrace(self: *FuncGen, _: Air.Inst.Index) Allocator.Error!Builder. } fn airSetErrReturnTrace(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; self.err_ret_trace = try self.resolveInst(un_op); return .none; } @@ -3189,7 +3189,7 @@ fn airSetErrReturnTrace(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Bu fn airSaveErrReturnTraceIndex(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const struct_ty = ty_pl.ty.toType(); const field_index = ty_pl.payload; @@ -3205,7 +3205,7 @@ fn airSaveErrReturnTraceIndex(self: *FuncGen, inst: Air.Inst.Index) Allocator.Er fn airWrapOptional(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const payload_ty = self.typeOf(ty_op.operand); comptime assert(optional_layout_version == 3); assert(payload_ty.hasRuntimeBits(zcu)); @@ -3228,7 +3228,7 @@ fn airWrapOptional(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder fn airWrapErrUnionPayload(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const err_un_ty = self.typeOfIndex(inst); const operand = try self.resolveInst(ty_op.operand); const payload_ty = self.typeOf(ty_op.operand); @@ -3250,7 +3250,7 @@ fn airWrapErrUnionPayload(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error! fn airWrapErrUnionErr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const err_un_ty = self.typeOfIndex(inst); const payload_ty = err_un_ty.errorUnionPayload(zcu); const operand = try self.resolveInst(ty_op.operand); @@ -3271,7 +3271,7 @@ fn airWrapErrUnionErr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Buil fn airWasmMemorySize(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const index = pl_op.payload; const llvm_usize = try o.lowerType(.usize, .by_value); return self.wip.callIntrinsic(.normal, .none, .@"wasm.memory.size", &.{llvm_usize}, &.{ @@ -3281,7 +3281,7 @@ fn airWasmMemorySize(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Build fn airWasmMemoryGrow(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const index = pl_op.payload; const llvm_isize = try o.lowerType(.isize, .by_value); return self.wip.callIntrinsic(.normal, .none, .@"wasm.memory.grow", &.{llvm_isize}, &.{ @@ -3291,7 +3291,7 @@ fn airWasmMemoryGrow(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Build fn airRuntimeNavPtr(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = fg.object; - const ty_nav = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav; + const ty_nav = fg.air.instructions.items(.data)[@backingInt(inst)].ty_nav; const llvm_ptr = try o.lowerNavRef(ty_nav.nav); return llvm_ptr.toValue(); } @@ -3299,7 +3299,7 @@ fn airRuntimeNavPtr(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder. fn airMin(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3319,7 +3319,7 @@ fn airMin(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { fn airMax(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3337,7 +3337,7 @@ fn airMax(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { } fn airSlice(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const ptr = try self.resolveInst(bin_op.lhs); const len = try self.resolveInst(bin_op.rhs); @@ -3347,7 +3347,7 @@ fn airSlice(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airAdd(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3366,7 +3366,7 @@ fn airSafeArithmetic( const o = fg.object; const zcu = o.zcu; - const bin_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = fg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try fg.resolveInst(bin_op.lhs); const rhs = try fg.resolveInst(bin_op.rhs); const inst_ty = fg.typeOfIndex(inst); @@ -3403,7 +3403,7 @@ fn airSafeArithmetic( } fn airAddWrap(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -3413,7 +3413,7 @@ fn airAddWrap(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Valu fn airAddSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3431,7 +3431,7 @@ fn airAddSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airSub(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3442,7 +3442,7 @@ fn airSub(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allo } fn airSubWrap(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -3452,7 +3452,7 @@ fn airSubWrap(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Valu fn airSubSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3470,7 +3470,7 @@ fn airSubSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airMul(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3481,7 +3481,7 @@ fn airMul(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allo } fn airMulWrap(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -3491,7 +3491,7 @@ fn airMulWrap(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Valu fn airMulSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3508,7 +3508,7 @@ fn airMulSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value } fn airDivFloat(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3518,7 +3518,7 @@ fn airDivFloat(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) fn airDivTrunc(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3534,7 +3534,7 @@ fn airDivTrunc(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) fn airDivFloor(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3583,7 +3583,7 @@ fn airDivFloor(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) fn airDivCeil(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3654,7 +3654,7 @@ fn airDivCeil(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) fn airDivExact(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3671,7 +3671,7 @@ fn airDivExact(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) fn airRem(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3688,7 +3688,7 @@ fn airRem(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allo fn airMod(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const inst_ty = self.typeOfIndex(inst); @@ -3738,7 +3738,7 @@ fn airMod(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allo fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_or_slice = try self.resolveInst(bin_op.lhs); const index = try self.resolveInst(bin_op.rhs); @@ -3754,7 +3754,7 @@ fn airPtrAdd(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airPtrSub(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_or_slice = try self.resolveInst(bin_op.lhs); const llvm_usize_ty = try o.lowerType(.usize, .by_value); @@ -3778,7 +3778,7 @@ fn airOverflow( ) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try self.resolveInst(extra.lhs); @@ -4097,7 +4097,7 @@ fn buildFloatOp( } fn airMulAdd(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.Bin, pl_op.payload).data; const mulend1 = try self.resolveInst(extra.lhs); @@ -4111,7 +4111,7 @@ fn airMulAdd(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airShlWithOverflow(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try self.resolveInst(extra.lhs); @@ -4160,21 +4160,21 @@ fn airShlWithOverflow(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Buil } fn airAnd(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); return self.wip.bin(.@"and", lhs, rhs, ""); } fn airOr(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); return self.wip.bin(.@"or", lhs, rhs, ""); } fn airXor(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); return self.wip.bin(.xor, lhs, rhs, ""); @@ -4183,7 +4183,7 @@ fn airXor(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { fn airShlExact(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -4206,7 +4206,7 @@ fn airShlExact(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Val fn airShl(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -4224,7 +4224,7 @@ fn airShl(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { fn airShlSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -4306,7 +4306,7 @@ fn airShlSat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airShr(self: *FuncGen, inst: Air.Inst.Index, is_exact: bool) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -4330,7 +4330,7 @@ fn airShr(self: *FuncGen, inst: Air.Inst.Index, is_exact: bool) Allocator.Error! fn airAbs(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const operand_ty = self.typeOf(ty_op.operand); const scalar_ty = operand_ty.scalarType(zcu); @@ -4352,7 +4352,7 @@ fn airAbs(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { fn airIntCast(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error!Builder.Value { const o = fg.object; const zcu = o.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const dest_ty = fg.typeOfIndex(inst); const dest_llvm_ty = try o.lowerType(dest_ty, .by_value); const operand = try fg.resolveInst(ty_op.operand); @@ -4459,7 +4459,7 @@ fn airIntCast(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error! } fn airTrunc(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const dest_llvm_ty = try self.object.lowerType(self.typeOfIndex(inst), .by_value); return self.wip.cast(.trunc, operand, dest_llvm_ty, ""); @@ -4468,7 +4468,7 @@ fn airTrunc(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airFptrunc(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const operand_ty = self.typeOf(ty_op.operand); const dest_ty = self.typeOfIndex(inst); @@ -4502,7 +4502,7 @@ fn airFptrunc(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Valu fn airFpext(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const operand_ty = self.typeOf(ty_op.operand); const dest_ty = self.typeOfIndex(inst); @@ -4543,7 +4543,7 @@ fn airBitCast(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error! const o = fg.object; const zcu = o.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = fg.typeOf(ty_op.operand); const dest_ty = fg.typeOfIndex(inst); const operand = try fg.resolveInst(ty_op.operand); @@ -4588,7 +4588,7 @@ fn airBitCast(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error! fn airNopCast(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = fg.object.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = fg.typeOf(ty_op.operand); const dest_ty = fg.typeOfIndex(inst); assert(isByRef(operand_ty, zcu) == isByRef(dest_ty, zcu)); @@ -4599,7 +4599,7 @@ fn airNopCast(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airPtrFromInt(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = fg.object; const zcu = o.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = fg.typeOf(ty_op.operand); const dest_ty = fg.typeOfIndex(inst); assert(operand_ty.scalarType(zcu).toIntern() == .usize_type); @@ -4613,7 +4613,7 @@ fn airPtrFromInt(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Val fn airIntFromPtr(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = fg.object; const zcu = o.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = fg.typeOf(ty_op.operand); const dest_ty = fg.typeOfIndex(inst); assert(operand_ty.scalarType(zcu).isPtrAtRuntime(zcu)); @@ -4625,7 +4625,7 @@ fn airIntFromPtr(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Val } fn airUnionFromEnum(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const enum_ty = fg.typeOf(ty_op.operand); const union_ty = fg.typeOfIndex(inst); const enum_val = try fg.resolveInst(ty_op.operand); @@ -4652,7 +4652,7 @@ fn airArg(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const mod = file.mod.?; if (mod.strip) return arg_val; - const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg; + const arg = self.air.instructions.items(.data)[@backingInt(inst)].arg; const zir = &file.zir.?; const name = zir.nullTerminatedString(zir.getParamName(zir.getParamBody(func_zir.inst)[arg.zir_param_index]).?); @@ -4791,7 +4791,7 @@ fn buildAlloca( fn airStore(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error!Builder.Value { const o = fg.object; const zcu = o.zcu; - const bin_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = fg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr = try fg.resolveInst(bin_op.lhs); const ptr_ty = fg.typeOf(bin_op.lhs); const ptr_info = ptr_ty.ptrInfo(zcu); @@ -4914,7 +4914,7 @@ fn airStore(fg: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error!Bu fn airLoad(fg: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = fg.object; const zcu = o.zcu; - const ty_op = fg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = fg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const ptr_ty = fg.typeOf(ty_op.operand); const ptr_info = ptr_ty.ptrInfo(zcu); const ptr = try fg.resolveInst(ty_op.operand); @@ -5024,7 +5024,7 @@ fn airCmpxchg( ) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data; const ptr = try self.resolveInst(extra.ptr); const ptr_ty = self.typeOf(extra.ptr); @@ -5090,7 +5090,7 @@ fn airCmpxchg( fn airAtomicRmw(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data; const ptr = try self.resolveInst(pl_op.operand); const ptr_ty = self.typeOf(pl_op.operand); @@ -5155,7 +5155,7 @@ fn airAtomicRmw(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Va fn airAtomicLoad(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const atomic_load = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; + const atomic_load = self.air.instructions.items(.data)[@backingInt(inst)].atomic_load; const ptr = try self.resolveInst(atomic_load.ptr); const ptr_ty = self.typeOf(atomic_load.ptr); const info = ptr_ty.ptrInfo(zcu); @@ -5203,7 +5203,7 @@ fn airAtomicStore( ordering: Builder.AtomicOrdering, ) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = self.typeOf(bin_op.lhs); const operand_ty = ptr_ty.childType(zcu); if (!operand_ty.hasRuntimeBits(zcu)) return .none; @@ -5240,7 +5240,7 @@ fn airAtomicStore( fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dest_slice = try self.resolveInst(bin_op.lhs); const ptr_ty = self.typeOf(bin_op.lhs); const elem_ty = self.typeOf(bin_op.rhs); @@ -5389,7 +5389,7 @@ fn airMemset(self: *FuncGen, inst: Air.Inst.Index, safety: bool) Allocator.Error fn airMemcpy(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dest_slice = try self.resolveInst(bin_op.lhs); const dest_ptr_ty = self.typeOf(bin_op.lhs); const src_slice = try self.resolveInst(bin_op.rhs); @@ -5417,7 +5417,7 @@ fn airMemcpy(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value fn airMemmove(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dest_slice = try self.resolveInst(bin_op.lhs); const dest_ptr_ty = self.typeOf(bin_op.lhs); const src_slice = try self.resolveInst(bin_op.rhs); @@ -5441,7 +5441,7 @@ fn airMemmove(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Valu fn airSetUnionTag(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const zcu = self.object.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const un_ptr_ty = self.typeOf(bin_op.lhs); const un_ty = un_ptr_ty.childType(zcu); const layout = un_ty.unionGetLayout(zcu); @@ -5466,7 +5466,7 @@ fn airSetUnionTag(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder. fn airGetUnionTag(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const un_ty = self.typeOf(ty_op.operand); const layout = un_ty.unionGetLayout(zcu); assert(layout.tag_size != 0); @@ -5477,7 +5477,7 @@ fn airGetUnionTag(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder. } fn airUnaryOp(self: *FuncGen, inst: Air.Inst.Index, comptime op: FloatOp) Allocator.Error!Builder.Value { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const operand_ty = self.typeOf(un_op); @@ -5485,7 +5485,7 @@ fn airUnaryOp(self: *FuncGen, inst: Air.Inst.Index, comptime op: FloatOp) Alloca } fn airNeg(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allocator.Error!Builder.Value { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const operand_ty = self.typeOf(un_op); @@ -5494,7 +5494,7 @@ fn airNeg(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) Allo fn airClzCtz(self: *FuncGen, inst: Air.Inst.Index, intrinsic: Builder.Intrinsic) Allocator.Error!Builder.Value { const o = self.object; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = self.typeOfIndex(inst); const operand_ty = self.typeOf(ty_op.operand); const operand = try self.resolveInst(ty_op.operand); @@ -5512,7 +5512,7 @@ fn airClzCtz(self: *FuncGen, inst: Air.Inst.Index, intrinsic: Builder.Intrinsic) fn airBitOp(self: *FuncGen, inst: Air.Inst.Index, intrinsic: Builder.Intrinsic) Allocator.Error!Builder.Value { const o = self.object; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = self.typeOfIndex(inst); const operand_ty = self.typeOf(ty_op.operand); const operand = try self.resolveInst(ty_op.operand); @@ -5531,7 +5531,7 @@ fn airBitOp(self: *FuncGen, inst: Air.Inst.Index, intrinsic: Builder.Intrinsic) fn airByteSwap(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = self.typeOf(ty_op.operand); var bits = operand_ty.intInfo(zcu).bits; assert(bits % 8 == 0); @@ -5566,7 +5566,7 @@ fn airErrorSetHasValue(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Bui const o = self.object; const zcu = o.zcu; const ip = &zcu.intern_pool; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const error_set_ty = ty_op.ty.toType(); @@ -5596,7 +5596,7 @@ fn airErrorSetHasValue(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Bui fn airIsNamedEnumValue(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const enum_ty = self.typeOf(un_op); @@ -5614,7 +5614,7 @@ fn airIsNamedEnumValue(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Bui fn airTagName(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const enum_ty = self.typeOf(un_op); @@ -5633,7 +5633,7 @@ fn airTagName(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Valu fn airErrorName(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; const zcu = o.zcu; - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const slice_ty = self.typeOfIndex(inst); @@ -5646,14 +5646,14 @@ fn airErrorName(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Va } fn airSplat(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const scalar = try self.resolveInst(ty_op.operand); const vector_ty = self.typeOfIndex(inst); return self.wip.splatVector(try self.object.lowerType(vector_ty, .by_value), scalar, ""); } fn airSelect(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.Bin, pl_op.payload).data; const pred = try self.resolveInst(pl_op.operand); const a = try self.resolveInst(extra.lhs); @@ -5921,7 +5921,7 @@ fn airReduce(self: *FuncGen, inst: Air.Inst.Index, fast: Builder.FastMathKind) A const zcu = o.zcu; const target = zcu.getTarget(); - const reduce = self.air.instructions.items(.data)[@intFromEnum(inst)].reduce; + const reduce = self.air.instructions.items(.data)[@backingInt(inst)].reduce; const operand = try self.resolveInst(reduce.operand); const operand_ty = self.typeOf(reduce.operand); const llvm_operand_ty = try o.lowerType(operand_ty, .by_value); @@ -6029,7 +6029,7 @@ fn airAggregateInit(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builde const o = self.object; const zcu = o.zcu; const ip = &zcu.intern_pool; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const result_ty = self.typeOfIndex(inst); const len: usize = @intCast(result_ty.arrayLen(zcu)); const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[ty_pl.payload..][0..len]); @@ -6126,7 +6126,7 @@ fn airUnionInit(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Va const o = self.object; const zcu = o.zcu; const ip = &zcu.intern_pool; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data; const union_ty = self.typeOfIndex(inst); const union_obj = zcu.typeToUnion(union_ty).?; @@ -6167,16 +6167,16 @@ fn airUnionInit(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Va fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const o = self.object; - const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch; + const prefetch = self.air.instructions.items(.data)[@backingInt(inst)].prefetch; - comptime assert(@intFromEnum(std.lang.PrefetchOptions.Rw.read) == 0); - comptime assert(@intFromEnum(std.lang.PrefetchOptions.Rw.write) == 1); + comptime assert(@backingInt(std.lang.PrefetchOptions.Rw.read) == 0); + comptime assert(@backingInt(std.lang.PrefetchOptions.Rw.write) == 1); comptime assert(prefetch.locality >= 0); comptime assert(prefetch.locality <= 3); - comptime assert(@intFromEnum(std.lang.PrefetchOptions.Cache.instruction) == 0); - comptime assert(@intFromEnum(std.lang.PrefetchOptions.Cache.data) == 1); + comptime assert(@backingInt(std.lang.PrefetchOptions.Cache.instruction) == 0); + comptime assert(@backingInt(std.lang.PrefetchOptions.Cache.data) == 1); // LLVM fails during codegen of instruction cache prefetchs for these architectures. // This is an LLVM bug as the prefetch intrinsic should be a noop if not supported @@ -6215,7 +6215,7 @@ fn airPrefetch(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Val } fn airAddrSpaceCast(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const inst_ty = self.typeOfIndex(inst); const operand = try self.resolveInst(ty_op.operand); return self.wip.cast(.addrspacecast, operand, try self.object.lowerType(inst_ty, .by_value), ""); @@ -6238,7 +6238,7 @@ fn workIntrinsic( fn airWorkItemId(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const target = self.object.zcu.getTarget(); - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const dimension = pl_op.payload; return switch (target.cpu.arch) { @@ -6251,7 +6251,7 @@ fn airWorkItemId(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.V fn airWorkGroupSize(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const target = self.object.zcu.getTarget(); - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const dimension = pl_op.payload; switch (target.cpu.arch) { @@ -6278,7 +6278,7 @@ fn airWorkGroupSize(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builde fn airWorkGroupId(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value { const target = self.object.zcu.getTarget(); - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const dimension = pl_op.payload; return switch (target.cpu.arch) { diff --git a/src/codegen/llvm/bindings.zig b/src/codegen/llvm/bindings.zig index 38f0c300bc625c399bc4d074a78ef4570158f254..e4f4d6eafefcca250babb49e4a907eba22866d22 100644 --- a/src/codegen/llvm/bindings.zig +++ b/src/codegen/llvm/bindings.zig @@ -5,7 +5,7 @@ pub const Bool = enum(c_int) { _, pub fn fromBool(b: bool) Bool { - return @as(Bool, @enumFromInt(@intFromBool(b))); + return @as(Bool, @fromBackingInt(@intCast(@intFromBool(b)))); } pub fn toBool(b: Bool) bool { diff --git a/src/codegen/riscv64/CodeGen.zig b/src/codegen/riscv64/CodeGen.zig index 4e5aac5f4d33cc85a30893b0973ab5cbb01488a3..2b953f3bbef4ac4924b37ac4cb3d8f524b7bc9d9 100644 --- a/src/codegen/riscv64/CodeGen.zig +++ b/src/codegen/riscv64/CodeGen.zig @@ -798,11 +798,11 @@ pub fn generate( try function.frame_allocs.resize(gpa, FrameIndex.named_count); function.frame_allocs.set( - @intFromEnum(FrameIndex.stack_frame), + @backingInt(FrameIndex.stack_frame), FrameAlloc.init(.{ .size = 0, .alignment = .@"1" }), ); function.frame_allocs.set( - @intFromEnum(FrameIndex.call_frame), + @backingInt(FrameIndex.call_frame), FrameAlloc.init(.{ .size = 0, .alignment = .@"1" }), ); @@ -813,22 +813,22 @@ pub fn generate( function.args = call_info.args; function.ret_mcv = call_info.return_value; - function.frame_allocs.set(@intFromEnum(FrameIndex.ret_addr), FrameAlloc.init(.{ + function.frame_allocs.set(@backingInt(FrameIndex.ret_addr), FrameAlloc.init(.{ .size = Type.u64.abiSize(zcu), .alignment = Type.u64.abiAlignment(zcu).min(call_info.stack_align), })); - function.frame_allocs.set(@intFromEnum(FrameIndex.base_ptr), FrameAlloc.init(.{ + function.frame_allocs.set(@backingInt(FrameIndex.base_ptr), FrameAlloc.init(.{ .size = Type.u64.abiSize(zcu), .alignment = Alignment.min( call_info.stack_align, Alignment.fromNonzeroByteUnits(function.target.stackAlignment()), ), })); - function.frame_allocs.set(@intFromEnum(FrameIndex.args_frame), FrameAlloc.init(.{ + function.frame_allocs.set(@backingInt(FrameIndex.args_frame), FrameAlloc.init(.{ .size = call_info.stack_byte_count, .alignment = call_info.stack_align, })); - function.frame_allocs.set(@intFromEnum(FrameIndex.spill_frame), FrameAlloc.init(.{ + function.frame_allocs.set(@backingInt(FrameIndex.spill_frame), FrameAlloc.init(.{ .size = 0, .alignment = Type.u64.abiAlignment(zcu), })); @@ -1080,7 +1080,7 @@ fn setVl(func: *Func, dst_reg: Register, avl: u64, options: bits.VType) !void { .data = .{ .i_type = .{ .rd = dst_reg, - .rs1 = @enumFromInt(avl), + .rs1 = @fromBackingInt(@intCast(avl)), .imm12 = Immediate.u(options_int), }, }, @@ -1297,7 +1297,7 @@ fn genLazy(func: *Func, lazy_sym: link.File.LazySymbol) InnerError!void { }) catch |err| return func.fail("{s} creating lazy symbol", .{@errorName(err)}); - try func.genSetReg(Type.u64, data_reg, .{ .lea_symbol = .{ .sym = @enumFromInt(sym_index) } }); + try func.genSetReg(Type.u64, data_reg, .{ .lea_symbol = .{ .sym = @fromBackingInt(@intCast(sym_index)) } }); const cmp_reg, const cmp_lock = try func.allocReg(.int); defer func.register_manager.unlockReg(cmp_lock); @@ -1381,7 +1381,7 @@ fn genBody(func: *Func, body: []const Air.Inst.Index) InnerError!void { func.reused_operands = @TypeOf(func.reused_operands).empty; try func.inst_tracking.ensureUnusedCapacity(func.gpa, 1); - const tag = air_tags[@intFromEnum(inst)]; + const tag = air_tags[@backingInt(inst)]; switch (tag) { // zig fmt: off @@ -1661,7 +1661,7 @@ fn genBody(func: *Func, body: []const Air.Inst.Index) InnerError!void { if (std.debug.runtime_safety) { if (func.air_bookkeeping < old_air_bookkeeping + 1) { - std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] }); + std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@backingInt(inst)] }); } { // check consistency of tracked registers @@ -1768,7 +1768,7 @@ fn setFrameLoc( offset: *i32, comptime aligned: bool, ) void { - const frame_i = @intFromEnum(frame_index); + const frame_i = @backingInt(frame_index); if (aligned) { const alignment: InternPool.Alignment = func.frame_allocs.items(.abi_align)[frame_i]; offset.* = math.sign(offset.*) * @as(i32, @intCast(alignment.backward(@intCast(@abs(offset.*))))); @@ -1787,13 +1787,13 @@ fn computeFrameLayout(func: *Func) !FrameLayout { const frame_align = func.frame_allocs.items(.abi_align); for (stack_frame_order, FrameIndex.named_count..) |*frame_order, frame_index| - frame_order.* = @enumFromInt(frame_index); + frame_order.* = @fromBackingInt(@intCast(frame_index)); { const SortContext = struct { frame_align: @TypeOf(frame_align), pub fn lessThan(context: @This(), lhs: FrameIndex, rhs: FrameIndex) bool { - return context.frame_align[@intFromEnum(lhs)].compare(.gt, context.frame_align[@intFromEnum(rhs)]); + return context.frame_align[@backingInt(lhs)].compare(.gt, context.frame_align[@backingInt(rhs)]); } }; const sort_context = SortContext{ .frame_align = frame_align }; @@ -1810,38 +1810,38 @@ fn computeFrameLayout(func: *Func) !FrameLayout { const total_alloc_size: i32 = blk: { var i: i32 = 0; for (stack_frame_order) |frame_index| { - i += frame_size[@intFromEnum(frame_index)]; + i += frame_size[@backingInt(frame_index)]; } break :blk i; }; const saved_reg_size = save_reg_list.size(); - frame_size[@intFromEnum(FrameIndex.spill_frame)] = @intCast(saved_reg_size); + frame_size[@backingInt(FrameIndex.spill_frame)] = @intCast(saved_reg_size); // The total frame size is calculated by the amount of s registers you need to save * 8, as each // register is 8 bytes, the total allocation sizes, and 16 more register for the spilled ra and s0 // register. Finally we align the frame size to the alignment of the base pointer. - const args_frame_size = frame_size[@intFromEnum(FrameIndex.args_frame)]; - const spill_frame_size = frame_size[@intFromEnum(FrameIndex.spill_frame)]; - const call_frame_size = frame_size[@intFromEnum(FrameIndex.call_frame)]; + const args_frame_size = frame_size[@backingInt(FrameIndex.args_frame)]; + const spill_frame_size = frame_size[@backingInt(FrameIndex.spill_frame)]; + const call_frame_size = frame_size[@backingInt(FrameIndex.call_frame)]; // TODO: this 64 should be a 16, but we were clobbering the top and bottom of the frame. // maybe everything can go from the bottom? const acc_frame_size: i32 = std.mem.alignForward( i32, total_alloc_size + 64 + args_frame_size + spill_frame_size + call_frame_size, - @intCast(frame_align[@intFromEnum(FrameIndex.base_ptr)].toByteUnits().?), + @intCast(frame_align[@backingInt(FrameIndex.base_ptr)].toByteUnits().?), ); log.debug("frame size: {d}", .{acc_frame_size}); // store the ra at total_size - 8, so it's the very first thing in the stack // relative to the fp func.frame_locs.set( - @intFromEnum(FrameIndex.ret_addr), + @backingInt(FrameIndex.ret_addr), .{ .base = .sp, .disp = acc_frame_size - 8 }, ); func.frame_locs.set( - @intFromEnum(FrameIndex.base_ptr), + @backingInt(FrameIndex.base_ptr), .{ .base = .sp, .disp = acc_frame_size - 16 }, ); @@ -1983,19 +1983,19 @@ fn allocFrameIndex(func: *Func, alloc: FrameAlloc) !FrameIndex { const frame_size = frame_allocs_slice.items(.abi_size); const frame_align = frame_allocs_slice.items(.abi_align); - const stack_frame_align = &frame_align[@intFromEnum(FrameIndex.stack_frame)]; + const stack_frame_align = &frame_align[@backingInt(FrameIndex.stack_frame)]; stack_frame_align.* = stack_frame_align.max(alloc.abi_align); for (func.free_frame_indices.keys(), 0..) |frame_index, free_i| { - const abi_size = frame_size[@intFromEnum(frame_index)]; + const abi_size = frame_size[@backingInt(frame_index)]; if (abi_size != alloc.abi_size) continue; - const abi_align = &frame_align[@intFromEnum(frame_index)]; + const abi_align = &frame_align[@backingInt(frame_index)]; abi_align.* = abi_align.max(alloc.abi_align); _ = func.free_frame_indices.swapRemoveAt(free_i); return frame_index; } - const frame_index: FrameIndex = @enumFromInt(func.frame_allocs.len); + const frame_index: FrameIndex = @fromBackingInt(@intCast(func.frame_allocs.len)); try func.frame_allocs.append(func.gpa, alloc); log.debug("allocated frame {}", .{frame_index}); return frame_index; @@ -2186,13 +2186,13 @@ fn airRetPtr(func: *Func, inst: Air.Inst.Index) !void { } fn airFptrunc(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airFptrunc for {}", .{func.target.cpu.arch}); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airFpext(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airFpext for {}", .{func.target.cpu.arch}); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } @@ -2200,7 +2200,7 @@ fn airFpext(func: *Func, inst: Air.Inst.Index) !void { fn airIntCast(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const src_ty = func.typeOf(ty_op.operand); const dst_ty = func.typeOfIndex(inst); @@ -2241,7 +2241,7 @@ fn airIntCast(func: *Func, inst: Air.Inst.Index) !void { } fn airTrunc(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; if (func.liveness.isUnused(inst)) return func.finishAir(inst, .unreach, .{ ty_op.operand, .none, .none }); // we assume no zeroext in the "Zig ABI", so it's fine to just not truncate it. @@ -2257,7 +2257,7 @@ fn airTrunc(func: *Func, inst: Air.Inst.Index) !void { } fn airNot(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const pt = func.pt; const zcu = pt.zcu; @@ -2319,7 +2319,7 @@ fn airNot(func: *Func, inst: Air.Inst.Index) !void { fn airSlice(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data; const slice_ty = func.typeOfIndex(inst); @@ -2343,7 +2343,7 @@ fn airSlice(func: *Func, inst: Air.Inst.Index) !void { fn airBinOp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { const pt = func.pt; const zcu = pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dst_mcv = try func.binOp(inst, tag, bin_op.lhs, bin_op.rhs); const dst_ty = func.typeOfIndex(inst); @@ -2873,7 +2873,7 @@ fn genBinOp( } fn airPtrArithmetic(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = func.air.extraData(Air.Bin, ty_pl.payload).data; const dst_mcv = try func.binOp(inst, tag, bin_op.lhs, bin_op.rhs); return func.finishAir(inst, dst_mcv, .{ bin_op.lhs, bin_op.rhs, .none }); @@ -2882,7 +2882,7 @@ fn airPtrArithmetic(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void fn airAddWithOverflow(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.Bin, ty_pl.payload).data; const rhs_ty = func.typeOf(extra.rhs); @@ -3010,7 +3010,7 @@ fn airAddWithOverflow(func: *Func, inst: Air.Inst.Index) !void { fn airSubWithOverflow(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.Bin, ty_pl.payload).data; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { @@ -3135,7 +3135,7 @@ fn airSubWithOverflow(func: *Func, inst: Air.Inst.Index) !void { fn airMulWithOverflow(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.Bin, ty_pl.payload).data; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { @@ -3210,7 +3210,7 @@ fn airMulWithOverflow(func: *Func, inst: Air.Inst.Index) !void { fn airShlWithOverflow(func: *Func, inst: Air.Inst.Index) !void { const zcu = func.pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else if (func.typeOf(bin_op.lhs).isVector(zcu) and !func.typeOf(bin_op.rhs).isVector(zcu)) @@ -3221,20 +3221,20 @@ fn airShlWithOverflow(func: *Func, inst: Air.Inst.Index) !void { } fn airSubSat(func: *Func, inst: Air.Inst.Index) !void { - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airSubSat", .{}); return func.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } fn airMulSat(func: *Func, inst: Air.Inst.Index) !void { - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airMulSat", .{}); return func.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } fn airShlSat(func: *Func, inst: Air.Inst.Index) !void { const zcu = func.pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else if (func.typeOf(bin_op.lhs).isVector(zcu) and !func.typeOf(bin_op.rhs).isVector(zcu)) @@ -3246,7 +3246,7 @@ fn airShlSat(func: *Func, inst: Air.Inst.Index) !void { fn airOptionalPayload(func: *Func, inst: Air.Inst.Index) !void { const zcu = func.pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = result: { const pl_ty = func.typeOfIndex(inst); if (!pl_ty.hasRuntimeBits(zcu)) break :result .none; @@ -3268,7 +3268,7 @@ fn airOptionalPayload(func: *Func, inst: Air.Inst.Index) !void { } fn airOptionalPayloadPtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement .optional_payload_ptr for {}", .{func.target.cpu.arch}); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } @@ -3276,7 +3276,7 @@ fn airOptionalPayloadPtr(func: *Func, inst: Air.Inst.Index) !void { fn airOptionalPayloadPtrSet(func: *Func, inst: Air.Inst.Index) !void { const zcu = func.pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const dst_ty = func.typeOfIndex(inst); const src_ty = func.typeOf(ty_op.operand); @@ -3310,7 +3310,7 @@ fn airOptionalPayloadPtrSet(func: *Func, inst: Air.Inst.Index) !void { } fn airUnwrapErrErr(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const pt = func.pt; const zcu = pt.zcu; const err_union_ty = func.typeOf(ty_op.operand); @@ -3359,7 +3359,7 @@ fn airUnwrapErrErr(func: *Func, inst: Air.Inst.Index) !void { } fn airUnwrapErrPayload(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = func.typeOf(ty_op.operand); const operand = try func.resolveInst(ty_op.operand); const result = try func.genUnwrapErrUnionPayloadMir(operand_ty, operand); @@ -3410,21 +3410,21 @@ fn genUnwrapErrUnionPayloadMir( // *(E!T) -> E fn airUnwrapErrErrPtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement unwrap error union error ptr for {}", .{func.target.cpu.arch}); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } // *(E!T) -> *T fn airUnwrapErrPayloadPtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement unwrap error union payload ptr for {}", .{func.target.cpu.arch}); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } // *(E!T) => *T fn airErrUnionPayloadPtrSet(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const zcu = func.pt.zcu; const src_ty = func.typeOf(ty_op.operand); @@ -3488,7 +3488,7 @@ fn airSaveErrReturnTraceIndex(func: *Func, inst: Air.Inst.Index) !void { fn airWrapOptional(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = result: { const pl_ty = func.typeOf(ty_op.operand); if (!pl_ty.hasRuntimeBits(zcu)) break :result .{ .immediate = 1 }; @@ -3531,7 +3531,7 @@ fn airWrapOptional(func: *Func, inst: Air.Inst.Index) !void { fn airWrapErrUnionPayload(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const eu_ty = ty_op.ty.toType(); const pl_ty = eu_ty.errorUnionPayload(zcu); @@ -3556,7 +3556,7 @@ fn airWrapErrUnionPayload(func: *Func, inst: Air.Inst.Index) !void { fn airWrapErrUnionErr(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const eu_ty = ty_op.ty.toType(); const pl_ty = eu_ty.errorUnionPayload(zcu); @@ -3579,7 +3579,7 @@ fn airWrapErrUnionErr(func: *Func, inst: Air.Inst.Index) !void { fn airRuntimeNavPtr(func: *Func, inst: Air.Inst.Index) !void { const zcu = func.pt.zcu; const ip = &zcu.intern_pool; - const ty_nav = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav; + const ty_nav = func.air.instructions.items(.data)[@backingInt(inst)].ty_nav; const ptr_ty: Type = .fromInterned(ty_nav.ty); const nav = ip.getNav(ty_nav.nav); @@ -3597,8 +3597,8 @@ fn airRuntimeNavPtr(func: *Func, inst: Air.Inst.Index) !void { .tag = .pseudo_load_tlv, .data = .{ .reloc = .{ .register = dest_mcv.getReg().?, - .atom_index = @enumFromInt(try func.owner.getSymbolIndex(func)), - .sym_index = @enumFromInt(tlv_sym_index), + .atom_index = @fromBackingInt(@intCast(try func.owner.getSymbolIndex(func))), + .sym_index = @fromBackingInt(@intCast(tlv_sym_index)), } }, }); } else { @@ -3608,8 +3608,8 @@ fn airRuntimeNavPtr(func: *Func, inst: Air.Inst.Index) !void { .tag = .pseudo_load_tlv, .data = .{ .reloc = .{ .register = tmp_reg, - .atom_index = @enumFromInt(try func.owner.getSymbolIndex(func)), - .sym_index = @enumFromInt(tlv_sym_index), + .atom_index = @fromBackingInt(@intCast(try func.owner.getSymbolIndex(func))), + .sym_index = @fromBackingInt(@intCast(tlv_sym_index)), } }, }); try func.genCopy(ptr_ty, dest_mcv, .{ .register = tmp_reg }); @@ -3674,7 +3674,7 @@ fn genTry( } fn airSlicePtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result = result: { const src_mcv = try func.resolveInst(ty_op.operand); if (func.reuseOperand(inst, ty_op.operand, 0, src_mcv)) break :result src_mcv; @@ -3688,7 +3688,7 @@ fn airSlicePtr(func: *Func, inst: Air.Inst.Index) !void { } fn airSliceLen(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const src_mcv = try func.resolveInst(ty_op.operand); const ty = func.typeOfIndex(inst); @@ -3721,7 +3721,7 @@ fn airSliceLen(func: *Func, inst: Air.Inst.Index) !void { } fn airPtrSliceLenPtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const src_mcv = try func.resolveInst(ty_op.operand); @@ -3736,7 +3736,7 @@ fn airPtrSliceLenPtr(func: *Func, inst: Air.Inst.Index) !void { } fn airPtrSlicePtrPtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const opt_mcv = try func.resolveInst(ty_op.operand); const dst_mcv = if (func.reuseOperand(inst, ty_op.operand, 0, opt_mcv)) @@ -3749,7 +3749,7 @@ fn airPtrSlicePtrPtr(func: *Func, inst: Air.Inst.Index) !void { fn airSliceElemVal(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = result: { const elem_ty = func.typeOfIndex(inst); @@ -3766,7 +3766,7 @@ fn airSliceElemVal(func: *Func, inst: Air.Inst.Index) !void { } fn airSliceElemPtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.Bin, ty_pl.payload).data; const dst_mcv = try func.genSliceElemPtr(extra.lhs, extra.rhs); return func.finishAir(inst, dst_mcv, .{ extra.lhs, extra.rhs, .none }); @@ -3817,7 +3817,7 @@ fn genSliceElemPtr(func: *Func, lhs: Air.Inst.Ref, rhs: Air.Inst.Ref) !MCValue { fn airArrayElemVal(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const result_ty = func.typeOfIndex(inst); @@ -3901,7 +3901,7 @@ fn airPtrElemVal(func: *Func, inst: Air.Inst.Index) !void { const is_volatile = false; // TODO const pt = func.pt; const zcu = pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const base_ptr_ty = func.typeOf(bin_op.lhs); const result: MCValue = if (!is_volatile and func.liveness.isUnused(inst)) .unreach else result: { @@ -3956,7 +3956,7 @@ fn airPtrElemVal(func: *Func, inst: Air.Inst.Index) !void { fn airPtrElemPtr(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.Bin, ty_pl.payload).data; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { @@ -3998,7 +3998,7 @@ fn airPtrElemPtr(func: *Func, inst: Air.Inst.Index) !void { } fn airSetUnionTag(func: *Func, inst: Air.Inst.Index) !void { - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; _ = bin_op; return func.fail("TODO implement airSetUnionTag for {}", .{func.target.cpu.arch}); // return func.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); @@ -4007,7 +4007,7 @@ fn airSetUnionTag(func: *Func, inst: Air.Inst.Index) !void { fn airGetUnionTag(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const tag_ty = func.typeOfIndex(inst); const union_ty = func.typeOf(ty_op.operand); @@ -4053,7 +4053,7 @@ fn airGetUnionTag(func: *Func, inst: Air.Inst.Index) !void { } fn airClz(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try func.resolveInst(ty_op.operand); const ty = func.typeOf(ty_op.operand); @@ -4109,13 +4109,13 @@ fn airClz(func: *Func, inst: Air.Inst.Index) !void { } fn airCtz(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; _ = ty_op; return func.fail("TODO: finish ctz", .{}); } fn airPopcount(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const pt = func.pt; const zcu = pt.zcu; @@ -4141,7 +4141,7 @@ fn airPopcount(func: *Func, inst: Air.Inst.Index) !void { .r_type = .{ .rd = dst_reg, .rs1 = operand_reg, - .rs2 = @enumFromInt(0b00010), // this is the cpop funct5 + .rs2 = @fromBackingInt(@intCast(0b00010)), // this is the cpop funct5 }, }, }); @@ -4154,7 +4154,7 @@ fn airPopcount(func: *Func, inst: Air.Inst.Index) !void { fn airAbs(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const ty = func.typeOf(ty_op.operand); const scalar_ty = ty.scalarType(zcu); @@ -4252,7 +4252,7 @@ fn airAbs(func: *Func, inst: Air.Inst.Index) !void { } fn airByteSwap(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const pt = func.pt; const zcu = pt.zcu; @@ -4314,7 +4314,7 @@ fn airByteSwap(func: *Func, inst: Air.Inst.Index) !void { } fn airBitReverse(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airBitReverse for {}", .{func.target.cpu.arch}); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } @@ -4322,7 +4322,7 @@ fn airBitReverse(func: *Func, inst: Air.Inst.Index) !void { fn airUnaryMath(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { const pt = func.pt; const zcu = pt.zcu; - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const ty = func.typeOf(un_op); @@ -4432,7 +4432,7 @@ fn reuseOperandAdvanced( fn airLoad(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const elem_ty = func.typeOfIndex(inst); const result: MCValue = result: { @@ -4512,7 +4512,7 @@ fn airStore(func: *Func, inst: Air.Inst.Index, safety: bool) !void { } else { // TODO if the value is undef, don't lower this instruction } - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr = try func.resolveInst(bin_op.lhs); const value = try func.resolveInst(bin_op.rhs); const ptr_ty = func.typeOf(bin_op.lhs); @@ -4559,14 +4559,14 @@ fn store(func: *Func, ptr_mcv: MCValue, src_mcv: MCValue, ptr_ty: Type) !void { } fn airStructFieldPtr(func: *Func, inst: Air.Inst.Index) !void { - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.StructField, ty_pl.payload).data; const result = try func.structFieldPtr(inst, extra.struct_operand, extra.field_index); return func.finishAir(inst, result, .{ extra.struct_operand, .none, .none }); } fn airStructFieldPtrIndex(func: *Func, inst: Air.Inst.Index, index: u8) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result = try func.structFieldPtr(inst, ty_op.operand, index); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } @@ -4598,7 +4598,7 @@ fn airAggFieldVal(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.StructField, ty_pl.payload).data; const operand = extra.struct_operand; const index = extra.field_index; @@ -4746,7 +4746,7 @@ fn airArg(func: *Func, inst: Air.Inst.Index) InnerError!void { try func.genCopy(arg_ty, dst_mcv, src_mcv); - const arg = func.air.instructions.items(.data)[@intFromEnum(inst)].arg; + const arg = func.air.instructions.items(.data)[@backingInt(inst)].arg; // can delete `func.func_index` if this logic is moved to emit const func_zir = zcu.funcInfo(func.func_index).zir_body_inst.resolveFull(&zcu.intern_pool).?; const file = zcu.fileByIndex(func_zir.file); @@ -4871,10 +4871,10 @@ fn genCall( }); const frame_allocs_slice = func.frame_allocs.slice(); const stack_frame_size = - &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)]; + &frame_allocs_slice.items(.abi_size)[@backingInt(FrameIndex.call_frame)]; stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size); const stack_frame_align = - &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)]; + &frame_allocs_slice.items(.abi_align)[@backingInt(FrameIndex.call_frame)]; stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align); } @@ -4958,7 +4958,7 @@ fn genCall( .func => |func_val| { if (func.bin_file.cast(.elf)) |elf_file| { const zo = elf_file.zigObjectPtr().?; - const sym_index: link.File.SymbolId = @enumFromInt(try zo.getOrCreateMetadataForNav(zcu, func_val.owner_nav)); + const sym_index: link.File.SymbolId = @fromBackingInt(@intCast(try zo.getOrCreateMetadataForNav(zcu, func_val.owner_nav))); if (func.mod.pic) { return func.fail("TODO: genCall pic", .{}); @@ -4978,7 +4978,7 @@ fn genCall( .@"extern" => |@"extern"| { const lib_name = @"extern".lib_name.toSlice(&zcu.intern_pool); const name = @"extern".name.toSlice(&zcu.intern_pool); - const atom_index: link.File.AtomId = @enumFromInt(try func.owner.getSymbolIndex(func)); + const atom_index: link.File.AtomId = @fromBackingInt(@intCast(try func.owner.getSymbolIndex(func))); const elf_file = func.bin_file.cast(.elf).?; _ = try func.addInst(.{ @@ -4986,7 +4986,7 @@ fn genCall( .data = .{ .reloc = .{ .register = .ra, .atom_index = atom_index, - .sym_index = @enumFromInt(try elf_file.getGlobalSymbol(name, lib_name)), + .sym_index = @fromBackingInt(@intCast(try elf_file.getGlobalSymbol(name, lib_name))), } }, }); }, @@ -5021,7 +5021,7 @@ fn genCall( fn airRet(func: *Func, inst: Air.Inst.Index, safety: bool) !void { const pt = func.pt; const zcu = pt.zcu; - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; if (safety) { // safe @@ -5087,7 +5087,7 @@ fn airRet(func: *Func, inst: Air.Inst.Index, safety: bool) !void { } fn airRetLoad(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const ptr = try func.resolveInst(un_op); const ptr_ty = func.typeOf(un_op); @@ -5113,7 +5113,7 @@ fn airRetLoad(func: *Func, inst: Air.Inst.Index) !void { } fn airCmp(func: *Func, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const pt = func.pt; const zcu = pt.zcu; @@ -5176,7 +5176,7 @@ fn airCmpVector(func: *Func, inst: Air.Inst.Index) !void { } fn airCmpLteErrorsLen(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try func.resolveInst(un_op); _ = operand; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airCmpLteErrorsLen for {}", .{func.target.cpu.arch}); @@ -5184,7 +5184,7 @@ fn airCmpLteErrorsLen(func: *Func, inst: Air.Inst.Index) !void { } fn airDbgStmt(func: *Func, inst: Air.Inst.Index) !void { - const dbg_stmt = func.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = func.air.instructions.items(.data)[@backingInt(inst)].dbg_stmt; _ = try func.addInst(.{ .tag = .pseudo_dbg_line_column, @@ -5203,13 +5203,13 @@ fn airDbgInlineBlock(func: *Func, inst: Air.Inst.Index) !void { } fn airDbgVar(func: *Func, inst: Air.Inst.Index) InnerError!void { - const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = func.air.instructions.items(.data)[@backingInt(inst)].pl_op; const operand = pl_op.operand; const ty = func.typeOf(operand); const mcv = try func.resolveInst(operand); - const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); - const tag = func.air.instructions.items(.tag)[@intFromEnum(inst)]; + const tag = func.air.instructions.items(.tag)[@backingInt(inst)]; func.genVarDbgInfo(tag, ty, mcv, name.toSlice(func.air)) catch |err| return func.fail("failed to generate variable debug info: {s}", .{@errorName(err)}); @@ -5409,7 +5409,7 @@ fn isNull(func: *Func, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC } fn airIsNull(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try func.resolveInst(un_op); const ty = func.typeOf(un_op); const result = try func.isNull(inst, ty, operand); @@ -5417,7 +5417,7 @@ fn airIsNull(func: *Func, inst: Air.Inst.Index) !void { } fn airIsNullPtr(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try func.resolveInst(un_op); _ = operand; const ty = func.typeOf(un_op); @@ -5429,7 +5429,7 @@ fn airIsNullPtr(func: *Func, inst: Air.Inst.Index) !void { } fn airIsNonNull(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try func.resolveInst(un_op); const ty = func.typeOf(un_op); const result = try func.isNull(inst, ty, operand); @@ -5449,7 +5449,7 @@ fn airIsNonNull(func: *Func, inst: Air.Inst.Index) !void { } fn airIsNonNullPtr(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try func.resolveInst(un_op); _ = operand; const ty = func.typeOf(un_op); @@ -5461,7 +5461,7 @@ fn airIsNonNullPtr(func: *Func, inst: Air.Inst.Index) !void { } fn airIsErr(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const operand = try func.resolveInst(un_op); const operand_ty = func.typeOf(un_op); @@ -5473,7 +5473,7 @@ fn airIsErr(func: *Func, inst: Air.Inst.Index) !void { fn airIsErrPtr(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const operand_ptr = try func.resolveInst(un_op); const operand: MCValue = blk: { @@ -5553,7 +5553,7 @@ fn isErr(func: *Func, maybe_inst: ?Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) } fn airIsNonErr(func: *Func, inst: Air.Inst.Index) !void { - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const operand = try func.resolveInst(un_op); const ty = func.typeOf(un_op); @@ -5589,7 +5589,7 @@ fn isNonErr(func: *Func, inst: Air.Inst.Index, eu_ty: Type, eu_mcv: MCValue) !MC fn airIsNonErrPtr(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const operand_ptr = try func.resolveInst(un_op); const operand: MCValue = blk: { @@ -5843,7 +5843,7 @@ fn airLoopSwitchBr(func: *Func, inst: Air.Inst.Index) !void { } fn airSwitchDispatch(func: *Func, inst: Air.Inst.Index) !void { - const br = func.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = func.air.instructions.items(.data)[@backingInt(inst)].br; const block_ty = func.typeOfIndex(br.block_inst); const block_tracking = func.inst_tracking.getPtr(br.block_inst).?; @@ -5905,7 +5905,7 @@ fn performReloc(func: *Func, inst: Mir.Inst.Index) void { fn airBr(func: *Func, inst: Air.Inst.Index) !void { const zcu = func.pt.zcu; - const br = func.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = func.air.instructions.items(.data)[@backingInt(inst)].br; const block_ty = func.typeOfIndex(br.block_inst); const block_unused = !block_ty.hasRuntimeBits(zcu) or func.liveness.isUnused(br.block_inst); @@ -5968,7 +5968,7 @@ fn airBr(func: *Func, inst: Air.Inst.Index) !void { } fn airRepeat(func: *Func, inst: Air.Inst.Index) !void { - const loop_inst = func.air.instructions.items(.data)[@intFromEnum(inst)].repeat.loop_inst; + const loop_inst = func.air.instructions.items(.data)[@backingInt(inst)].repeat.loop_inst; const repeat_info = func.loops.get(loop_inst).?; try func.restoreState(repeat_info.state, &.{}, .{ .emit_instructions = true, @@ -5981,8 +5981,8 @@ fn airRepeat(func: *Func, inst: Air.Inst.Index) !void { } fn airBoolOp(func: *Func, inst: Air.Inst.Index) !void { - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; - const tag: Air.Inst.Tag = func.air.instructions.items(.tag)[@intFromEnum(inst)]; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; + const tag: Air.Inst.Tag = func.air.instructions.items(.tag)[@backingInt(inst)]; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const lhs = try func.resolveInst(bin_op.lhs); @@ -6404,7 +6404,7 @@ fn airAsm(func: *Func, inst: Air.Inst.Index) !void { .tag = .pseudo_extern_fn_reloc, .data = .{ .reloc = .{ .register = random_link_reg, - .atom_index = @enumFromInt(try func.owner.getSymbolIndex(func)), + .atom_index = @fromBackingInt(@intCast(try func.owner.getSymbolIndex(func))), .sym_index = sym_offset.sym, } }, }); @@ -7035,7 +7035,7 @@ fn genSetReg(func: *Func, ty: Type, reg: Register, src_mcv: MCValue) InnerError! }, .lea_symbol => |sym_off| { assert(sym_off.off == 0); - const atom_index: link.File.AtomId = @enumFromInt(try func.owner.getSymbolIndex(func)); + const atom_index: link.File.AtomId = @fromBackingInt(@intCast(try func.owner.getSymbolIndex(func))); _ = try func.addInst(.{ .tag = .pseudo_load_symbol, @@ -7154,8 +7154,8 @@ fn genSetMem( const mem_size = switch (base) { .frame => |base_fi| mem_size: { assert(disp >= 0); - const frame_abi_size = func.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)]; - const frame_spill_pad = func.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)]; + const frame_abi_size = func.frame_allocs.items(.abi_size)[@backingInt(base_fi)]; + const frame_spill_pad = func.frame_allocs.items(.spill_pad)[@backingInt(base_fi)]; assert(frame_abi_size - frame_spill_pad - disp >= abi_size); break :mem_size if (frame_abi_size - frame_spill_pad - disp == abi_size) frame_abi_size @@ -7225,7 +7225,7 @@ fn airBitCast(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result = if (func.liveness.isUnused(inst)) .unreach else result: { const src_mcv = try func.resolveInst(ty_op.operand); @@ -7262,7 +7262,7 @@ fn airBitCast(func: *Func, inst: Air.Inst.Index) !void { fn airArrayToSlice(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const slice_ty = func.typeOfIndex(inst); const ptr_ty = func.typeOf(ty_op.operand); @@ -7284,7 +7284,7 @@ fn airArrayToSlice(func: *Func, inst: Air.Inst.Index) !void { } fn airFloatFromInt(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const pt = func.pt; const zcu = pt.zcu; @@ -7348,7 +7348,7 @@ fn airFloatFromInt(func: *Func, inst: Air.Inst.Index) !void { } fn airIntFromFloat(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const pt = func.pt; const zcu = pt.zcu; @@ -7410,7 +7410,7 @@ fn airCmpxchg(func: *Func, inst: Air.Inst.Index, strength: enum { weak, strong } const pt = func.pt; const zcu = pt.zcu; - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.Cmpxchg, ty_pl.payload).data; const ptr_ty = func.typeOf(extra.ptr); @@ -7547,7 +7547,7 @@ fn airCmpxchg(func: *Func, inst: Air.Inst.Index, strength: enum { weak, strong } fn airAtomicRmw(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = func.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = func.air.extraData(Air.AtomicRmw, pl_op.payload).data; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { @@ -7689,7 +7689,7 @@ fn airAtomicRmw(func: *Func, inst: Air.Inst.Index) !void { fn airAtomicLoad(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const atomic_load = func.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; + const atomic_load = func.air.instructions.items(.data)[@backingInt(inst)].atomic_load; const order: std.lang.AtomicOrder = atomic_load.order; const ptr_ty = func.typeOf(atomic_load.ptr); @@ -7737,7 +7737,7 @@ fn airAtomicLoad(func: *Func, inst: Air.Inst.Index) !void { } fn airAtomicStore(func: *Func, inst: Air.Inst.Index, order: std.lang.AtomicOrder) !void { - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = func.typeOf(bin_op.lhs); const ptr_mcv = try func.resolveInst(bin_op.lhs); @@ -7780,7 +7780,7 @@ fn airAtomicStore(func: *Func, inst: Air.Inst.Index, order: std.lang.AtomicOrder fn airMemset(func: *Func, inst: Air.Inst.Index, safety: bool) !void { const pt = func.pt; const zcu = pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; result: { if (!safety and (try func.resolveInst(bin_op.rhs)) == .undef) break :result; @@ -7861,7 +7861,7 @@ fn airMemset(func: *Func, inst: Air.Inst.Index, safety: bool) !void { fn airMemcpy(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; const zcu = pt.zcu; - const bin_op = func.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = func.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dst_ptr = try func.resolveInst(bin_op.lhs); const src_ptr = try func.resolveInst(bin_op.rhs); @@ -7909,7 +7909,7 @@ fn airMemmove(func: *Func, inst: Air.Inst.Index) !void { fn airTagName(func: *Func, inst: Air.Inst.Index) !void { const pt = func.pt; - const un_op = func.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = func.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else result: { const enum_ty = func.typeOf(un_op); @@ -7954,13 +7954,13 @@ fn airErrorName(func: *Func, inst: Air.Inst.Index) !void { } fn airSplat(func: *Func, inst: Air.Inst.Index) !void { - const ty_op = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = func.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airSplat for riscv64", .{}); return func.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airSelect(func: *Func, inst: Air.Inst.Index) !void { - const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = func.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = func.air.extraData(Air.Bin, pl_op.payload).data; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airSelect for riscv64", .{}); return func.finishAir(inst, result, .{ pl_op.operand, extra.lhs, extra.rhs }); @@ -7977,7 +7977,7 @@ fn airShuffleTwo(func: *Func, inst: Air.Inst.Index) !void { } fn airReduce(func: *Func, inst: Air.Inst.Index) !void { - const reduce = func.air.instructions.items(.data)[@intFromEnum(inst)].reduce; + const reduce = func.air.instructions.items(.data)[@backingInt(inst)].reduce; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else return func.fail("TODO implement airReduce for riscv64", .{}); return func.finishAir(inst, result, .{ reduce.operand, .none, .none }); } @@ -7987,7 +7987,7 @@ fn airAggregateInit(func: *Func, inst: Air.Inst.Index) !void { const zcu = pt.zcu; const result_ty = func.typeOfIndex(inst); const len: usize = @intCast(result_ty.arrayLen(zcu)); - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const elements: []const Air.Inst.Ref = @ptrCast(func.air.extra.items[ty_pl.payload..][0..len]); const result: MCValue = result: { @@ -8085,7 +8085,7 @@ fn airAggregateInit(func: *Func, inst: Air.Inst.Index) !void { } fn airUnionInit(func: *Func, inst: Air.Inst.Index) !void { - const ty_pl = func.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = func.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = func.air.extraData(Air.UnionInit, ty_pl.payload).data; _ = extra; return func.fail("TODO implement airUnionInit for riscv64", .{}); @@ -8093,14 +8093,14 @@ fn airUnionInit(func: *Func, inst: Air.Inst.Index) !void { } fn airPrefetch(func: *Func, inst: Air.Inst.Index) !void { - const prefetch = func.air.instructions.items(.data)[@intFromEnum(inst)].prefetch; + const prefetch = func.air.instructions.items(.data)[@backingInt(inst)].prefetch; // TODO: RISC-V does have prefetch instruction variants. // see here: https://raw.githubusercontent.com/riscv/riscv-CMOs/master/specifications/cmobase-v1.0.1.pdf return func.finishAir(inst, .unreach, .{ prefetch.ptr, .none, .none }); } fn airMulAdd(func: *Func, inst: Air.Inst.Index) !void { - const pl_op = func.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = func.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = func.air.extraData(Air.Bin, pl_op.payload).data; const result: MCValue = if (func.liveness.isUnused(inst)) .unreach else { return func.fail("TODO implement airMulAdd for riscv64", .{}); @@ -8379,7 +8379,7 @@ fn typeOf(func: *Func, inst: Air.Inst.Ref) Type { fn typeOfIndex(func: *Func, inst: Air.Inst.Index) Type { const zcu = func.pt.zcu; - return switch (func.air.instructions.items(.tag)[@intFromEnum(inst)]) { + return switch (func.air.instructions.items(.tag)[@backingInt(inst)]) { .loop_switch_br => func.typeOf(func.air.unwrapSwitch(inst).operand), else => func.air.typeOfIndex(inst, &zcu.intern_pool), }; diff --git a/src/codegen/riscv64/Emit.zig b/src/codegen/riscv64/Emit.zig index 42b17b005c37bfb93e55197318c8d911930620db..f5a3f9584a5018fa88e0d2a7507d2fd73cbef645 100644 --- a/src/codegen/riscv64/Emit.zig +++ b/src/codegen/riscv64/Emit.zig @@ -47,25 +47,25 @@ pub fn emitMir(emit: *Emit) Error!void { const elf_file = emit.bin_file.cast(.elf).?; const zo = elf_file.zigObjectPtr().?; - const atom_ptr = zo.symbol(@intFromEnum(symbol.atom_index)).atom(elf_file).?; - const sym = zo.symbol(@intFromEnum(symbol.sym_index)); + const atom_ptr = zo.symbol(@backingInt(symbol.atom_index)).atom(elf_file).?; + const sym = zo.symbol(@backingInt(symbol.sym_index)); if (emit.lower.pic) { return emit.fail("know when to emit GOT relocation for symbol '{s}'", .{sym.name(elf_file)}); } - const hi_r_type: u32 = @intFromEnum(std.elf.R_RISCV.HI20); - const lo_r_type: u32 = @intFromEnum(std.elf.R_RISCV.LO12_I); + const hi_r_type: u32 = @backingInt(std.elf.R_RISCV.HI20); + const lo_r_type: u32 = @backingInt(std.elf.R_RISCV.LO12_I); try atom_ptr.addReloc(gpa, .{ .r_offset = start_offset, - .r_info = (@as(u64, @intFromEnum(symbol.sym_index)) << 32) | hi_r_type, + .r_info = (@as(u64, @backingInt(symbol.sym_index)) << 32) | hi_r_type, .r_addend = 0, }, zo); try atom_ptr.addReloc(gpa, .{ .r_offset = start_offset + 4, - .r_info = (@as(u64, @intFromEnum(symbol.sym_index)) << 32) | lo_r_type, + .r_info = (@as(u64, @backingInt(symbol.sym_index)) << 32) | lo_r_type, .r_addend = 0, }, zo); }, @@ -73,38 +73,38 @@ pub fn emitMir(emit: *Emit) Error!void { const elf_file = emit.bin_file.cast(.elf).?; const zo = elf_file.zigObjectPtr().?; - const atom_ptr = zo.symbol(@intFromEnum(symbol.atom_index)).atom(elf_file).?; + const atom_ptr = zo.symbol(@backingInt(symbol.atom_index)).atom(elf_file).?; const R_RISCV = std.elf.R_RISCV; try atom_ptr.addReloc(gpa, .{ .r_offset = start_offset, - .r_info = (@as(u64, @intFromEnum(symbol.sym_index)) << 32) | @intFromEnum(R_RISCV.TPREL_HI20), + .r_info = (@as(u64, @backingInt(symbol.sym_index)) << 32) | @backingInt(R_RISCV.TPREL_HI20), .r_addend = 0, }, zo); try atom_ptr.addReloc(gpa, .{ .r_offset = start_offset + 4, - .r_info = (@as(u64, @intFromEnum(symbol.sym_index)) << 32) | @intFromEnum(R_RISCV.TPREL_ADD), + .r_info = (@as(u64, @backingInt(symbol.sym_index)) << 32) | @backingInt(R_RISCV.TPREL_ADD), .r_addend = 0, }, zo); try atom_ptr.addReloc(gpa, .{ .r_offset = start_offset + 8, - .r_info = (@as(u64, @intFromEnum(symbol.sym_index)) << 32) | @intFromEnum(R_RISCV.TPREL_LO12_I), + .r_info = (@as(u64, @backingInt(symbol.sym_index)) << 32) | @backingInt(R_RISCV.TPREL_LO12_I), .r_addend = 0, }, zo); }, .call_extern_fn_reloc => |symbol| { const elf_file = emit.bin_file.cast(.elf).?; const zo = elf_file.zigObjectPtr().?; - const atom_ptr = zo.symbol(@intFromEnum(symbol.atom_index)).atom(elf_file).?; + const atom_ptr = zo.symbol(@backingInt(symbol.atom_index)).atom(elf_file).?; - const r_type: u32 = @intFromEnum(std.elf.R_RISCV.CALL_PLT); + const r_type: u32 = @backingInt(std.elf.R_RISCV.CALL_PLT); try atom_ptr.addReloc(gpa, .{ .r_offset = start_offset, - .r_info = (@as(u64, @intFromEnum(symbol.sym_index)) << 32) | r_type, + .r_info = (@as(u64, @backingInt(symbol.sym_index)) << 32) | r_type, .r_addend = 0, }, zo); }, diff --git a/src/codegen/riscv64/Lower.zig b/src/codegen/riscv64/Lower.zig index a3de43ad46d00ec6aa4c43015d9e8ff4f4f214b9..b111dae26d4d435432c8d61b621e65175d632d09 100644 --- a/src/codegen/riscv64/Lower.zig +++ b/src/codegen/riscv64/Lower.zig @@ -554,7 +554,7 @@ fn pushPopRegList(lower: *Lower, comptime spilling: bool, reg_list: Mir.Register var reg_i: u31 = 0; while (it.next()) |i| { - const frame = lower.mir.frame_locs.get(@intFromEnum(bits.FrameIndex.spill_frame)); + const frame = lower.mir.frame_locs.get(@backingInt(bits.FrameIndex.spill_frame)); const reg = abi.Registers.all_preserved[i]; const reg_class = reg.class(); diff --git a/src/codegen/riscv64/bits.zig b/src/codegen/riscv64/bits.zig index b2fea0171d203d94c70a09cdebace029a440d081..184b5c2d89e06ef5a7e14aeefef63ee5814d2ca5 100644 --- a/src/codegen/riscv64/bits.zig +++ b/src/codegen/riscv64/bits.zig @@ -75,7 +75,7 @@ pub const Memory = struct { }; }, .frame => |index| { - const base_loc = mir.frame_locs.get(@intFromEnum(index)); + const base_loc = mir.frame_locs.get(@backingInt(index)); return .{ .base = base_loc.base, .disp = base_loc.disp + offset, @@ -191,7 +191,7 @@ pub const Register = enum(u8) { /// seperate IDs for `x0` and `f0`. We will assume that each register set has 32 registers /// and is repeated twice, once for the named version, once for the number version. pub fn id(reg: Register) std.math.IntFittingRange(0, @typeInfo(Register).@"enum".field_names.len) { - const base = switch (@intFromEnum(reg)) { + const base = switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.zero) ... @intFromEnum(Register.x31) => @intFromEnum(Register.zero), @intFromEnum(Register.ft0) ... @intFromEnum(Register.f31) => @intFromEnum(Register.ft0), @@ -204,7 +204,7 @@ pub const Register = enum(u8) { } pub fn encodeId(reg: Register) u5 { - return @truncate(@intFromEnum(reg)); + return @truncate(@backingInt(reg)); } pub fn dwarfNum(reg: Register) u8 { @@ -212,7 +212,7 @@ pub const Register = enum(u8) { } pub fn bitSize(reg: Register, zcu: *const Zcu) u32 { - return switch (@intFromEnum(reg)) { + return switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.zero) ... @intFromEnum(Register.x31) => 64, @intFromEnum(Register.ft0) ... @intFromEnum(Register.f31) => if (zcu.getTarget().cpu.has(.riscv, .d)) 64 else 32, @@ -223,7 +223,7 @@ pub const Register = enum(u8) { } pub fn class(reg: Register) abi.RegisterClass { - return switch (@intFromEnum(reg)) { + return switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.zero) ... @intFromEnum(Register.x31) => .int, @intFromEnum(Register.ft0) ... @intFromEnum(Register.f31) => .float, @@ -254,7 +254,7 @@ pub const FrameIndex = enum(u32) { pub const named_count = @typeInfo(FrameIndex).@"enum".field_names.len; pub fn isNamed(fi: FrameIndex) bool { - return @intFromEnum(fi) < named_count; + return @backingInt(fi) < named_count; } }; diff --git a/src/codegen/riscv64/encoding.zig b/src/codegen/riscv64/encoding.zig index a6c4303af3779a101f377ff7f863e30e2672170d..40de9855cd342b35ea2ba540a20d589822c1b76f 100644 --- a/src/codegen/riscv64/encoding.zig +++ b/src/codegen/riscv64/encoding.zig @@ -523,7 +523,7 @@ pub const Instruction = union(Lir.Format) { } pub fn fromLir(lir: Lir, ops: []const Operand) Instruction { - const opcode: u7 = @intFromEnum(lir.opcode); + const opcode: u7 = @backingInt(lir.opcode); switch (lir.format) { .R => { @@ -545,26 +545,26 @@ pub const Instruction = union(Lir.Format) { .opcode = opcode, .funct3 = fmt.rm, - .funct7 = (@as(u7, fmt.funct5) << 2) | @intFromEnum(fmt.fmt), + .funct7 = (@as(u7, fmt.funct5) << 2) | @backingInt(fmt.fmt), }, .fcvt => |fcvt| .{ .rd = ops[0].reg.encodeId(), .rs1 = ops[1].reg.encodeId(), - .rs2 = @intFromEnum(fcvt.width), + .rs2 = @backingInt(fcvt.width), .opcode = opcode, .funct3 = fcvt.rm, - .funct7 = (@as(u7, fcvt.funct5) << 2) | @intFromEnum(fcvt.fmt), + .funct7 = (@as(u7, fcvt.funct5) << 2) | @backingInt(fcvt.fmt), }, .vecls => |vec| .{ .rd = ops[0].reg.encodeId(), .rs1 = ops[1].reg.encodeId(), - .rs2 = @intFromEnum(vec.umop), + .rs2 = @backingInt(vec.umop), .opcode = opcode, - .funct3 = @intFromEnum(vec.width), - .funct7 = (@as(u7, vec.nf) << 4) | (@as(u7, @intFromBool(vec.mew)) << 3) | (@as(u7, @intFromEnum(vec.mop)) << 1) | @intFromBool(vec.vm), + .funct3 = @backingInt(vec.width), + .funct7 = (@as(u7, vec.nf) << 4) | (@as(u7, @intFromBool(vec.mew)) << 3) | (@as(u7, @backingInt(vec.mop)) << 1) | @intFromBool(vec.vm), }, .vecmath => |vec| .{ .rd = ops[0].reg.encodeId(), @@ -572,7 +572,7 @@ pub const Instruction = union(Lir.Format) { .rs2 = ops[2].reg.encodeId(), .opcode = opcode, - .funct3 = @intFromEnum(vec.funct3), + .funct3 = @backingInt(vec.funct3), .funct7 = (@as(u7, vec.funct6) << 1) | @intFromBool(vec.vm), }, .amo => |amo| .{ @@ -581,7 +581,7 @@ pub const Instruction = union(Lir.Format) { .rs2 = ops[2].reg.encodeId(), .opcode = opcode, - .funct3 = @intFromEnum(amo.width), + .funct3 = @backingInt(amo.width), .funct7 = @as(u7, amo.funct5) << 2 | @as(u7, @intFromBool(ops[3].barrier == .rl)) << 1 | @as(u7, @intFromBool(ops[4].barrier == .aq)), @@ -629,9 +629,9 @@ pub const Instruction = union(Lir.Format) { .rd = 0, .rs1 = 0, .funct3 = 0, - .imm0_11 = (@as(u12, @intFromEnum(fence.fm)) << 8) | - (@as(u12, @intFromEnum(ops[1].barrier)) << 4) | - @as(u12, @intFromEnum(ops[0].barrier)), + .imm0_11 = (@as(u12, @backingInt(fence.fm)) << 8) | + (@as(u12, @backingInt(ops[1].barrier)) << 4) | + @as(u12, @backingInt(ops[0].barrier)), .opcode = opcode, }, else => unreachable, diff --git a/src/codegen/sparc64/CodeGen.zig b/src/codegen/sparc64/CodeGen.zig index 23a69bab00cb5c7c83a0cdfc4aad4c4b63a60fd7..c5161485d377a68949901d6ed882346289a1c354 100644 --- a/src/codegen/sparc64/CodeGen.zig +++ b/src/codegen/sparc64/CodeGen.zig @@ -466,7 +466,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void { try self.ensureProcessDeathCapacity(Air.Liveness.bpi); self.reused_operands = @TypeOf(self.reused_operands).empty; - switch (air_tags[@intFromEnum(inst)]) { + switch (air_tags[@backingInt(inst)]) { // zig fmt: off // No "scalarize" legalizations are enabled, so these instructions never appear. @@ -726,21 +726,21 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void { if (std.debug.runtime_safety) { if (self.air_bookkeeping < old_air_bookkeeping + 1) { - std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{t}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@intFromEnum(inst)] }); + std.debug.panic("in codegen.zig, handling of AIR instruction %{d} ('{t}') did not do proper bookkeeping. Look for a missing call to finishAir.", .{ inst, air_tags[@backingInt(inst)] }); } } } } fn airAddSat(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement add_sat for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } fn airAddSubWithOverflow(self: *Self, inst: Air.Inst.Index) !void { - const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)]; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const tag = self.air.instructions.items(.tag)[@backingInt(inst)]; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Bin, ty_pl.payload).data; const pt = self.pt; const zcu = pt.zcu; @@ -825,7 +825,7 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void { const zcu = pt.zcu; const vector_ty = self.typeOfIndex(inst); const len = vector_ty.vectorLen(zcu); - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[ty_pl.payload..][0..len]); const result: MCValue = res: { if (self.liveness.isUnused(inst)) break :res MCValue.dead; @@ -850,7 +850,7 @@ fn airAlloc(self: *Self, inst: Air.Inst.Index) !void { } fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement array_elem_val for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } @@ -858,7 +858,7 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void { fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const ptr_ty = self.typeOf(ty_op.operand); const ptr = try self.resolveInst(ty_op.operand); @@ -993,7 +993,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) InnerError!void { const func_zir = zcu.funcInfo(self.func_index).zir_body_inst.resolveFull(&zcu.intern_pool).?; const file = zcu.fileByIndex(func_zir.file); if (!file.mod.?.strip) { - const arg = self.air.instructions.items(.data)[@intFromEnum(inst)].arg; + const arg = self.air.instructions.items(.data)[@backingInt(inst)].arg; const zir = &file.zir.?; const name = zir.nullTerminatedString(zir.getParamName(zir.getParamBody(func_zir.inst)[arg.zir_param_index]).?); @@ -1015,7 +1015,7 @@ fn airArg(self: *Self, inst: Air.Inst.Index) InnerError!void { } fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void { - _ = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; + _ = self.air.instructions.items(.data)[@backingInt(inst)].atomic_load; return self.fail("TODO implement airAtomicLoad for {}", .{ self.target.cpu.arch, @@ -1023,7 +1023,7 @@ fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void { } fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void { - _ = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + _ = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; return self.fail("TODO implement airAtomicRmw for {}", .{ self.target.cpu.arch, @@ -1031,7 +1031,7 @@ fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void { } fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const lhs_ty = self.typeOf(bin_op.lhs); @@ -1048,7 +1048,7 @@ fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { } fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); @@ -1066,7 +1066,7 @@ fn airPtrArithmetic(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void } fn airBitCast(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result = if (self.liveness.isUnused(inst)) .dead else result: { const operand = try self.resolveInst(ty_op.operand); if (self.reuseOperand(inst, ty_op.operand, 0, operand)) break :result operand; @@ -1086,7 +1086,7 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void { } fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } @@ -1134,7 +1134,7 @@ fn lowerBlock(self: *Self, inst: Air.Inst.Index, body: []const Air.Inst.Index) ! } fn airBr(self: *Self, inst: Air.Inst.Index) !void { - const branch = self.air.instructions.items(.data)[@intFromEnum(inst)].br; + const branch = self.air.instructions.items(.data)[@backingInt(inst)].br; try self.br(branch.block_inst, branch.operand); return self.finishAir(inst, .dead, .{ branch.operand, .none, .none }); } @@ -1172,7 +1172,7 @@ fn airBreakpoint(self: *Self) !void { fn airByteSwap(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; // We have hardware byteswapper in SPARCv9, don't let mainstream compilers mislead you. // That being said, the strategy to lower this is: @@ -1359,13 +1359,13 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.lang.CallModifier) ! } fn airClz(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airClz for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const pt = self.pt; const zcu = pt.zcu; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { @@ -1423,7 +1423,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void { } fn airCmpLteErrorsLen(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); _ = operand; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCmpLteErrorsLen for {}", .{self.target.cpu.arch}); @@ -1584,7 +1584,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void { } fn airCtz(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airCtz for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } @@ -1596,7 +1596,7 @@ fn airDbgInlineBlock(self: *Self, inst: Air.Inst.Index) !void { } fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void { - const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = self.air.instructions.items(.data)[@backingInt(inst)].dbg_stmt; _ = try self.addInst(.{ .tag = .dbg_line, @@ -1612,8 +1612,8 @@ fn airDbgStmt(self: *Self, inst: Air.Inst.Index) !void { } fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void { - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; - const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; + const name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); const operand = pl_op.operand; // TODO emit debug info for this variable _ = name; @@ -1621,13 +1621,13 @@ fn airDbgVar(self: *Self, inst: Air.Inst.Index) !void { } fn airDiv(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement div for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } fn airErrorName(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const result: MCValue = if (self.liveness.isUnused(inst)) .dead else { _ = operand; @@ -1637,13 +1637,13 @@ fn airErrorName(self: *Self, inst: Air.Inst.Index) !void { } fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airIntFromFloat for {}", .{ self.target.cpu.arch, }); @@ -1651,13 +1651,13 @@ fn airIntFromFloat(self: *Self, inst: Air.Inst.Index) !void { } fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airIntCast(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; if (self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none }); @@ -1677,7 +1677,7 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void { } fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airFloatFromInt for {}", .{ self.target.cpu.arch, }); @@ -1685,7 +1685,7 @@ fn airFloatFromInt(self: *Self, inst: Air.Inst.Index) !void { } fn airIsErr(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const operand = try self.resolveInst(un_op); const ty = self.typeOf(un_op); @@ -1695,7 +1695,7 @@ fn airIsErr(self: *Self, inst: Air.Inst.Index) !void { } fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const operand = try self.resolveInst(un_op); const ty = self.typeOf(un_op); @@ -1705,7 +1705,7 @@ fn airIsNonErr(self: *Self, inst: Air.Inst.Index) !void { } fn airIsNull(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const operand = try self.resolveInst(un_op); break :result try self.isNull(operand); @@ -1714,7 +1714,7 @@ fn airIsNull(self: *Self, inst: Air.Inst.Index) !void { } fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const operand = try self.resolveInst(un_op); break :result try self.isNonNull(operand); @@ -1725,7 +1725,7 @@ fn airIsNonNull(self: *Self, inst: Air.Inst.Index) !void { fn airLoad(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const elem_ty = self.typeOfIndex(inst); const elem_size = elem_ty.abiSize(zcu); const result: MCValue = result: { @@ -1771,7 +1771,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void { } else { // TODO if the value is undef, don't lower this instruction } - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.Bin, pl_op.payload); const operand = pl_op.operand; @@ -1785,8 +1785,8 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void { } fn airMinMax(self: *Self, inst: Air.Inst.Index) !void { - const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)]; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const tag = self.air.instructions.items(.tag)[@backingInt(inst)]; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const lhs_ty = self.typeOf(bin_op.lhs); @@ -1801,7 +1801,7 @@ fn airMinMax(self: *Self, inst: Air.Inst.Index) !void { } fn airMod(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const lhs_ty = self.typeOf(bin_op.lhs); @@ -1939,14 +1939,14 @@ fn airMod(self: *Self, inst: Air.Inst.Index) !void { } fn airMulSat(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement mul_sat for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void { //const tag = self.air.instructions.items(.tag)[@intFromEnum(inst)]; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Bin, ty_pl.payload).data; const pt = self.pt; const zcu = pt.zcu; @@ -2012,7 +2012,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void { } fn airNot(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const pt = self.pt; const zcu = pt.zcu; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { @@ -2109,51 +2109,51 @@ fn airNot(self: *Self, inst: Air.Inst.Index) !void { } fn airOptionalPayload(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airOptionalPayloadPtr(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airOptionalPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .optional_payload_ptr_set for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airPopcount(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airPopcount for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airPrefetch(self: *Self, inst: Air.Inst.Index) !void { - const prefetch = self.air.instructions.items(.data)[@intFromEnum(inst)].prefetch; + const prefetch = self.air.instructions.items(.data)[@backingInt(inst)].prefetch; // TODO Emit a PREFETCH/IPREFETCH as necessary, see A.7 and A.42 return self.finishAir(inst, MCValue.dead, .{ prefetch.ptr, .none, .none }); } fn airPtrElemVal(self: *Self, inst: Air.Inst.Index) !void { const is_volatile = false; // TODO - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (!is_volatile and self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_val for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } fn airPtrElemPtr(self: *Self, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Bin, ty_pl.payload).data; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement ptr_elem_ptr for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ extra.lhs, extra.rhs, .none }); } fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const ptr_bits = self.target.ptrBitWidth(); const ptr_bytes = @divExact(ptr_bits, 8); @@ -2170,7 +2170,7 @@ fn airPtrSliceLenPtr(self: *Self, inst: Air.Inst.Index) !void { } fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const mcv = try self.resolveInst(ty_op.operand); switch (mcv) { @@ -2185,7 +2185,7 @@ fn airPtrSlicePtrPtr(self: *Self, inst: Air.Inst.Index) !void { } fn airRem(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try self.resolveInst(bin_op.lhs); const rhs = try self.resolveInst(bin_op.rhs); const lhs_ty = self.typeOf(bin_op.lhs); @@ -2206,14 +2206,14 @@ fn airRem(self: *Self, inst: Air.Inst.Index) !void { } fn airRet(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); try self.ret(operand); return self.finishAir(inst, .dead, .{ un_op, .none, .none }); } fn airRetLoad(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const ptr = try self.resolveInst(un_op); _ = ptr; return self.fail("TODO implement airRetLoad for {}", .{self.target.cpu.arch}); @@ -2226,14 +2226,14 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void { } fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; _ = bin_op; return self.fail("TODO implement airSetUnionTag for {}", .{self.target.cpu.arch}); } fn airShlSat(self: *Self, inst: Air.Inst.Index) !void { const zcu = self.pt.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else if (self.typeOf(bin_op.lhs).isVector(zcu) and !self.typeOf(bin_op.rhs).isVector(zcu)) @@ -2244,7 +2244,7 @@ fn airShlSat(self: *Self, inst: Air.Inst.Index) !void { } fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Bin, ty_pl.payload).data; const pt = self.pt; const zcu = pt.zcu; @@ -2338,7 +2338,7 @@ fn airShlWithOverflow(self: *Self, inst: Air.Inst.Index) !void { } fn airSlice(self: *Self, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const ptr = try self.resolveInst(bin_op.lhs); @@ -2358,7 +2358,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; const is_volatile = false; // TODO - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; if (!is_volatile and self.liveness.isUnused(inst)) return self.finishAir(inst, .dead, .{ bin_op.lhs, bin_op.rhs, .none }); const result: MCValue = result: { @@ -2400,7 +2400,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void { } fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const ptr_bits = self.target.ptrBitWidth(); const ptr_bytes = @divExact(ptr_bits, 8); @@ -2421,7 +2421,7 @@ fn airSliceLen(self: *Self, inst: Air.Inst.Index) !void { } fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const mcv = try self.resolveInst(ty_op.operand); switch (mcv) { @@ -2440,7 +2440,7 @@ fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void { } fn airSplat(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSplat for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } @@ -2451,7 +2451,7 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void { } else { // TODO if the value is undef, don't lower this instruction } - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr = try self.resolveInst(bin_op.lhs); const value = try self.resolveInst(bin_op.rhs); const ptr_ty = self.typeOf(bin_op.lhs); @@ -2463,20 +2463,20 @@ fn airStore(self: *Self, inst: Air.Inst.Index, safety: bool) !void { } fn airStructFieldPtr(self: *Self, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.StructField, ty_pl.payload).data; const result = try self.structFieldPtr(inst, extra.struct_operand, extra.field_index); return self.finishAir(inst, result, .{ extra.struct_operand, .none, .none }); } fn airStructFieldPtrIndex(self: *Self, inst: Air.Inst.Index, index: u8) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result = try self.structFieldPtr(inst, ty_op.operand, index); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airAggFieldVal(self: *Self, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.StructField, ty_pl.payload).data; const operand = extra.struct_operand; const index = extra.field_index; @@ -2546,7 +2546,7 @@ fn airAggFieldVal(self: *Self, inst: Air.Inst.Index) !void { } fn airSubSat(self: *Self, inst: Air.Inst.Index) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement sub_sat for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none }); } @@ -2557,7 +2557,7 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void { } fn airTagName(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try self.resolveInst(un_op); const result: MCValue = if (self.liveness.isUnused(inst)) .dead else { _ = operand; @@ -2567,7 +2567,7 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void { } fn airTrunc(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try self.resolveInst(ty_op.operand); const operand_ty = self.typeOf(ty_op.operand); const dest_ty = self.typeOfIndex(inst); @@ -2597,7 +2597,7 @@ fn airTry(self: *Self, inst: Air.Inst.Index) !void { } fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else @@ -2606,7 +2606,7 @@ fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void { } fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data; _ = extra; return self.fail("TODO implement airUnionInit for {}", .{self.target.cpu.arch}); @@ -2615,7 +2615,7 @@ fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void { fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const error_union_ty = self.typeOf(ty_op.operand); const payload_ty = error_union_ty.errorUnionPayload(zcu); @@ -2630,7 +2630,7 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void { fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const error_union_ty = self.typeOf(ty_op.operand); const payload_ty = error_union_ty.errorUnionPayload(zcu); @@ -2645,7 +2645,7 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void { fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const error_union_ty = ty_op.ty.toType(); const payload_ty = error_union_ty.errorUnionPayload(zcu); @@ -2659,14 +2659,14 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void { /// T to E!T fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion payload for {}", .{self.target.cpu.arch}); return self.finishAir(inst, result, .{ ty_op.operand, .none, .none }); } fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void { const pt = self.pt; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: { const optional_ty = self.typeOfIndex(inst); @@ -4670,7 +4670,7 @@ fn trunc( defer if (lock) |reg| self.register_manager.unlockReg(reg); const dest_reg = if (maybe_inst) |inst| blk: { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) { break :blk operand_reg; diff --git a/src/codegen/sparc64/bits.zig b/src/codegen/sparc64/bits.zig index d27371bf2505f2c7a4abde9255834f3063e896c2..0e571df4ea85759bc5900207aa0010962debb7fd 100644 --- a/src/codegen/sparc64/bits.zig +++ b/src/codegen/sparc64/bits.zig @@ -15,7 +15,7 @@ pub const Register = enum(u6) { // zig fmt: on pub fn id(reg: Register) u5 { - return @truncate(@intFromEnum(reg)); + return @truncate(@backingInt(reg)); } pub fn enc(reg: Register) u5 { @@ -95,9 +95,9 @@ pub const FloatingPointRegister = enum(u7) { pub fn id(self: FloatingPointRegister) u6 { return switch (self.size()) { - 32 => @as(u6, @truncate(@intFromEnum(self))), - 64 => @as(u6, @truncate((@intFromEnum(self) - 32) * 2)), - 128 => @as(u6, @truncate((@intFromEnum(self) - 64) * 4)), + 32 => @as(u6, @truncate(@backingInt(self))), + 64 => @as(u6, @truncate((@backingInt(self) - 32) * 2)), + 128 => @as(u6, @truncate((@backingInt(self) - 64) * 4)), else => unreachable, }; } @@ -113,7 +113,7 @@ pub const FloatingPointRegister = enum(u7) { /// Returns the bit-width of the register. pub fn size(self: FloatingPointRegister) u8 { - return switch (@intFromEnum(self)) { + return switch (@backingInt(self)) { 0...31 => 32, 32...63 => 64, 64...79 => 128, @@ -695,8 +695,8 @@ pub const Instruction = union(enum) { /// Encodes the condition into the instruction bit pattern. pub fn enc(cond: Condition) u4 { return switch (cond) { - .icond => |c| @intFromEnum(c), - .fcond => |c| @intFromEnum(c), + .icond => |c| @backingInt(c), + .fcond => |c| @backingInt(c), }; } @@ -802,8 +802,8 @@ pub const Instruction = union(enum) { // Discard the last two bits since those are implicitly zero. const udisp_truncated = @as(u19, @truncate(udisp >> 2)); - const ccr_cc1 = @as(u1, @truncate(@intFromEnum(ccr) >> 1)); - const ccr_cc0 = @as(u1, @truncate(@intFromEnum(ccr))); + const ccr_cc1 = @as(u1, @truncate(@backingInt(ccr) >> 1)); + const ccr_cc0 = @as(u1, @truncate(@backingInt(ccr))); return Instruction{ .format_2c = .{ .a = @intFromBool(annul), @@ -831,7 +831,7 @@ pub const Instruction = union(enum) { return Instruction{ .format_2d = .{ .a = @intFromBool(annul), - .rcond = @intFromEnum(rcond), + .rcond = @backingInt(rcond), .op2 = op2, .p = @intFromBool(pt), .rs1 = rs1.enc(), @@ -890,7 +890,7 @@ pub const Instruction = union(enum) { .rd = rd.enc(), .op3 = op3, .rs1 = rs1.enc(), - .rcond = @intFromEnum(rcond), + .rcond = @backingInt(rcond), .rs2 = rs2.enc(), }, }; @@ -902,7 +902,7 @@ pub const Instruction = union(enum) { .rd = rd.enc(), .op3 = op3, .rs1 = rs1.enc(), - .rcond = @intFromEnum(rcond), + .rcond = @backingInt(rcond), .simm10 = @as(u10, @bitCast(imm)), }, }; @@ -933,7 +933,7 @@ pub const Instruction = union(enum) { .rd = rd.enc(), .op3 = op3, .rs1 = rs1.enc(), - .imm_asi = @intFromEnum(asi), + .imm_asi = @backingInt(asi), .rs2 = rs2.enc(), }, }; @@ -955,7 +955,7 @@ pub const Instruction = union(enum) { .rd = rd.enc(), .op3 = op3, .rs1 = rs1.enc(), - .x = @intFromEnum(sw), + .x = @backingInt(sw), .rs2 = rs2.enc(), }, }; @@ -994,8 +994,8 @@ pub const Instruction = union(enum) { }; } fn format3o(op: u2, op3: u6, opf: u9, ccr: CCR, rs1: Register, rs2: Register) Instruction { - const ccr_cc1 = @as(u1, @truncate(@intFromEnum(ccr) >> 1)); - const ccr_cc0 = @as(u1, @truncate(@intFromEnum(ccr))); + const ccr_cc1 = @as(u1, @truncate(@backingInt(ccr) >> 1)); + const ccr_cc0 = @as(u1, @truncate(@backingInt(ccr))); return Instruction{ .format_3o = .{ .op = op, @@ -1050,8 +1050,8 @@ pub const Instruction = union(enum) { } fn format4a(op3: u6, ccr: CCR, rs1: Register, rs2: Register, rd: Register) Instruction { - const ccr_cc1 = @as(u1, @truncate(@intFromEnum(ccr) >> 1)); - const ccr_cc0 = @as(u1, @truncate(@intFromEnum(ccr))); + const ccr_cc1 = @as(u1, @truncate(@backingInt(ccr) >> 1)); + const ccr_cc0 = @as(u1, @truncate(@backingInt(ccr))); return Instruction{ .format_4a = .{ .rd = rd.enc(), @@ -1065,8 +1065,8 @@ pub const Instruction = union(enum) { } fn format4b(op3: u6, ccr: CCR, rs1: Register, imm: i11, rd: Register) Instruction { - const ccr_cc1 = @as(u1, @truncate(@intFromEnum(ccr) >> 1)); - const ccr_cc0 = @as(u1, @truncate(@intFromEnum(ccr))); + const ccr_cc1 = @as(u1, @truncate(@backingInt(ccr) >> 1)); + const ccr_cc0 = @as(u1, @truncate(@backingInt(ccr))); return Instruction{ .format_4b = .{ .rd = rd.enc(), @@ -1080,9 +1080,9 @@ pub const Instruction = union(enum) { } fn format4c(op3: u6, cond: Condition, ccr: CCR, rs2: Register, rd: Register) Instruction { - const ccr_cc2 = @as(u1, @truncate(@intFromEnum(ccr) >> 2)); - const ccr_cc1 = @as(u1, @truncate(@intFromEnum(ccr) >> 1)); - const ccr_cc0 = @as(u1, @truncate(@intFromEnum(ccr))); + const ccr_cc2 = @as(u1, @truncate(@backingInt(ccr) >> 2)); + const ccr_cc1 = @as(u1, @truncate(@backingInt(ccr) >> 1)); + const ccr_cc0 = @as(u1, @truncate(@backingInt(ccr))); return Instruction{ .format_4c = .{ .rd = rd.enc(), @@ -1097,9 +1097,9 @@ pub const Instruction = union(enum) { } fn format4d(op3: u6, cond: Condition, ccr: CCR, imm: i11, rd: Register) Instruction { - const ccr_cc2 = @as(u1, @truncate(@intFromEnum(ccr) >> 2)); - const ccr_cc1 = @as(u1, @truncate(@intFromEnum(ccr) >> 1)); - const ccr_cc0 = @as(u1, @truncate(@intFromEnum(ccr))); + const ccr_cc2 = @as(u1, @truncate(@backingInt(ccr) >> 2)); + const ccr_cc1 = @as(u1, @truncate(@backingInt(ccr) >> 1)); + const ccr_cc0 = @as(u1, @truncate(@backingInt(ccr))); return Instruction{ .format_4d = .{ .rd = rd.enc(), @@ -1114,8 +1114,8 @@ pub const Instruction = union(enum) { } fn format4e(op3: u6, ccr: CCR, rs1: Register, rd: Register, sw_trap: u7) Instruction { - const ccr_cc1 = @as(u1, @truncate(@intFromEnum(ccr) >> 1)); - const ccr_cc0 = @as(u1, @truncate(@intFromEnum(ccr))); + const ccr_cc1 = @as(u1, @truncate(@backingInt(ccr) >> 1)); + const ccr_cc0 = @as(u1, @truncate(@backingInt(ccr))); return Instruction{ .format_4e = .{ .rd = rd.enc(), @@ -1141,7 +1141,7 @@ pub const Instruction = union(enum) { .rd = rd.enc(), .op3 = op3, .rs1 = rs1.enc(), - .rcond = @intFromEnum(rcond), + .rcond = @backingInt(rcond), .opf_low = opf_low, .rs2 = rs2.enc(), }, @@ -1467,8 +1467,8 @@ pub const Instruction = union(enum) { pub fn trap(comptime s2: type, cond: ICondition, ccr: CCR, rs1: Register, rs2: s2) Instruction { // Tcc instructions abuse the rd field to store the conditionals. return switch (s2) { - Register => format4a(0b11_1010, ccr, rs1, rs2, @as(Register, @enumFromInt(@intFromEnum(cond)))), - u7 => format4e(0b11_1010, ccr, rs1, @as(Register, @enumFromInt(@intFromEnum(cond))), rs2), + Register => format4a(0b11_1010, ccr, rs1, rs2, @as(Register, @fromBackingInt(@intCast(@backingInt(cond))))), + u7 => format4e(0b11_1010, ccr, rs1, @as(Register, @fromBackingInt(@intCast(@backingInt(cond)))), rs2), else => unreachable, }; } diff --git a/src/codegen/spirv/Assembler.zig b/src/codegen/spirv/Assembler.zig index 25f848c0f6892907339524e67557749ac9c0d02a..aa80b4257ecc0756a463b58a550155ba56f22d04 100644 --- a/src/codegen/spirv/Assembler.zig +++ b/src/codegen/spirv/Assembler.zig @@ -267,7 +267,7 @@ fn processTypeInstruction(ass: *Assembler) !AsmValue { break :blk result_id; }, .OpTypePointer => blk: { - const storage_class: StorageClass = @enumFromInt(operands[1].value); + const storage_class: StorageClass = @fromBackingInt(@intCast(operands[1].value)); const child_type = try ass.resolveRefId(operands[2].ref_id); const result_id = cg.allocId(); try section.emit(cg.gpa, .OpTypePointer, .{ @@ -290,12 +290,12 @@ fn processTypeInstruction(ass: *Assembler) !AsmValue { try section.emit(gpa, .OpTypeImage, .{ .id_result = result_id, .sampled_type = sampled_type, - .dim = @enumFromInt(operands[2].value), + .dim = @fromBackingInt(@intCast(operands[2].value)), .depth = operands[3].literal32, .arrayed = operands[4].literal32, .ms = operands[5].literal32, .sampled = operands[6].literal32, - .image_format = @enumFromInt(operands[7].value), + .image_format = @fromBackingInt(@intCast(operands[7].value)), }); break :blk result_id; }, @@ -350,7 +350,7 @@ fn processGenericInstruction(ass: *Assembler) !?AsmValue { .OpEntryPoint => unreachable, .OpExecutionMode, .OpExecutionModeId => &cg.sections.execution_modes, .OpVariable => section: { - const storage_class: spec.StorageClass = @enumFromInt(operands[2].value); + const storage_class: spec.StorageClass = @fromBackingInt(@intCast(operands[2].value)); if (storage_class == .function) break :section &ass.cg.prologue; maybe_spv_decl_index = try cg.allocDecl(.global); if (!target.cpu.has(.spirv, .v1_4) and storage_class != .input and storage_class != .output) { @@ -404,7 +404,7 @@ fn processGenericInstruction(ass: *Assembler) !?AsmValue { } const actual_word_count = section.instructions.items.len - first_word; - section.instructions.items[first_word] |= @as(u32, @as(u16, @intCast(actual_word_count))) << 16 | @intFromEnum(ass.inst.opcode); + section.instructions.items[first_word] |= @as(u32, @as(u16, @intCast(actual_word_count))) << 16 | @backingInt(ass.inst.opcode); switch (ass.inst.opcode) { .OpKill, @@ -487,7 +487,7 @@ fn processSpecConstVector(ass: *Assembler) !?AsmValue { }; try annotations.emitRaw(gpa, .OpDecorate, 3); annotations.writeOperand(Id, elem_id); - annotations.writeWord(@intFromEnum(spec.Decoration.spec_id)); + annotations.writeWord(@backingInt(spec.Decoration.spec_id)); annotations.writeWord(spec_id_word); } @@ -561,7 +561,7 @@ fn parseInstruction(ass: *Assembler) !void { }; const inst = spec.InstructionSet.core.instructions()[index]; - ass.inst.opcode = @enumFromInt(inst.opcode); + ass.inst.opcode = @fromBackingInt(@intCast(inst.opcode)); const expected_operands = inst.operands; // This is a loop because the result-id is not always the first operand. @@ -855,16 +855,16 @@ fn parseContextDependentNumber(ass: *Assembler) !void { var offset: usize = 0; while (offset < words.len) { const word_count = words[offset] >> 16; - const opcode: Opcode = @enumFromInt(words[offset] & 0xFFFF); + const opcode: Opcode = @fromBackingInt(@intCast(words[offset] & 0xFFFF)); defer offset += word_count; if (word_count == 0) break; switch (opcode) { - .OpTypeInt => if (word_count >= 4 and @as(Id, @enumFromInt(words[offset + 1])) == result_id) { + .OpTypeInt => if (word_count >= 4 and @as(Id, @fromBackingInt(@intCast(words[offset + 1]))) == result_id) { const width: u16 = @intCast(words[offset + 2]); const signedness: std.lang.Signedness = if (words[offset + 3] == 0) .unsigned else .signed; return ass.parseContextDependentInt(signedness, width); }, - .OpTypeFloat => if (word_count >= 3 and @as(Id, @enumFromInt(words[offset + 1])) == result_id) { + .OpTypeFloat => if (word_count >= 3 and @as(Id, @fromBackingInt(@intCast(words[offset + 1]))) == result_id) { const bits = words[offset + 2]; return switch (bits) { 16 => ass.parseContextDependentFloat(16), diff --git a/src/codegen/spirv/CodeGen.zig b/src/codegen/spirv/CodeGen.zig index d6b82ea773dc8ccf41dd9aa38794197cd255a573..7833c787e039be9d0002886293000ed5424203f6 100644 --- a/src/codegen/spirv/CodeGen.zig +++ b/src/codegen/spirv/CodeGen.zig @@ -432,11 +432,11 @@ pub fn addEntryPointDeps( const decl = cg.declPtr(decl_index); const deps = cg.decl_deps.items[decl.begin_dep..decl.end_dep]; - if (seen.isSet(@intFromEnum(decl_index))) { + if (seen.isSet(@backingInt(decl_index))) { return; } - seen.set(@intFromEnum(decl_index)); + seen.set(@backingInt(decl_index)); if (decl.kind == .global) { try interface.append(cg.gpa, decl.result_id); @@ -778,11 +778,11 @@ pub fn allocDecl(cg: *CodeGen, kind: Decl.Kind) !Decl.Index { .result_id = cg.allocId(), }); - return @as(Decl.Index, @enumFromInt(@as(u32, @intCast(cg.decls.items.len - 1)))); + return @as(Decl.Index, @fromBackingInt(@intCast(@as(u32, @intCast(cg.decls.items.len - 1))))); } pub fn declPtr(cg: *CodeGen, index: Decl.Index) *Decl { - return &cg.decls.items[@intFromEnum(index)]; + return &cg.decls.items[@backingInt(index)]; } pub fn debugName(cg: *CodeGen, target: Id, name: []const u8) !void { @@ -1054,7 +1054,7 @@ pub fn genNav(cg: *CodeGen, do_codegen: bool) Error!void { .id_result_type = ptr_ty_id, .id_result = result_id, .set = try cg.importInstructionSet(.zig), - .instruction = .{ .inst = @intFromEnum(spec.Zig.InvocationGlobal) }, + .instruction = .{ .inst = @backingInt(spec.Zig.InvocationGlobal) }, .id_ref_4 = &.{initializer_id}, }); }, @@ -1269,14 +1269,14 @@ fn resolveUav(cg: *CodeGen, val: InternPool.Index) !Id { try cg.sections.functions.append(gpa, cg.prologue); try cg.sections.functions.append(gpa, cg.body); - try cg.debugNameFmt(initializer_id, "initializer of __anon_{d}", .{@intFromEnum(val)}); + try cg.debugNameFmt(initializer_id, "initializer of __anon_{d}", .{@backingInt(val)}); const fn_decl_ptr_ty_id = try cg.ptrType(ty_id, .function); try cg.sections.globals.emit(gpa, .OpExtInst, .{ .id_result_type = fn_decl_ptr_ty_id, .id_result = result_id, .set = try cg.importInstructionSet(.zig), - .instruction = .{ .inst = @intFromEnum(spec.Zig.InvocationGlobal) }, + .instruction = .{ .inst = @backingInt(spec.Zig.InvocationGlobal) }, .id_ref_4 = &.{initializer_id}, }); } @@ -2760,7 +2760,7 @@ const Temporary = struct { // If the value is a scalar, then this is a no-op. if (!temp.ty.isVector(zcu)) { return switch (temp.value) { - .singleton => |id| .{ .base = @intFromEnum(id), .len = 1 }, + .singleton => |id| .{ .base = @backingInt(id), .len = 1 }, .exploded_vector => |range| range, }; } @@ -3367,7 +3367,7 @@ const CompositeInt = struct { .id_result_type = limb_ty_id, .id_result = hi, .set = set, - .instruction = .{ .inst = @intFromEnum(spec.OpenClOpcode.u_mul_hi) }, + .instruction = .{ .inst = @backingInt(spec.OpenClOpcode.u_mul_hi) }, .id_ref_4 = &.{ ci.limbs[i], other.limbs[j] }, }); }, @@ -3805,7 +3805,7 @@ const UnaryOp = enum { pub fn extInstOpcode(op: UnaryOp, target: *const std.Target) ?u32 { return switch (target.os.tag) { - .opencl => @intFromEnum(@as(spec.OpenClOpcode, switch (op) { + .opencl => @backingInt(@as(spec.OpenClOpcode, switch (op) { .i_abs => .s_abs, .f_abs => .fabs, .clz => .clz, @@ -3828,7 +3828,7 @@ const UnaryOp = enum { // Note: We'll need to check these for floating point accuracy // Vulkan does not put tight requirements on these, for correction // we might want to emulate them at some point. - .vulkan, .opengl => @intFromEnum(@as(spec.GlslOpcode, switch (op) { + .vulkan, .opengl => @backingInt(@as(spec.GlslOpcode, switch (op) { .i_abs => .SAbs, .f_abs => .FAbs, .floor => .Floor, @@ -3970,7 +3970,7 @@ fn buildWideMul( .id_result_type = arith_op_ty_id, .id_result = overflow_results.at(i), .set = set, - .instruction = .{ .inst = @intFromEnum(overflow_inst) }, + .instruction = .{ .inst = @backingInt(overflow_inst) }, .id_ref_4 = &.{ lhs_op.at(i), rhs_op.at(i) }, }); } @@ -4355,7 +4355,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) Error!void { return; const air_tags = cg.air.instructions.items(.tag); - const maybe_result_id: ?Id = switch (air_tags[@intFromEnum(inst)]) { + const maybe_result_id: ?Id = switch (air_tags[@backingInt(inst)]) { // zig fmt: off .add, .add_wrap, .add_optimized => try cg.airArithOp(inst, .OpFAdd, .OpIAdd, .OpIAdd), .sub, .sub_wrap, .sub_optimized => try cg.airArithOp(inst, .OpFSub, .OpISub, .OpISub), @@ -4535,7 +4535,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) Error!void { } fn airBinOpSimple(cg: *CodeGen, inst: Air.Inst.Index, op: Opcode) !?Id { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.temporary(bin_op.lhs); const rhs = try cg.temporary(bin_op.rhs); @@ -4546,7 +4546,7 @@ fn airBinOpSimple(cg: *CodeGen, inst: Air.Inst.Index, op: Opcode) !?Id { const BitwiseOp = enum { bit_and, bit_or, xor }; fn airBitwiseOp(cg: *CodeGen, inst: Air.Inst.Index, op: BitwiseOp) !?Id { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.temporary(bin_op.lhs); const rhs = try cg.temporary(bin_op.rhs); const info = cg.arithmeticTypeInfo(lhs.ty); @@ -4587,7 +4587,7 @@ fn airBitwiseOp(cg: *CodeGen, inst: Air.Inst.Index, op: BitwiseOp) !?Id { fn airShift(cg: *CodeGen, inst: Air.Inst.Index, unsigned: Opcode, signed: Opcode) !?Id { const zcu = cg.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const base = try cg.temporary(bin_op.lhs); const shift = try cg.temporary(bin_op.rhs); @@ -4661,7 +4661,7 @@ const MinMax = enum { info: ArithmeticTypeInfo, ) u32 { return switch (target.os.tag) { - .opencl => @intFromEnum(@as(spec.OpenClOpcode, switch (info.class) { + .opencl => @backingInt(@as(spec.OpenClOpcode, switch (info.class) { .float => switch (op) { .min => .fmin, .max => .fmax, @@ -4678,7 +4678,7 @@ const MinMax = enum { }, .bool => unreachable, })), - .vulkan, .opengl => @intFromEnum(@as(spec.GlslOpcode, switch (info.class) { + .vulkan, .opengl => @backingInt(@as(spec.GlslOpcode, switch (info.class) { .float => switch (op) { .min => .FMin, .max => .FMax, @@ -4701,7 +4701,7 @@ const MinMax = enum { }; fn airMinMax(cg: *CodeGen, inst: Air.Inst.Index, op: MinMax) !?Id { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.temporary(bin_op.lhs); const rhs = try cg.temporary(bin_op.rhs); @@ -4781,7 +4781,7 @@ fn normalize(cg: *CodeGen, value: Temporary, info: ArithmeticTypeInfo) !Temporar } fn airDivFloor(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.temporary(bin_op.lhs); const rhs = try cg.temporary(bin_op.rhs); @@ -4822,7 +4822,7 @@ fn airDivFloor(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airDivTrunc(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.temporary(bin_op.lhs); const rhs = try cg.temporary(bin_op.rhs); const info = cg.arithmeticTypeInfo(lhs.ty); @@ -4848,7 +4848,7 @@ fn airDivTrunc(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airUnOpSimple(cg: *CodeGen, inst: Air.Inst.Index, op: UnaryOp) !?Id { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.temporary(un_op); const result = try cg.buildUnary(op, operand); return try result.materialize(cg); @@ -4861,7 +4861,7 @@ fn airArithOp( comptime sop: Opcode, comptime uop: Opcode, ) !?Id { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.temporary(bin_op.lhs); const rhs = try cg.temporary(bin_op.rhs); const info = cg.arithmeticTypeInfo(lhs.ty); @@ -4898,7 +4898,7 @@ fn airArithOp( fn airAbs(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; const target = zcu.getTarget(); - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const value = try cg.temporary(ty_op.operand); // Note: operand_ty may be signed, while ty is always unsigned. const result_ty = cg.typeOfIndex(inst); @@ -4970,7 +4970,7 @@ fn airAddSubOverflow( _ = s_opcode; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try cg.temporary(extra.lhs); const rhs = try cg.temporary(extra.rhs); @@ -5087,7 +5087,7 @@ fn airAddSubOverflow( fn airMulOverflow(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const pt = cg.pt; const gpa = cg.gpa; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try cg.temporary(extra.lhs); const rhs = try cg.temporary(extra.rhs); @@ -5416,7 +5416,7 @@ fn airMulOverflow(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airShlOverflow(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.Bin, ty_pl.payload).data; const base = try cg.temporary(extra.lhs); @@ -5451,7 +5451,7 @@ fn airShlOverflow(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airMulAdd(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = cg.air.extraData(Air.Bin, pl_op.payload).data; const a = try cg.temporary(extra.lhs); @@ -5479,10 +5479,10 @@ fn airMulAdd(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const set = try cg.importExtendedSet(); const opcode: u32 = switch (target.os.tag) { - .opencl => @intFromEnum(spec.OpenClOpcode.fma), + .opencl => @backingInt(spec.OpenClOpcode.fma), // NOTE: Vulkan's FMA does not meet Zig's nor OpenCL's precision guarantees and needs // to be emulated. - .vulkan, .opengl => @intFromEnum(spec.GlslOpcode.Fma), + .vulkan, .opengl => @backingInt(spec.GlslOpcode.Fma), else => unreachable, }; @@ -5504,7 +5504,7 @@ fn airClzCtz(cg: *CodeGen, inst: Air.Inst.Index, op: UnaryOp) !?Id { if (cg.liveness.isUnused(inst)) return null; const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.temporary(ty_op.operand); const scalar_result_ty = cg.typeOfIndex(inst).scalarType(zcu); @@ -5526,7 +5526,7 @@ fn airClzCtz(cg: *CodeGen, inst: Air.Inst.Index, op: UnaryOp) !?Id { } fn airSelect(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = cg.air.extraData(Air.Bin, pl_op.payload).data; const pred = try cg.temporary(pl_op.operand); const a = try cg.temporary(extra.lhs); @@ -5537,7 +5537,7 @@ fn airSelect(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_id = try cg.resolve(ty_op.operand); const result_ty = cg.typeOfIndex(inst); @@ -5547,7 +5547,7 @@ fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airReduce(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const reduce = cg.air.instructions.items(.data)[@intFromEnum(inst)].reduce; + const reduce = cg.air.instructions.items(.data)[@backingInt(inst)].reduce; const operand = try cg.resolve(reduce.operand); const operand_ty = cg.typeOf(reduce.operand); const scalar_ty = operand_ty.scalarType(zcu); @@ -5763,7 +5763,7 @@ fn ptrAdd(cg: *CodeGen, result_ty: Type, ptr_ty: Type, ptr_id: Id, offset_id: Id } fn airPtrAdd(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_id = try cg.resolve(bin_op.lhs); const offset_id = try cg.resolve(bin_op.rhs); @@ -5774,7 +5774,7 @@ fn airPtrAdd(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airPtrSub(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_id = try cg.resolve(bin_op.lhs); const ptr_ty = cg.typeOf(bin_op.lhs); @@ -5979,7 +5979,7 @@ fn airCmp( inst: Air.Inst.Index, comptime op: std.math.CompareOperator, ) !?Id { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.temporary(bin_op.lhs); const rhs = try cg.temporary(bin_op.rhs); @@ -5988,7 +5988,7 @@ fn airCmp( } fn airVectorCmp(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const vec_cmp = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; const lhs = try cg.temporary(vec_cmp.lhs); const rhs = try cg.temporary(vec_cmp.rhs); @@ -6126,7 +6126,7 @@ fn bitCast( } fn airBitCast(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = cg.typeOf(ty_op.operand); const result_ty = cg.typeOfIndex(inst); if (operand_ty.toIntern() == .bool_type) { @@ -6145,7 +6145,7 @@ fn airBitCast(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airIntCast(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const src = try cg.temporary(ty_op.operand); const dst_ty = cg.typeOfIndex(inst); @@ -6391,7 +6391,7 @@ fn intFromPtr(cg: *CodeGen, operand_id: Id) !Id { fn airFloatFromInt(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const gpa = cg.gpa; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = cg.typeOf(ty_op.operand); const operand_id = try cg.resolve(ty_op.operand); const result_ty = cg.typeOfIndex(inst); @@ -6415,7 +6415,7 @@ fn airFloatFromInt(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airIntFromFloat(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const gpa = cg.gpa; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_id = try cg.resolve(ty_op.operand); const result_ty = cg.typeOfIndex(inst); const result_info = cg.arithmeticTypeInfo(result_ty); @@ -6437,7 +6437,7 @@ fn airIntFromFloat(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airFloatCast(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.temporary(ty_op.operand); const dest_ty = cg.typeOfIndex(inst); const result = try cg.buildConvert(dest_ty, operand); @@ -6445,7 +6445,7 @@ fn airFloatCast(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airNot(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.temporary(ty_op.operand); const result_ty = cg.typeOfIndex(inst); const info = cg.arithmeticTypeInfo(result_ty); @@ -6473,7 +6473,7 @@ fn airNot(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const array_ptr_ty = cg.typeOf(ty_op.operand); const array_ty = array_ptr_ty.childType(zcu); const slice_ty = cg.typeOfIndex(inst); @@ -6496,7 +6496,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airSlice(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_id = try cg.resolve(bin_op.lhs); const len_id = try cg.resolve(bin_op.rhs); @@ -6511,7 +6511,7 @@ fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; const ip = &zcu.intern_pool; const target = cg.zcu.getTarget(); - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const result_ty = cg.typeOfIndex(inst); const len: usize = @intCast(result_ty.arrayLen(zcu)); const elements: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[ty_pl.payload..][0..len]); @@ -6645,7 +6645,7 @@ fn sliceOrArrayPtr(cg: *CodeGen, operand_id: Id, ty: Type) !Id { } fn airMemcpy(cg: *CodeGen, inst: Air.Inst.Index) !void { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dest_slice = try cg.resolve(bin_op.lhs); const src_slice = try cg.resolve(bin_op.rhs); const dest_ty = cg.typeOf(bin_op.lhs); @@ -6675,7 +6675,7 @@ fn airMemmove(cg: *CodeGen, inst: Air.Inst.Index) !void { } fn airSliceField(cg: *CodeGen, inst: Air.Inst.Index, field: u32) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const field_ty = cg.typeOfIndex(inst); const operand_id = try cg.resolve(ty_op.operand); return try cg.extractField(field_ty, operand_id, field); @@ -6683,7 +6683,7 @@ fn airSliceField(cg: *CodeGen, inst: Air.Inst.Index, field: u32) !?Id { fn airSpirvRuntimeArrayLen(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const gpa = cg.gpa; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.StructField, ty_pl.payload).data; const struct_ptr_id = try cg.resolve(extra.struct_operand); const u32_ty_id = try cg.intType(.unsigned, 32); @@ -6699,7 +6699,7 @@ fn airSpirvRuntimeArrayLen(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airSliceElemPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const slice_ty = cg.typeOf(bin_op.lhs); if (!slice_ty.isVolatilePtr(zcu) and cg.liveness.isUnused(inst)) return null; @@ -6716,7 +6716,7 @@ fn airSliceElemPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const slice_ty = cg.typeOf(bin_op.lhs); if (!slice_ty.isVolatilePtr(zcu) and cg.liveness.isUnused(inst)) return null; @@ -6749,7 +6749,7 @@ fn ptrElemPtr(cg: *CodeGen, ptr_ty: Type, ptr_id: Id, index_id: Id) !Id { fn airPtrElemPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const src_ptr_ty = cg.typeOf(bin_op.lhs); const elem_ty = src_ptr_ty.childType(zcu); @@ -6764,7 +6764,7 @@ fn airPtrElemPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airArrayElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const gpa = cg.gpa; const zcu = cg.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const array_ty = cg.typeOf(bin_op.lhs); const elem_ty = array_ty.childType(zcu); const array_id = try cg.resolve(bin_op.lhs); @@ -6815,7 +6815,7 @@ fn airArrayElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airPtrElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = cg.typeOf(bin_op.lhs); const elem_ty = cg.typeOfIndex(inst); const ptr_id = try cg.resolve(bin_op.lhs); @@ -6826,7 +6826,7 @@ fn airPtrElemVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airSetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) !void { const zcu = cg.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const un_ptr_ty = cg.typeOf(bin_op.lhs); const un_ty = un_ptr_ty.childType(zcu); const layout = cg.unionLayout(un_ty); @@ -6849,7 +6849,7 @@ fn airSetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) !void { } fn airGetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const un_ty = cg.typeOf(ty_op.operand); const zcu = cg.zcu; @@ -6937,7 +6937,7 @@ fn unionInit( fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; const ip = &zcu.intern_pool; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; const ty = cg.typeOfIndex(inst); @@ -6953,7 +6953,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airAggFieldVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const pt = cg.pt; const zcu = cg.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; const object_ty = cg.typeOf(struct_field.struct_operand); @@ -7058,7 +7058,7 @@ fn airAggFieldVal(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airFieldParentPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; const target = zcu.getTarget(); - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; const parent_ptr_ty = ty_pl.ty.toType(); @@ -7190,7 +7190,7 @@ fn structFieldPtr( } fn airStructFieldPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; const struct_ptr = try cg.resolve(struct_field.struct_operand); const struct_ptr_ty = cg.typeOf(struct_field.struct_operand); @@ -7199,7 +7199,7 @@ fn airStructFieldPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airStructFieldPtrIndex(cg: *CodeGen, inst: Air.Inst.Index, field_index: u32) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const struct_ptr = try cg.resolve(ty_op.operand); const struct_ptr_ty = cg.typeOf(ty_op.operand); const result_ptr_ty = cg.typeOfIndex(inst); @@ -7437,7 +7437,7 @@ fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) assert(cg.block_stack.items.len > 0); // Check if the target of the branch was this current block. - const this_block = try cg.constInt(.u32, @intFromEnum(inst)); + const this_block = try cg.constInt(.u32, @backingInt(inst)); const jump_to_this_block_id = cg.allocId(); const bool_ty_id = try cg.resolveType(.bool, .direct); try cg.body.emit(gpa, .OpIEqual, .{ @@ -7506,7 +7506,7 @@ fn lowerBlock(cg: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) fn airBr(cg: *CodeGen, inst: Air.Inst.Index) !void { const zcu = cg.zcu; - const br = cg.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = cg.air.instructions.items(.data)[@backingInt(inst)].br; const operand_ty = cg.typeOf(br.operand); if (operand_ty.hasRuntimeBits(zcu)) { @@ -7515,7 +7515,7 @@ fn airBr(cg: *CodeGen, inst: Air.Inst.Index) !void { try cg.store(operand_ty, block_result_var_id, operand_id, .{}); } - const next_block = try cg.constInt(.u32, @intFromEnum(br.block_inst)); + const next_block = try cg.constInt(.u32, @backingInt(br.block_inst)); try cg.structuredBreak(next_block); } @@ -7611,7 +7611,7 @@ fn airLoop(cg: *CodeGen, inst: Air.Inst.Index) !void { fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; const pt = cg.pt; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const ptr_ty = cg.typeOf(ty_op.operand); const ptr_info = ptr_ty.ptrInfo(zcu); const elem_ty = cg.typeOfIndex(inst); @@ -7655,7 +7655,7 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) !?Id { try cg.resolveType(elem_ty, .indirect), cg.storageClass(ptr_info.flags.address_space), ); - break :ptr_id try cg.accessChain(elem_ptr_ty_id, operand_ptr_id, &.{@intFromEnum(index)}); + break :ptr_id try cg.accessChain(elem_ptr_ty_id, operand_ptr_id, &.{@backingInt(index)}); }, }; return try cg.load(elem_ty, ptr_id, .{ @@ -7667,7 +7667,7 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airStore(cg: *CodeGen, inst: Air.Inst.Index) !void { const zcu = cg.zcu; const pt = cg.pt; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = cg.typeOf(bin_op.lhs); const ptr_info = ptr_ty.ptrInfo(zcu); const elem_ty: Type = .fromInterned(ptr_info.child); @@ -7729,7 +7729,7 @@ fn airStore(cg: *CodeGen, inst: Air.Inst.Index) !void { try cg.resolveType(elem_ty, .indirect), cg.storageClass(ptr_info.flags.address_space), ); - break :ptr_id try cg.accessChain(elem_ptr_ty_id, operand_ptr_id, &.{@intFromEnum(index)}); + break :ptr_id try cg.accessChain(elem_ptr_ty_id, operand_ptr_id, &.{@backingInt(index)}); }, }; @@ -7742,7 +7742,7 @@ fn airStore(cg: *CodeGen, inst: Air.Inst.Index) !void { fn airRet(cg: *CodeGen, inst: Air.Inst.Index) !void { const gpa = cg.gpa; const zcu = cg.zcu; - const operand = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const operand = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const ret_ty = cg.typeOf(operand); if (!ret_ty.hasRuntimeBits(zcu)) { const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?; @@ -7764,7 +7764,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index) !void { fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) !void { const gpa = cg.gpa; const zcu = cg.zcu; - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const ptr_ty = cg.typeOf(un_op); const ret_ty = ptr_ty.childType(zcu); @@ -7856,7 +7856,7 @@ fn airTry(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_id = try cg.resolve(ty_op.operand); const err_union_ty = cg.typeOf(ty_op.operand); const err_ty_id = try cg.resolveType(.anyerror, .direct); @@ -7878,7 +7878,7 @@ fn airErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_id = try cg.resolve(ty_op.operand); const payload_ty = cg.typeOfIndex(inst); const eu_layout = cg.errorUnionLayout(payload_ty); @@ -7892,7 +7892,7 @@ fn airErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const err_union_ty = cg.typeOfIndex(inst); const payload_ty = err_union_ty.errorUnionPayload(zcu); const operand_id = try cg.resolve(ty_op.operand); @@ -7917,7 +7917,7 @@ fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airWrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) !?Id { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const err_union_ty = cg.typeOfIndex(inst); const operand_id = try cg.resolve(ty_op.operand); const payload_ty = cg.typeOf(ty_op.operand); @@ -7941,7 +7941,7 @@ fn airWrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum { is_null, is_non_null }) !?Id { const zcu = cg.zcu; - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand_id = try cg.resolve(un_op); const operand_ty = cg.typeOf(un_op); const optional_ty = if (is_pointer) operand_ty.childType(zcu) else operand_ty; @@ -8018,7 +8018,7 @@ fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum { fn airIsErr(cg: *CodeGen, inst: Air.Inst.Index, pred: enum { is_err, is_non_err }) !?Id { const zcu = cg.zcu; - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand_id = try cg.resolve(un_op); const err_union_ty = cg.typeOf(un_op); @@ -8056,7 +8056,7 @@ fn airIsErr(cg: *CodeGen, inst: Air.Inst.Index, pred: enum { is_err, is_non_err fn airUnwrapOptional(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_id = try cg.resolve(ty_op.operand); const optional_ty = cg.typeOf(ty_op.operand); const payload_ty = cg.typeOfIndex(inst); @@ -8072,7 +8072,7 @@ fn airUnwrapOptional(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airUnwrapOptionalPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_id = try cg.resolve(ty_op.operand); const operand_ty = cg.typeOf(ty_op.operand); const optional_ty = operand_ty.childType(zcu); @@ -8096,7 +8096,7 @@ fn airUnwrapOptionalPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airSetOptionalPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const ptr_ty = cg.typeOf(ty_op.operand); const ptr_id = try cg.resolve(ty_op.operand); @@ -8129,7 +8129,7 @@ fn airSetOptionalPtr(cg: *CodeGen, inst: Air.Inst.Index) !?Id { fn airWrapOptional(cg: *CodeGen, inst: Air.Inst.Index) !?Id { const zcu = cg.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const payload_ty = cg.typeOf(ty_op.operand); assert(payload_ty.hasRuntimeBits(zcu)); @@ -8424,7 +8424,7 @@ fn airLoopSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void { // switch_dispatch signals "continue the loop" by using this sentinel as the // next_block in structuredBreak. at switch_merge, a phi + comparison distinguishes // dispatch (continue) from break (exit) - const dispatch_sentinel = try cg.constInt(.u32, @intFromEnum(inst)); + const dispatch_sentinel = try cg.constInt(.u32, @backingInt(inst)); try cg.loop_switches.putNoClobber(gpa, inst, .{ .cond_var = cond_var, @@ -8627,7 +8627,7 @@ fn airLoopSwitchBr(cg: *CodeGen, inst: Air.Inst.Index) !void { } fn airSwitchDispatch(cg: *CodeGen, inst: Air.Inst.Index) !void { - const br = cg.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = cg.air.instructions.items(.data)[@backingInt(inst)].br; const loop_switch = cg.loop_switches.get(br.block_inst).?; const cond_ty = cg.typeOf(br.operand); const operand = try cg.resolve(br.operand); @@ -8643,7 +8643,7 @@ fn airUnreach(cg: *CodeGen) !void { fn airDbgStmt(cg: *CodeGen, inst: Air.Inst.Index) !void { const zcu = cg.zcu; - const dbg_stmt = cg.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = cg.air.instructions.items(.data)[@backingInt(inst)].dbg_stmt; const path = zcu.navFileScope(cg.owner_nav).sub_file_path; if (zcu.comp.config.root_strip) return; @@ -8670,12 +8670,12 @@ fn airDbgInlineBlock(cg: *CodeGen, inst: Air.Inst.Index) !?Id { } fn airDbgVar(cg: *CodeGen, inst: Air.Inst.Index) !void { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const target_id = switch (try cg.resolvePtr(pl_op.operand)) { .tracked => return, .id => |id| id, }; - const name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); try cg.debugName(target_id, name.toSlice(cg.air)); } @@ -8944,7 +8944,7 @@ fn builtin3D( fn airWorkItemId(cg: *CodeGen, inst: Air.Inst.Index) !?Id { if (cg.liveness.isUnused(inst)) return null; - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const dimension = pl_op.payload; return try cg.builtin3D(.u32, .local_invocation_id, dimension, 0); } @@ -8952,14 +8952,14 @@ fn airWorkItemId(cg: *CodeGen, inst: Air.Inst.Index) !?Id { // TODO: this must be an OpConstant/OpSpec but even then the driver crashes. fn airWorkGroupSize(cg: *CodeGen, inst: Air.Inst.Index) !?Id { if (cg.liveness.isUnused(inst)) return null; - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const dimension = pl_op.payload; return try cg.builtin3D(.u32, .workgroup_size, dimension, 0); } fn airWorkGroupId(cg: *CodeGen, inst: Air.Inst.Index) !?Id { if (cg.liveness.isUnused(inst)) return null; - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const dimension = pl_op.payload; return try cg.builtin3D(.u32, .workgroup_id, dimension, 0); } diff --git a/src/codegen/spirv/Section.zig b/src/codegen/spirv/Section.zig index db338f77db57347d662a20d4c525f61f1b2c18ab..6207cc787cd0c187c8199fc54efd7c9aaf451efc 100644 --- a/src/codegen/spirv/Section.zig +++ b/src/codegen/spirv/Section.zig @@ -50,7 +50,7 @@ pub fn emitRaw( ) !void { const word_count = 1 + operand_words; try section.instructions.ensureUnusedCapacity(allocator, word_count); - section.writeWord((@as(Word, @intCast(word_count << 16))) | @intFromEnum(opcode)); + section.writeWord((@as(Word, @intCast(word_count << 16))) | @backingInt(opcode)); } /// Write an entire instruction, including all operands @@ -70,7 +70,7 @@ pub fn emitAssumeCapacity( operands: opcode.Operands(), ) !void { const word_count = instructionSize(opcode, operands); - section.writeWord(@as(Word, @intCast(word_count << 16)) | @intFromEnum(opcode)); + section.writeWord(@as(Word, @intCast(word_count << 16)) | @backingInt(opcode)); section.writeOperands(opcode.Operands(), operands); } @@ -82,7 +82,7 @@ pub fn emit( ) !void { const word_count = instructionSize(opcode, operands); try section.instructions.ensureUnusedCapacity(allocator, word_count); - section.writeWord(@as(Word, @intCast(word_count << 16)) | @intFromEnum(opcode)); + section.writeWord(@as(Word, @intCast(word_count << 16)) | @backingInt(opcode)); section.writeOperands(opcode.Operands(), operands); } @@ -115,16 +115,16 @@ fn writeOperands(section: *Section, comptime Operands: type, operands: Operands) pub fn writeOperand(section: *Section, comptime Operand: type, operand: Operand) void { switch (Operand) { spec.LiteralSpecConstantOpInteger => unreachable, - spec.Id => section.writeWord(@intFromEnum(operand)), + spec.Id => section.writeWord(@backingInt(operand)), spec.LiteralInteger => section.writeWord(operand), spec.LiteralString => section.writeString(operand), spec.LiteralContextDependentNumber => section.writeContextDependentNumber(operand), spec.LiteralExtInstInteger => section.writeWord(operand.inst), - spec.PairLiteralIntegerIdRef => section.writeWords(&.{ operand.value, @enumFromInt(operand.label) }), - spec.PairIdRefLiteralInteger => section.writeWords(&.{ @intFromEnum(operand.target), operand.member }), - spec.PairIdRefIdRef => section.writeWords(&.{ @intFromEnum(operand[0]), @intFromEnum(operand[1]) }), + spec.PairLiteralIntegerIdRef => section.writeWords(&.{ operand.value, @fromBackingInt(@intCast(operand.label)) }), + spec.PairIdRefLiteralInteger => section.writeWords(&.{ @backingInt(operand.target), operand.member }), + spec.PairIdRefIdRef => section.writeWords(&.{ @backingInt(operand[0]), @backingInt(operand[1]) }), else => switch (@typeInfo(Operand)) { - .@"enum" => section.writeWord(@intFromEnum(operand)), + .@"enum" => section.writeWord(@backingInt(operand)), .optional => |info| if (operand) |child| section.writeOperand(info.child, child), .pointer => |info| { std.debug.assert(info.size == .slice); // Should be no other pointer types in the spec. @@ -200,7 +200,7 @@ fn writeExtendedMask(section: *Section, comptime Operand: type, operand: Operand fn writeExtendedUnion(section: *Section, comptime Operand: type, operand: Operand) void { return switch (operand) { inline else => |op, tag| { - section.writeWord(@intFromEnum(tag)); + section.writeWord(@backingInt(tag)); section.writeOperands( @FieldType(Operand, @tagName(tag)), op, diff --git a/src/codegen/spirv/spec.zig b/src/codegen/spirv/spec.zig index 415a2ae706c2ab2fecdb92b132930a92271961d3..8f2733a92e6c169325d7e41ef0a166b21b46bee2 100644 --- a/src/codegen/spirv/spec.zig +++ b/src/codegen/spirv/spec.zig @@ -21,7 +21,7 @@ pub const Id = enum(Word) { pub fn format(self: Id, writer: *std.Io.Writer) std.Io.Writer.Error!void { switch (self) { .none => try writer.writeAll("(none)"), - else => try writer.print("%{d}", .{@intFromEnum(self)}), + else => try writer.print("%{d}", .{@backingInt(self)}), } } }; @@ -32,7 +32,7 @@ pub const IdRange = struct { pub fn at(range: IdRange, i: usize) Id { std.debug.assert(i < range.len); - return @enumFromInt(range.base + i); + return @fromBackingInt(@intCast(range.base + i)); } }; diff --git a/src/codegen/wasm/CodeGen.zig b/src/codegen/wasm/CodeGen.zig index 644beb2b7192f24f87b19c7dbc04f9216363fec4..e0e73040cab9dedecaaca4c4f843e647e87edcd5 100644 --- a/src/codegen/wasm/CodeGen.zig +++ b/src/codegen/wasm/CodeGen.zig @@ -482,7 +482,7 @@ fn processDeath(cg: *CodeGen, ref: Air.Inst.Ref) void { if (value.local.value < reserved_indexes) { return; // function arguments can never be re-used } - log.debug("Decreasing reference for ref: %{d}, using local '{d}'", .{ @intFromEnum(ref.toIndex().?), value.local.value }); + log.debug("Decreasing reference for ref: %{d}, using local '{d}'", .{ @backingInt(ref.toIndex().?), value.local.value }); value.local.references -= 1; // if this panics, a call to `reuseOperand` was forgotten by the developer if (value.local.references == 0) { value.free(cg); @@ -499,7 +499,7 @@ pub fn addTag(cg: *CodeGen, tag: Mir.Inst.Tag) error{OutOfMemory}!void { pub fn addExtended(cg: *CodeGen, opcode: std.wasm.MiscOpcode) error{OutOfMemory}!void { const extra_index: u32 = @intCast(cg.mir_extra.items.len); - try cg.mir_extra.append(cg.gpa, @intFromEnum(opcode)); + try cg.mir_extra.append(cg.gpa, @backingInt(opcode)); try cg.addInst(.{ .tag = .misc_prefix, .data = .{ .payload = extra_index } }); } @@ -532,7 +532,7 @@ pub fn addImm128(cg: *CodeGen, index: u32) error{OutOfMemory}!void { const extra_index: u32 = @intCast(cg.mir_extra.items.len); // tag + 128bit value try cg.mir_extra.ensureUnusedCapacity(cg.gpa, 5); - cg.mir_extra.appendAssumeCapacity(@intFromEnum(std.wasm.SimdOpcode.v128_const)); + cg.mir_extra.appendAssumeCapacity(@backingInt(std.wasm.SimdOpcode.v128_const)); cg.mir_extra.appendSliceAssumeCapacity(@alignCast(mem.bytesAsSlice(u32, &simd_values))); try cg.addInst(.{ .tag = .simd_prefix, .data = .{ .payload = extra_index } }); } @@ -555,14 +555,14 @@ pub fn addMemArg(cg: *CodeGen, tag: Mir.Inst.Tag, mem_arg: Mir.MemArg) error{Out /// Inserts an instruction from the 'atomics' feature which accesses wasm's linear memory dependent on the /// given `tag`. pub fn addAtomicMemArg(cg: *CodeGen, tag: std.wasm.AtomicsOpcode, mem_arg: Mir.MemArg) error{OutOfMemory}!void { - const extra_index = try cg.addExtra(@as(struct { val: u32 }, .{ .val = @intFromEnum(tag) })); + const extra_index = try cg.addExtra(@as(struct { val: u32 }, .{ .val = @backingInt(tag) })); _ = try cg.addExtra(mem_arg); try cg.addInst(.{ .tag = .atomics_prefix, .data = .{ .payload = extra_index } }); } /// Helper function to emit atomic mir opcodes. pub fn addAtomicTag(cg: *CodeGen, tag: std.wasm.AtomicsOpcode) error{OutOfMemory}!void { - const extra_index = try cg.addExtra(@as(struct { val: u32 }, .{ .val = @intFromEnum(tag) })); + const extra_index = try cg.addExtra(@as(struct { val: u32 }, .{ .val = @backingInt(tag) })); try cg.addInst(.{ .tag = .atomics_prefix, .data = .{ .payload = extra_index } }); } @@ -589,7 +589,7 @@ fn addExtraAssumeCapacity(cg: *CodeGen, extra: anytype) error{OutOfMemory}!u32 { i32 => @bitCast(@field(extra, field_name)), InternPool.Index, InternPool.Nav.Index, - => @intFromEnum(@field(extra, field_name)), + => @backingInt(@field(extra, field_name)), else => @compileError("Unsupported field type " ++ @typeName(field_type)), }); } @@ -1304,7 +1304,7 @@ fn buildPointerOffset(cg: *CodeGen, ptr_value: WValue, offset: u64, action: enum fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; const air_tags = cg.air.instructions.items(.tag); - return switch (air_tags[@intFromEnum(inst)]) { + return switch (air_tags[@backingInt(inst)]) { // No soft float legalizations are enabled. .legalize_compiler_rt_call => unreachable, @@ -1312,7 +1312,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { .legalize_vec_elem_val => cg.airArrayElemVal(inst), .legalize_vec_store_elem => { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data; const vec_ptr = try cg.resolveInst(pl_op.operand); const elem_idx = try cg.resolveInst(bin_op.lhs); @@ -1345,7 +1345,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { .div_floor, .div_ceil, => |tag| { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); @@ -1399,7 +1399,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } }, .div_float => { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); const ty = cg.typeOfIndex(inst); @@ -1412,7 +1412,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { try cg.finishAir(inst, result, &.{ bin_op.lhs, bin_op.rhs }); }, .abs => { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const ty = cg.typeOf(ty_op.operand); @@ -1433,7 +1433,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } }, .mul_add => { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data; const addend = try cg.resolveInst(pl_op.operand); const lhs = try cg.resolveInst(bin_op.lhs); @@ -1453,7 +1453,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { .mul_sat, .shl_sat, => |tag| { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); const ty = cg.typeOfIndex(inst); @@ -1479,7 +1479,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { .mul_with_overflow, .shl_with_overflow, => |tag| { - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try cg.resolveInst(extra.lhs); @@ -1512,7 +1512,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .add_wrap, .sub_wrap, .mul_wrap, .shl => |tag| { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); const ty = cg.typeOfIndex(inst); @@ -1535,7 +1535,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .bit_and, .bit_or, .xor, .shl_exact, .shr, .shr_exact => |tag| { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); const ty = cg.typeOfIndex(inst); @@ -1558,7 +1558,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .not => { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const ty = cg.typeOf(ty_op.operand); @@ -1581,7 +1581,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { .union_from_enum => cg.airUnionFromEnum(inst), .int_cast => { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const dest_ty = ty_op.ty.toType(); const operand = try cg.resolveInst(ty_op.operand); @@ -1609,7 +1609,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { try cg.finishAir(inst, result, &.{ty_op.operand}); }, .trunc => { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const dest_ty = ty_op.ty.toType(); @@ -1632,7 +1632,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .fptrunc, .fpext => |tag| { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const src_ty = cg.typeOf(ty_op.operand); @@ -1655,7 +1655,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .int_from_float => { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const src_ty = cg.typeOf(ty_op.operand); const dest_ty = cg.typeOfIndex(inst); @@ -1668,7 +1668,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { try cg.finishAir(inst, result, &.{ty_op.operand}); }, .float_from_int => { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const src_ty = cg.typeOf(ty_op.operand); const dest_ty = cg.typeOfIndex(inst); @@ -1682,7 +1682,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .clz, .ctz, .popcount, .byte_swap, .bit_reverse => |tag| { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const ty = cg.typeOf(ty_op.operand); @@ -1704,7 +1704,7 @@ fn genInst(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .sqrt, .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .floor, .ceil, .round, .trunc_float, .neg => |tag| { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); const ty = cg.typeOfIndex(inst); @@ -1935,7 +1935,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { if (std.debug.runtime_safety and cg.air_bookkeeping < old_bookkeeping_value + 1) { std.debug.panic("Missing call to `finishAir` in AIR instruction %{d} ('{t}')", .{ inst, - cg.air.instructions.items(.tag)[@intFromEnum(inst)], + cg.air.instructions.items(.tag)[@backingInt(inst)], }); } } @@ -1943,7 +1943,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { fn airRet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); const fn_info = zcu.typeToFunc(zcu.navValue(cg.owner_nav).typeOf(zcu)).?; const ret_ty = Type.fromInterned(fn_info.return_type); @@ -1999,7 +1999,7 @@ fn airRetPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); const ret_ty = cg.typeOf(un_op).childType(zcu); @@ -2174,12 +2174,12 @@ fn airVaStart(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airVaEnd(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; return cg.finishAir(inst, .none, &.{un_op}); } fn airVaCopy(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const result = try cg.load(operand, .usize, 0); @@ -2189,7 +2189,7 @@ fn airVaCopy(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airVaArg(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const ty = cg.typeOfIndex(inst); @@ -2261,7 +2261,7 @@ fn airAlloc(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airStore(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); @@ -2278,7 +2278,7 @@ fn airStore(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void { assert(ptr_info.packed_offset.host_size == 0); // legalize .expand_packed_store break :offset 0; }, - else => |index| @intCast(@intFromEnum(index) * elem_ty.abiSize(zcu)), + else => |index| @intCast(@backingInt(index) * elem_ty.abiSize(zcu)), }; try cg.store(lhs, rhs, elem_ty, offset); return cg.finishAir(inst, .none, &.{ bin_op.lhs, bin_op.rhs }); @@ -2312,7 +2312,7 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr const extra_index: u32 = @intCast(cg.mir_extra.items.len); // stores as := opcode, offset, alignment (opcode::memarg) try cg.mir_extra.appendSlice(cg.gpa, &[_]u32{ - @intFromEnum(std.wasm.SimdOpcode.v128_store), + @backingInt(std.wasm.SimdOpcode.v128_store), offset + lhs.offset(), @intCast(ty.abiAlignment(zcu).toByteUnits().?), }); @@ -2353,7 +2353,7 @@ fn store(cg: *CodeGen, lhs: WValue, rhs: WValue, ty: Type, offset: u32) InnerErr fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const elem_ty = ty_op.ty.toType(); const ptr_ty = cg.typeOf(ty_op.operand); @@ -2366,7 +2366,7 @@ fn airLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { assert(ptr_info.packed_offset.host_size == 0); // legalize .expand_packed_load break :offset 0; }, - else => |index| @intCast(@intFromEnum(index) * elem_ty.abiSize(zcu)), + else => |index| @intCast(@backingInt(index) * elem_ty.abiSize(zcu)), }; const result = try cg.load(operand, elem_ty, offset); return cg.finishAir(inst, result, &.{ty_op.operand}); @@ -2400,7 +2400,7 @@ fn load(cg: *CodeGen, operand: WValue, ty: Type, offset: u32) InnerError!WValue const extra_index: u32 = @intCast(cg.mir_extra.items.len); // stores as := opcode, offset, alignment (opcode::memarg) try cg.mir_extra.appendSlice(cg.gpa, &[_]u32{ - @intFromEnum(std.wasm.SimdOpcode.v128_load), + @backingInt(std.wasm.SimdOpcode.v128_load), offset + operand.offset(), @intCast(ty.abiAlignment(zcu).toByteUnits().?), }); @@ -5241,7 +5241,7 @@ fn airCondBr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airCmp(cg: *CodeGen, inst: Air.Inst.Index, op: std.math.CompareOperator) InnerError!void { - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const lhs = try cg.resolveInst(bin_op.lhs); const rhs = try cg.resolveInst(bin_op.rhs); const operand_ty = cg.typeOf(bin_op.lhs); @@ -5473,7 +5473,7 @@ fn airCmpVector(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airCmpLteErrorsLen(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); try cg.emitWValue(operand); @@ -5486,7 +5486,7 @@ fn airCmpLteErrorsLen(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airBr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const br = cg.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = cg.air.instructions.items(.data)[@backingInt(inst)].br; const block = cg.blocks.get(br.block_inst).?; // if operand has codegen bits we should break with a value @@ -5505,7 +5505,7 @@ fn airBr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airRepeat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const repeat = cg.air.instructions.items(.data)[@intFromEnum(inst)].repeat; + const repeat = cg.air.instructions.items(.data)[@backingInt(inst)].repeat; const loop_label = cg.loops.get(repeat.loop_inst).?; const idx: u32 = cg.block_depth - loop_label; @@ -5533,7 +5533,7 @@ fn airUnreachable(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airNopCast(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = cg.typeOf(ty_op.operand); const dest_ty = cg.typeOfIndex(inst); @@ -5548,7 +5548,7 @@ fn airNopCast(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airIntFromPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand_ty = cg.typeOf(ty_op.operand); const dest_ty = cg.typeOfIndex(inst); @@ -5566,7 +5566,7 @@ fn airIntFromPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airUnionFromEnum(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const union_ty = cg.typeOfIndex(inst); const enum_ty = cg.typeOf(ty_op.operand); @@ -5580,7 +5580,7 @@ fn airUnionFromEnum(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airBitcast(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const dest_ty = cg.typeOfIndex(inst); const src_ty = cg.typeOf(ty_op.operand); @@ -5690,7 +5690,7 @@ fn bitcast(cg: *CodeGen, dest_ty: Type, src_ty: Type, operand: WValue) InnerErro fn airStructFieldPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.StructField, ty_pl.payload); const struct_ptr = try cg.resolveInst(extra.data.struct_operand); @@ -5702,7 +5702,7 @@ fn airStructFieldPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airStructFieldPtrIndex(cg: *CodeGen, inst: Air.Inst.Index, index: u32) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const struct_ptr = try cg.resolveInst(ty_op.operand); const struct_ptr_ty = cg.typeOf(ty_op.operand); const struct_ty = struct_ptr_ty.childType(zcu); @@ -5754,7 +5754,7 @@ fn structFieldPtr( fn airAggFieldVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; const struct_ty = cg.typeOf(struct_field.struct_operand); @@ -5986,7 +5986,7 @@ fn airSwitchBr(cg: *CodeGen, inst: Air.Inst.Index, is_dispatch_loop: bool) Inner } fn airSwitchDispatch(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const br = cg.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = cg.air.instructions.items(.data)[@backingInt(inst)].br; const switch_loop = cg.blocks.get(br.block_inst).?; const operand = try cg.resolveInst(br.operand); @@ -6001,7 +6001,7 @@ fn airSwitchDispatch(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airIsErr(cg: *CodeGen, inst: Air.Inst.Index, opcode: std.wasm.Opcode, op_kind: enum { value, ptr }) InnerError!void { const zcu = cg.pt.zcu; - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); const err_union_ty = switch (op_kind) { .value => cg.typeOf(un_op), @@ -6038,7 +6038,7 @@ fn airIsErr(cg: *CodeGen, inst: Air.Inst.Index, opcode: std.wasm.Opcode, op_kind /// *(E!T) -> *T op_is_prt == true fn airUnwrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const op_ty = cg.typeOf(ty_op.operand); @@ -6070,7 +6070,7 @@ fn airUnwrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) /// NOTE: op_is_ptr will not change return type fn airUnwrapErrUnionError(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const op_ty = cg.typeOf(ty_op.operand); @@ -6095,7 +6095,7 @@ fn airUnwrapErrUnionError(cg: *CodeGen, inst: Air.Inst.Index, op_is_ptr: bool) I fn airWrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const err_ty = cg.typeOfIndex(inst); @@ -6125,7 +6125,7 @@ fn airWrapErrUnionPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const err_ty = ty_op.ty.toType(); @@ -6153,7 +6153,7 @@ fn airWrapErrUnionErr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const OpKind = enum { value, ptr }; fn airIsNull(cg: *CodeGen, inst: Air.Inst.Index, opcode: std.wasm.Opcode, op_kind: OpKind) InnerError!void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); const op_ty = cg.typeOf(un_op); @@ -6204,7 +6204,7 @@ fn isNull(cg: *CodeGen, operand: WValue, op_ty: Type, opcode: std.wasm.Opcode, o fn airOptionalPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const opt_ty = cg.typeOf(ty_op.operand); const payload_ty = cg.typeOfIndex(inst); if (!payload_ty.hasRuntimeBits(zcu)) { @@ -6226,7 +6226,7 @@ fn airOptionalPayload(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airOptionalPayloadPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const opt_ty = cg.typeOf(ty_op.operand).childType(zcu); @@ -6244,7 +6244,7 @@ fn airOptionalPayloadPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airOptionalPayloadPtrSet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const opt_ty = cg.typeOf(ty_op.operand).childType(zcu); const payload_ty = opt_ty.optionalChild(zcu); @@ -6266,7 +6266,7 @@ fn airOptionalPayloadPtrSet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void } fn airWrapOptional(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const payload_ty = cg.typeOf(ty_op.operand); const pt = cg.pt; const zcu = pt.zcu; @@ -6304,7 +6304,7 @@ fn airWrapOptional(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const lhs = try cg.resolveInst(bin_op.lhs); @@ -6319,7 +6319,7 @@ fn airSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airSliceLen(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); return cg.finishAir(inst, try cg.sliceLen(operand), &.{ty_op.operand}); @@ -6327,7 +6327,7 @@ fn airSliceLen(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const slice_ty = cg.typeOf(bin_op.lhs); const slice = try cg.resolveInst(bin_op.lhs); @@ -6351,7 +6351,7 @@ fn airSliceElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airSliceElemPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const elem_ty = ty_pl.ty.toType().childType(zcu); @@ -6372,7 +6372,7 @@ fn airSliceElemPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airSlicePtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); return cg.finishAir(inst, try cg.slicePtr(operand), &.{ty_op.operand}); } @@ -6389,7 +6389,7 @@ fn sliceLen(cg: *CodeGen, operand: WValue) InnerError!WValue { fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const array_ty = cg.typeOf(ty_op.operand).childType(zcu); @@ -6409,7 +6409,7 @@ fn airArrayToSlice(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airPtrElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = cg.typeOf(bin_op.lhs); const ptr = try cg.resolveInst(bin_op.lhs); @@ -6437,7 +6437,7 @@ fn airPtrElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airPtrElemPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_ty = cg.typeOf(bin_op.lhs); @@ -6465,7 +6465,7 @@ fn airPtrElemPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airPtrBinOp(cg: *CodeGen, inst: Air.Inst.Index, op: enum { add, sub }) InnerError!void { const zcu = cg.pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; const ptr = try cg.resolveInst(bin_op.lhs); @@ -6503,7 +6503,7 @@ fn airPtrBinOp(cg: *CodeGen, inst: Air.Inst.Index, op: enum { add, sub }) InnerE fn airMemset(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) InnerError!void { const zcu = cg.pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr = try cg.resolveInst(bin_op.lhs); const ptr_ty = cg.typeOf(bin_op.lhs); @@ -6643,7 +6643,7 @@ fn memset(cg: *CodeGen, elem_ty: Type, ptr: WValue, len: WValue, value: WValue) fn airArrayElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const array_ty = cg.typeOf(bin_op.lhs); const array = try cg.resolveInst(bin_op.lhs); @@ -6670,7 +6670,7 @@ fn airArrayElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { else => unreachable, }; - var operands = [_]u32{ @intFromEnum(opcode), @as(u8, @intCast(lane)) }; + var operands = [_]u32{ @backingInt(opcode), @as(u8, @intCast(lane)) }; try cg.emitWValue(array); @@ -6703,7 +6703,7 @@ fn airArrayElemVal(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const ty = cg.typeOfIndex(inst); const elem_ty = ty.childType(zcu); @@ -6715,10 +6715,10 @@ fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { // the scalar value onto the stack. .stack_offset, .nav_ref, .uav_ref => { const opcode = switch (elem_ty.bitSize(zcu)) { - 8 => @intFromEnum(std.wasm.SimdOpcode.v128_load8_splat), - 16 => @intFromEnum(std.wasm.SimdOpcode.v128_load16_splat), - 32 => @intFromEnum(std.wasm.SimdOpcode.v128_load32_splat), - 64 => @intFromEnum(std.wasm.SimdOpcode.v128_load64_splat), + 8 => @backingInt(std.wasm.SimdOpcode.v128_load8_splat), + 16 => @backingInt(std.wasm.SimdOpcode.v128_load16_splat), + 32 => @backingInt(std.wasm.SimdOpcode.v128_load32_splat), + 64 => @backingInt(std.wasm.SimdOpcode.v128_load64_splat), else => break :blk, // Cannot make use of simd-instructions }; try cg.emitWValue(operand); @@ -6734,10 +6734,10 @@ fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { }, .local => { const opcode = switch (elem_ty.bitSize(zcu)) { - 8 => @intFromEnum(std.wasm.SimdOpcode.i8x16_splat), - 16 => @intFromEnum(std.wasm.SimdOpcode.i16x8_splat), - 32 => if (elem_ty.isInt(zcu)) @intFromEnum(std.wasm.SimdOpcode.i32x4_splat) else @intFromEnum(std.wasm.SimdOpcode.f32x4_splat), - 64 => if (elem_ty.isInt(zcu)) @intFromEnum(std.wasm.SimdOpcode.i64x2_splat) else @intFromEnum(std.wasm.SimdOpcode.f64x2_splat), + 8 => @backingInt(std.wasm.SimdOpcode.i8x16_splat), + 16 => @backingInt(std.wasm.SimdOpcode.i16x8_splat), + 32 => if (elem_ty.isInt(zcu)) @backingInt(std.wasm.SimdOpcode.i32x4_splat) else @backingInt(std.wasm.SimdOpcode.f32x4_splat), + 64 => if (elem_ty.isInt(zcu)) @backingInt(std.wasm.SimdOpcode.i64x2_splat) else @backingInt(std.wasm.SimdOpcode.f64x2_splat), else => break :blk, // Cannot make use of simd-instructions }; try cg.emitWValue(operand); @@ -6764,7 +6764,7 @@ fn airSplat(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airSelect(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const operand = try cg.resolveInst(pl_op.operand); _ = operand; @@ -6843,7 +6843,7 @@ fn airShuffleTwo(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { try cg.emitWValue(operand_b); const extra_index: u32 = @intCast(cg.mir_extra.items.len); try cg.mir_extra.appendSlice(cg.gpa, &.{ - @intFromEnum(std.wasm.SimdOpcode.i8x16_shuffle), + @backingInt(std.wasm.SimdOpcode.i8x16_shuffle), @bitCast(lane_map[0..4].*), @bitCast(lane_map[4..8].*), @bitCast(lane_map[8..12].*), @@ -6873,7 +6873,7 @@ fn airShuffleTwo(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airReduce(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const reduce = cg.air.instructions.items(.data)[@intFromEnum(inst)].reduce; + const reduce = cg.air.instructions.items(.data)[@backingInt(inst)].reduce; const operand = try cg.resolveInst(reduce.operand); _ = operand; @@ -6883,7 +6883,7 @@ fn airReduce(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airAggregateInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const result_ty = cg.typeOfIndex(inst); const len = @as(usize, @intCast(result_ty.arrayLen(zcu))); const elements: []const Air.Inst.Ref = @ptrCast(cg.air.extra.items[ty_pl.payload..][0..len]); @@ -6960,7 +6960,7 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; const result = result: { @@ -7019,19 +7019,19 @@ fn airUnionInit(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airPrefetch(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const prefetch = cg.air.instructions.items(.data)[@intFromEnum(inst)].prefetch; + const prefetch = cg.air.instructions.items(.data)[@backingInt(inst)].prefetch; return cg.finishAir(inst, .none, &.{prefetch.ptr}); } fn airWasmMemorySize(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; try cg.addLabel(.memory_size, pl_op.payload); return cg.finishAir(inst, .stack, &.{pl_op.operand}); } fn airWasmMemoryGrow(cg: *CodeGen, inst: Air.Inst.Index) !void { - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const operand = try cg.resolveInst(pl_op.operand); try cg.emitWValue(operand); @@ -7042,7 +7042,7 @@ fn airWasmMemoryGrow(cg: *CodeGen, inst: Air.Inst.Index) !void { fn airSetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const un_ty = cg.typeOf(bin_op.lhs).childType(zcu); const tag_ty = cg.typeOf(bin_op.rhs); const layout = un_ty.unionGetLayout(zcu); @@ -7066,7 +7066,7 @@ fn airSetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airGetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const un_ty = cg.typeOf(ty_op.operand); const tag_ty = cg.typeOfIndex(inst); @@ -7086,7 +7086,7 @@ fn airGetUnionTag(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airErrUnionPayloadPtrSet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const err_set_ty = cg.typeOf(ty_op.operand).childType(zcu); const payload_ty = err_set_ty.errorUnionPayload(zcu); @@ -7113,7 +7113,7 @@ fn airErrUnionPayloadPtrSet(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void fn airFieldParentPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const pt = cg.pt; const zcu = pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; const field_ptr = try cg.resolveInst(extra.field_ptr); @@ -7154,7 +7154,7 @@ fn sliceOrArrayPtr(cg: *CodeGen, ptr: WValue, ptr_ty: Type) InnerError!WValue { fn airMemcpy(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dst = try cg.resolveInst(bin_op.lhs); const dst_ty = cg.typeOf(bin_op.lhs); const ptr_elem_ty = dst_ty.childType(zcu); @@ -7185,7 +7185,7 @@ fn airMemcpy(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airMemmove(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const dst = try cg.resolveInst(bin_op.lhs); const dst_ty = cg.typeOf(bin_op.lhs); const ptr_elem_ty = dst_ty.childType(zcu); @@ -7223,7 +7223,7 @@ fn airRetAddr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airErrorName(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); // Each entry to this table is a slice (ptr+len). // The operand in this instruction represents the index within this table. @@ -7257,14 +7257,14 @@ fn airErrorName(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airPtrSliceFieldPtr(cg: *CodeGen, inst: Air.Inst.Index, offset: u32) InnerError!void { - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const slice_ptr = try cg.resolveInst(ty_op.operand); const result = try cg.buildPointerOffset(slice_ptr, offset, .new); return cg.finishAir(inst, result, &.{ty_op.operand}); } fn airDbgStmt(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const dbg_stmt = cg.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = cg.air.instructions.items(.data)[@backingInt(inst)].dbg_stmt; try cg.addInst(.{ .tag = .dbg_line, .data = .{ .payload = try cg.addExtra(Mir.DbgLineColumn{ .line = dbg_stmt.line, @@ -7408,7 +7408,7 @@ fn callIntrinsic( } fn airTagName(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); const enum_ty = cg.typeOf(un_op); @@ -7433,7 +7433,7 @@ fn airTagName(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airIsNamedEnumValue(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const operand = try cg.resolveInst(un_op); const enum_ty = cg.typeOf(un_op); @@ -7448,7 +7448,7 @@ fn airIsNamedEnumValue(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airErrorSetHasValue(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; const ip = &zcu.intern_pool; - const ty_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = cg.air.instructions.items(.data)[@backingInt(inst)].ty_op; const operand = try cg.resolveInst(ty_op.operand); const error_set_ty = ty_op.ty.toType(); @@ -7534,7 +7534,7 @@ inline fn useAtomicFeature(cg: *const CodeGen) bool { fn airCmpxchg(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const ty_pl = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = cg.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = cg.air.extraData(Air.Cmpxchg, ty_pl.payload).data; const ptr_ty = cg.typeOf(extra.ptr); @@ -7609,7 +7609,7 @@ fn airCmpxchg(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airAtomicLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const atomic_load = cg.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; + const atomic_load = cg.air.instructions.items(.data)[@backingInt(inst)].atomic_load; const ptr = try cg.resolveInst(atomic_load.ptr); const ty = cg.typeOfIndex(inst); @@ -7635,7 +7635,7 @@ fn airAtomicLoad(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const pl_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = cg.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = cg.air.extraData(Air.AtomicRmw, pl_op.payload).data; const ptr = try cg.resolveInst(pl_op.operand); @@ -7838,7 +7838,7 @@ fn airAtomicRmw(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { fn airAtomicStore(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { const zcu = cg.pt.zcu; - const bin_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = cg.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr = try cg.resolveInst(bin_op.lhs); const operand = try cg.resolveInst(bin_op.rhs); @@ -7875,7 +7875,7 @@ fn airFrameAddress(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { } fn airRuntimeNavPtr(cg: *CodeGen, inst: Air.Inst.Index) InnerError!void { - const ty_nav = cg.air.instructions.items(.data)[@intFromEnum(inst)].ty_nav; + const ty_nav = cg.air.instructions.items(.data)[@backingInt(inst)].ty_nav; const mod = cg.pt.zcu.navFileScope(cg.owner_nav).mod.?; if (mod.single_threaded) { const result: WValue = .{ .nav_ref = .{ diff --git a/src/codegen/wasm/Emit.zig b/src/codegen/wasm/Emit.zig index e0a7d449d661c4a782e3237e69a4876b2f03c41a..81bf1e1315362d5b4dd4928b29f76dc5ab1f41f0 100644 --- a/src/codegen/wasm/Emit.zig +++ b/src/codegen/wasm/Emit.zig @@ -42,8 +42,8 @@ pub fn lowerToCode(emit: *Emit) Error!void { .block, .loop => { const block_type = datas[inst].block_type; try code.ensureUnusedCapacity(gpa, 2); - code.appendAssumeCapacity(@intFromEnum(tags[inst])); - code.appendAssumeCapacity(@intFromEnum(block_type)); + code.appendAssumeCapacity(@backingInt(tags[inst])); + code.appendAssumeCapacity(@backingInt(block_type)); inst += 1; continue :loop tags[inst]; @@ -78,14 +78,14 @@ pub fn lowerToCode(emit: *Emit) Error!void { continue :loop tags[inst]; }, .func_ref => { - const indirect_func_idx: Wasm.ZcuIndirectFunctionSetIndex = @enumFromInt( + const indirect_func_idx: Wasm.ZcuIndirectFunctionSetIndex = @fromBackingInt(@intCast( wasm.zcu_indirect_function_set.getIndex(datas[inst].nav_index).?, - ); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + )); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); if (is_obj) { @panic("TODO"); } else { - writeSleb128(code, 1 + @intFromEnum(indirect_func_idx)); + writeSleb128(code, 1 + @backingInt(indirect_func_idx)); } inst += 1; continue :loop tags[inst]; @@ -96,7 +96,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { }, .errors_len => { try code.ensureUnusedCapacity(gpa, 6); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); // MIR is lowered during flush, so there is indeed only one thread at this time. const errors_len = 1 + comp.zcu.?.intern_pool.global_error_set.getNamesFromMainThread().len; writeSleb128(code, errors_len); @@ -108,7 +108,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { wasm.error_name_table_ref_count += 1; try code.ensureUnusedCapacity(gpa, 11); const opcode: std.wasm.Opcode = if (is_wasm32) .i32_const else .i64_const; - code.appendAssumeCapacity(@intFromEnum(opcode)); + code.appendAssumeCapacity(@backingInt(opcode)); if (is_obj) { try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), @@ -130,7 +130,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { }, .br_if, .br, .memory_grow, .memory_size => { try code.ensureUnusedCapacity(gpa, 11); - code.appendAssumeCapacity(@intFromEnum(tags[inst])); + code.appendAssumeCapacity(@backingInt(tags[inst])); writeUleb128(code, datas[inst].label); inst += 1; @@ -139,7 +139,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .local_get, .local_set, .local_tee => { try code.ensureUnusedCapacity(gpa, 11); - code.appendAssumeCapacity(@intFromEnum(tags[inst])); + code.appendAssumeCapacity(@backingInt(tags[inst])); writeUleb128(code, datas[inst].local); inst += 1; @@ -151,7 +151,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { const extra = mir.extraData(Mir.JumpTable, extra_index); const labels = mir.extra[extra.end..][0..extra.data.length]; try code.ensureUnusedCapacity(gpa, 11 + 10 * labels.len); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_table)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.br_table)); // -1 because default label is not part of length/depth. writeUleb128(code, extra.data.length - 1); for (labels) |label| writeUleb128(code, label); @@ -162,7 +162,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .call_nav => { try code.ensureUnusedCapacity(gpa, 6); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.call)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.call)); if (is_obj) { try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), @@ -190,7 +190,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { target, ).?; if (is_obj) { - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.call_indirect)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.call_indirect)); try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), .pointee = .{ .type_index = func_ty_index }, @@ -199,7 +199,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { }); code.appendNTimesAssumeCapacity(0, 5); } else { - const index: Wasm.Flush.FuncTypeIndex = @enumFromInt(wasm.flush_buffer.func_types.getIndex(func_ty_index) orelse { + const index: Wasm.Flush.FuncTypeIndex = @fromBackingInt(@intCast(wasm.flush_buffer.func_types.getIndex(func_ty_index) orelse { // In this case we tried to call a function pointer for // which the type signature does not match any function // body or function import in the entire wasm executable. @@ -207,12 +207,12 @@ pub fn lowerToCode(emit: *Emit) Error!void { // Since there is no way to create a reference to a // function without it being in the function table or // import table, this instruction is unreachable. - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.@"unreachable")); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.@"unreachable")); inst += 1; continue :loop tags[inst]; - }); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.call_indirect)); - writeUleb128(code, @intFromEnum(index)); + })); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.call_indirect)); + writeUleb128(code, @backingInt(index)); } writeUleb128(code, @as(u32, 0)); // table index @@ -222,7 +222,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .call_tag_index => { try code.ensureUnusedCapacity(gpa, 6); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.call)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.call)); if (is_obj) { try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), @@ -242,7 +242,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .enum_tag_name_table_ref => { try code.ensureUnusedCapacity(gpa, 11); const opcode: std.wasm.Opcode = if (is_wasm32) .i32_const else .i64_const; - code.appendAssumeCapacity(@intFromEnum(opcode)); + code.appendAssumeCapacity(@backingInt(opcode)); if (is_obj) { @panic("TODO"); } else { @@ -261,7 +261,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { const symbol_name = try wasm.internString(@tagName(datas[inst].intrinsic)); try code.ensureUnusedCapacity(gpa, 6); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.call)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.call)); if (is_obj) { try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), @@ -280,7 +280,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .global_set_sp => { try code.ensureUnusedCapacity(gpa, 6); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.global_set)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.global_set)); if (is_obj) { try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), @@ -291,7 +291,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { code.appendNTimesAssumeCapacity(0, 5); } else { const sp_global: Wasm.GlobalIndex = .stack_pointer; - writeUleb128(code, @intFromEnum(sp_global)); + writeUleb128(code, @backingInt(sp_global)); } inst += 1; @@ -300,7 +300,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .f32_const => { try code.ensureUnusedCapacity(gpa, 5); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.f32_const)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.f32_const)); std.mem.writeInt(u32, code.addManyAsArrayAssumeCapacity(4), @bitCast(datas[inst].float32), .little); inst += 1; @@ -309,7 +309,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .f64_const => { try code.ensureUnusedCapacity(gpa, 9); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.f64_const)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.f64_const)); const float64 = mir.extraData(Mir.Float64, datas[inst].payload).data; std.mem.writeInt(u64, code.addManyAsArrayAssumeCapacity(8), float64.toInt(), .little); @@ -318,7 +318,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { }, .i32_const => { try code.ensureUnusedCapacity(gpa, 6); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); writeSleb128(code, datas[inst].imm32); inst += 1; @@ -326,7 +326,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { }, .i64_const => { try code.ensureUnusedCapacity(gpa, 11); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_const)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i64_const)); const int64: i64 = @bitCast(mir.extraData(Mir.Imm64, datas[inst].payload).data.toInt()); writeSleb128(code, int64); @@ -359,7 +359,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .i64_store32, => { try code.ensureUnusedCapacity(gpa, 1 + 20); - code.appendAssumeCapacity(@intFromEnum(tags[inst])); + code.appendAssumeCapacity(@backingInt(tags[inst])); encodeMemArg(code, mir.extraData(Mir.MemArg, datas[inst].payload).data); inst += 1; continue :loop tags[inst]; @@ -495,7 +495,7 @@ pub fn lowerToCode(emit: *Emit) Error!void { .i64_clz, .i64_ctz, => { - try code.append(gpa, @intFromEnum(tags[inst])); + try code.append(gpa, @backingInt(tags[inst])); inst += 1; continue :loop tags[inst]; }, @@ -504,9 +504,9 @@ pub fn lowerToCode(emit: *Emit) Error!void { try code.ensureUnusedCapacity(gpa, 6 + 6); const extra_index = datas[inst].payload; const opcode = mir.extra[extra_index]; - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.misc_prefix)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.misc_prefix)); writeUleb128(code, opcode); - switch (@as(std.wasm.MiscOpcode, @enumFromInt(opcode))) { + switch (@as(std.wasm.MiscOpcode, @fromBackingInt(@intCast(opcode)))) { // bulk-memory opcodes .data_drop => { const segment = mir.extra[extra_index + 1]; @@ -566,9 +566,9 @@ pub fn lowerToCode(emit: *Emit) Error!void { try code.ensureUnusedCapacity(gpa, 6 + 20); const extra_index = datas[inst].payload; const opcode = mir.extra[extra_index]; - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.simd_prefix)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.simd_prefix)); writeUleb128(code, opcode); - switch (@as(std.wasm.SimdOpcode, @enumFromInt(opcode))) { + switch (@as(std.wasm.SimdOpcode, @fromBackingInt(@intCast(opcode)))) { .v128_store, .v128_load, .v128_load8_splat, @@ -852,9 +852,9 @@ pub fn lowerToCode(emit: *Emit) Error!void { const extra_index = datas[inst].payload; const opcode = mir.extra[extra_index]; - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.atomics_prefix)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.atomics_prefix)); writeUleb128(code, opcode); - switch (@as(std.wasm.AtomicsOpcode, @enumFromInt(opcode))) { + switch (@as(std.wasm.AtomicsOpcode, @fromBackingInt(@intCast(opcode)))) { .i32_atomic_load, .i64_atomic_load, .i32_atomic_load8_u, @@ -958,7 +958,7 @@ fn uavRefObj(wasm: *Wasm, code: *ArrayList(u8), value: InternPool.Index, offset: const opcode: std.wasm.Opcode = if (is_wasm32) .i32_const else .i64_const; try code.ensureUnusedCapacity(gpa, 11); - code.appendAssumeCapacity(@intFromEnum(opcode)); + code.appendAssumeCapacity(@backingInt(opcode)); try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), @@ -975,7 +975,7 @@ fn uavRefExe(wasm: *Wasm, code: *ArrayList(u8), value: InternPool.Index, offset: const opcode: std.wasm.Opcode = if (is_wasm32) .i32_const else .i64_const; try code.ensureUnusedCapacity(gpa, 11); - code.appendAssumeCapacity(@intFromEnum(opcode)); + code.appendAssumeCapacity(@backingInt(opcode)); const addr = wasm.uavAddr(value); writeUleb128(code, @as(u32, @intCast(@as(i64, addr) + offset))); @@ -993,7 +993,7 @@ fn navRefOff(wasm: *Wasm, code: *ArrayList(u8), data: Mir.NavRefOff, is_wasm32: try code.ensureUnusedCapacity(gpa, 11); const opcode: std.wasm.Opcode = if (is_wasm32) .i32_const else .i64_const; - code.appendAssumeCapacity(@intFromEnum(opcode)); + code.appendAssumeCapacity(@backingInt(opcode)); if (is_obj) { try wasm.out_relocs.append(gpa, .{ .offset = @intCast(code.items.len), @@ -1009,7 +1009,7 @@ fn navRefOff(wasm: *Wasm, code: *ArrayList(u8), data: Mir.NavRefOff, is_wasm32: } fn appendOutputFunctionIndex(code: *ArrayList(u8), i: Wasm.OutputFunctionIndex) void { - writeUleb128(code, @intFromEnum(i)); + writeUleb128(code, @backingInt(i)); } fn writeUleb128(code: *ArrayList(u8), arg: anytype) void { diff --git a/src/codegen/wasm/Mir.zig b/src/codegen/wasm/Mir.zig index d9ff5117b454391a22d799225f0f29f097a1bca7..454592c5d2198e14d895b2e19586775396ef5395 100644 --- a/src/codegen/wasm/Mir.zig +++ b/src/codegen/wasm/Mir.zig @@ -618,12 +618,12 @@ pub const Inst = struct { /// From a given wasm opcode, returns a MIR tag. pub fn fromOpcode(opcode: std.wasm.Opcode) Tag { - return @as(Tag, @enumFromInt(@intFromEnum(opcode))); // Given `Opcode` is not present as a tag for MIR yet + return @as(Tag, @fromBackingInt(@intCast(@backingInt(opcode)))); // Given `Opcode` is not present as a tag for MIR yet } /// Returns a wasm opcode from a given MIR tag. pub fn toOpcode(self: Tag) std.wasm.Opcode { - return @as(std.wasm.Opcode, @enumFromInt(@intFromEnum(self))); + return @as(std.wasm.Opcode, @fromBackingInt(@intCast(@backingInt(self)))); } }; @@ -690,7 +690,7 @@ pub fn lower(mir: *const Mir, wasm: *Wasm, code: *std.ArrayList(u8)) std.mem.All for (mir.locals) |local| { w.writeLeb128(@as(u32, 1)) catch unreachable; - w.writeByte(@intFromEnum(local)) catch unreachable; + w.writeByte(@backingInt(local)) catch unreachable; } // Stack management section of function prologue. @@ -698,31 +698,31 @@ pub fn lower(mir: *const Mir, wasm: *Wasm, code: *std.ArrayList(u8)) std.mem.All if (stack_alignment.toByteUnits()) |align_bytes| { const sp_global: Wasm.GlobalIndex = .stack_pointer; // load stack pointer - w.writeByte(@intFromEnum(std.wasm.Opcode.global_get)) catch unreachable; - w.writeUleb128(@intFromEnum(sp_global)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.global_get)) catch unreachable; + w.writeUleb128(@backingInt(sp_global)) catch unreachable; // store stack pointer so we can restore it when we return from the function - w.writeByte(@intFromEnum(std.wasm.Opcode.local_tee)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.local_tee)) catch unreachable; w.writeUleb128(mir.prologue.sp_local) catch unreachable; // get the total stack size const aligned_stack: i32 = @intCast(stack_alignment.forward(mir.prologue.stack_size)); - w.writeByte(@intFromEnum(std.wasm.Opcode.i32_const)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.i32_const)) catch unreachable; w.writeSleb128(aligned_stack) catch unreachable; // subtract it from the current stack pointer - w.writeByte(@intFromEnum(std.wasm.Opcode.i32_sub)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.i32_sub)) catch unreachable; // Get negative stack alignment const neg_stack_align = @as(i32, @intCast(align_bytes)) * -1; - w.writeByte(@intFromEnum(std.wasm.Opcode.i32_const)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.i32_const)) catch unreachable; w.writeSleb128(neg_stack_align) catch unreachable; // Bitwise-and the value to get the new stack pointer to ensure the // pointers are aligned with the abi alignment. - w.writeByte(@intFromEnum(std.wasm.Opcode.i32_and)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.i32_and)) catch unreachable; // The bottom will be used to calculate all stack pointer offsets. - w.writeByte(@intFromEnum(std.wasm.Opcode.local_tee)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.local_tee)) catch unreachable; w.writeUleb128(mir.prologue.bottom_stack_local) catch unreachable; // Store the current stack pointer value into the global stack pointer so other function calls will // start from this value instead and not overwrite the current stack. - w.writeByte(@intFromEnum(std.wasm.Opcode.global_set)) catch unreachable; - w.writeUleb128(@intFromEnum(sp_global)) catch unreachable; + w.writeByte(@backingInt(std.wasm.Opcode.global_set)) catch unreachable; + w.writeUleb128(@backingInt(sp_global)) catch unreachable; } code.items.len += w.end; @@ -747,7 +747,7 @@ pub fn extraData(self: *const Mir, comptime T: type, index: usize) struct { data Wasm.UavsExeIndex, InternPool.Nav.Index, InternPool.Index, - => @enumFromInt(self.extra[i]), + => @fromBackingInt(@intCast(self.extra[i])), else => @compileError("Unsupported field type " ++ @typeName(field_type)), }; i += 1; diff --git a/src/codegen/x86_64/CodeGen.zig b/src/codegen/x86_64/CodeGen.zig index 10adf9b858ee9ab1f977218652a1dfa0d37b89ff..1b29b50549173fe0d0855f541238971f8fcba181 100644 --- a/src/codegen/x86_64/CodeGen.zig +++ b/src/codegen/x86_64/CodeGen.zig @@ -85,7 +85,7 @@ pub fn legalizeFeatures(_: *const std.Target) *const Air.Legalize.Features { /// https://github.com/ziglang/zig/issues/22419 const hack_around_sema_opv_bugs = true; -const err_ret_trace_index: Air.Inst.Index = @enumFromInt(std.math.maxInt(u32)); +const err_ret_trace_index: Air.Inst.Index = @fromBackingInt(@intCast(std.math.maxInt(u32))); gpa: Allocator, pt: Zcu.PerThread, @@ -165,7 +165,7 @@ loop_switches: std.AutoHashMapUnmanaged(Air.Inst.Index, struct { }, }) = .empty, -next_temp_index: Temp.Index = @enumFromInt(0), +next_temp_index: Temp.Index = @fromBackingInt(@intCast(0)), temp_type: [Temp.Index.max]Type = undefined, const MaskInfo = packed struct { @@ -616,14 +616,14 @@ pub const MCValue = union(enum) { }), .load_frame => |pl| try w.print("[{f} + 0x{x}]", .{ pl.index, pl.off }), .lea_frame => |pl| try w.print("{f} + 0x{x}", .{ pl.index, pl.off }), - .load_nav => |pl| try w.print("[nav:{d}]", .{@intFromEnum(pl)}), - .lea_nav => |pl| try w.print("nav:{d}", .{@intFromEnum(pl)}), - .load_uav => |pl| try w.print("[uav:{d}]", .{@intFromEnum(pl.val)}), - .lea_uav => |pl| try w.print("uav:{d}", .{@intFromEnum(pl.val)}), - .load_lazy_sym => |pl| try w.print("[lazy:{s}:{d}]", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }), - .lea_lazy_sym => |pl| try w.print("lazy:{s}:{d}", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }), - .load_extern_func => |pl| try w.print("[extern:{d}]", .{@intFromEnum(pl)}), - .lea_extern_func => |pl| try w.print("extern:{d}", .{@intFromEnum(pl)}), + .load_nav => |pl| try w.print("[nav:{d}]", .{@backingInt(pl)}), + .lea_nav => |pl| try w.print("nav:{d}", .{@backingInt(pl)}), + .load_uav => |pl| try w.print("[uav:{d}]", .{@backingInt(pl.val)}), + .lea_uav => |pl| try w.print("uav:{d}", .{@backingInt(pl.val)}), + .load_lazy_sym => |pl| try w.print("[lazy:{s}:{d}]", .{ @tagName(pl.kind), @backingInt(pl.ty) }), + .lea_lazy_sym => |pl| try w.print("lazy:{s}:{d}", .{ @tagName(pl.kind), @backingInt(pl.ty) }), + .load_extern_func => |pl| try w.print("[extern:{d}]", .{@backingInt(pl)}), + .lea_extern_func => |pl| try w.print("extern:{d}", .{@backingInt(pl)}), .register_tee => |pl| try w.print("tee:{s}:{s}", .{ @tagName(pl[1]), @tagName(pl[0]) }), .elementwise_gpr => |pl| try w.print("elementwise:gpr{d}:[{f} + 0x{x}]", .{ pl.info.reg_index, pl.frame_index, pl.info.frame_off, @@ -641,7 +641,7 @@ pub const MCValue = union(enum) { pl.info.reg_index, pl.frame_index, pl.info.frame_off, }), .reserved_frame => |pl| try w.print("(dead:{f})", .{pl}), - .air_ref => |pl| try w.print("(air:0x{x})", .{@intFromEnum(pl)}), + .air_ref => |pl| try w.print("(air:0x{x})", .{@backingInt(pl)}), } } }; @@ -1011,7 +1011,7 @@ pub fn generate( } try function.inst_tracking.ensureTotalCapacity(gpa, Temp.Index.max); for (0..Temp.Index.max) |temp_index| { - const temp: Temp.Index = @enumFromInt(temp_index); + const temp: Temp.Index = @fromBackingInt(@intCast(temp_index)); function.inst_tracking.putAssumeCapacityNoClobber(temp.toIndex(), .init(.none)); } @@ -1019,11 +1019,11 @@ pub fn generate( try function.frame_allocs.resize(gpa, FrameIndex.named_count); function.frame_allocs.set( - @intFromEnum(FrameIndex.stack_frame), + @backingInt(FrameIndex.stack_frame), .init(.{ .size = 0, .alignment = .@"1" }), ); function.frame_allocs.set( - @intFromEnum(FrameIndex.call_frame), + @backingInt(FrameIndex.call_frame), .init(.{ .size = 0, .alignment = .@"1" }), ); @@ -1034,18 +1034,18 @@ pub fn generate( function.args = call_info.args; function.ret_mcv = call_info.return_value; function.err_ret_trace_reg = call_info.err_ret_trace_reg; - function.frame_allocs.set(@intFromEnum(FrameIndex.ret_addr), .init(.{ + function.frame_allocs.set(@backingInt(FrameIndex.ret_addr), .init(.{ .size = Type.usize.abiSize(zcu), .alignment = Type.usize.abiAlignment(zcu).min(call_info.stack_align), })); - function.frame_allocs.set(@intFromEnum(FrameIndex.base_ptr), .init(.{ + function.frame_allocs.set(@backingInt(FrameIndex.base_ptr), .init(.{ .size = Type.usize.abiSize(zcu), .alignment = call_info.stack_align.min( .fromNonzeroByteUnits(function.target.stackAlignment()), ), })); function.frame_allocs.set( - @intFromEnum(FrameIndex.args_frame), + @backingInt(FrameIndex.args_frame), .init(.{ .size = call_info.stack_byte_count, .alignment = call_info.stack_align, @@ -1148,7 +1148,7 @@ pub fn generateLazy( } try function.inst_tracking.ensureTotalCapacity(gpa, Temp.Index.max); for (0..Temp.Index.max) |temp_index| { - const temp: Temp.Index = @enumFromInt(temp_index); + const temp: Temp.Index = @fromBackingInt(@intCast(temp_index)); function.inst_tracking.putAssumeCapacityNoClobber(temp.toIndex(), .init(.none)); } @@ -1313,7 +1313,7 @@ fn addExtraAssumeCapacity(self: *CodeGen, extra: anytype) u32 { self.mir_extra.appendAssumeCapacity(switch (field_type) { u32 => @field(extra, field_name), i32, Mir.Memory.Info => @bitCast(@field(extra, field_name)), - FrameIndex => @intFromEnum(@field(extra, field_name)), + FrameIndex => @backingInt(@field(extra, field_name)), else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)), }); } @@ -1333,7 +1333,7 @@ fn addString(cg: *CodeGen, string: []const u8) Allocator.Error!Mir.NullTerminate cg.mir_string_bytes.appendSliceAssumeCapacity(string); cg.mir_string_bytes.appendAssumeCapacity(0); } - return @enumFromInt(mir_string_gop.key_ptr.*); + return @fromBackingInt(@intCast(mir_string_gop.key_ptr.*)); } fn asmOps(self: *CodeGen, tag: Mir.Inst.FixedTag, ops: [4]Operand) !void { @@ -2392,13 +2392,13 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { cg.reused_operands = .empty; try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); - switch (air_tags[@intFromEnum(inst)]) { + switch (air_tags[@backingInt(inst)]) { .select => try cg.airSelect(inst), .shuffle_one, .shuffle_two => @panic("x86_64 TODO: shuffle_one/shuffle_two"), .arg => try cg.airArg(inst), .add, .add_optimized, .add_wrap => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -4560,7 +4560,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .add_safe => unreachable, .add_sat => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -13124,7 +13124,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .sub, .sub_optimized, .sub_wrap => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -15311,7 +15311,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .sub_safe => unreachable, .sub_sat => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -22145,7 +22145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .mul, .mul_optimized => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -25083,7 +25083,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .mul_safe => unreachable, .mul_wrap => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -26888,7 +26888,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .mul_sat => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -32105,7 +32105,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -33343,7 +33343,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .div_trunc => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -34800,7 +34800,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .div_trunc_optimized, .div_floor_optimized => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) { @@ -36361,7 +36361,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .div_floor => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -38053,7 +38053,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .rem, .rem_optimized => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -39835,7 +39835,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .mod, .mod_optimized => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -43348,7 +43348,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .ptr_add => |air_tag| { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); try ops[0].toSlicePtr(cg); @@ -43462,7 +43462,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .ptr_sub => |air_tag| { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); try ops[0].toSlicePtr(cg); @@ -43591,7 +43591,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .max => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -47900,7 +47900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .min => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -52203,7 +52203,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .add_with_overflow => |air_tag| { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; @@ -53053,7 +53053,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .sub_with_overflow => |air_tag| { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; @@ -53958,7 +53958,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .mul_with_overflow => |air_tag| { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; @@ -57555,7 +57555,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .shl_with_overflow => |air_tag| { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [2]Temp = undefined; @@ -60900,7 +60900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .alloc => { - const ty = air_datas[@intFromEnum(inst)].ty; + const ty = air_datas[@backingInt(inst)].ty; const slot = try cg.tempInit(ty, .{ .lea_frame = .{ .index = try cg.allocMemPtr(inst), } }); @@ -60908,7 +60908,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .inferred_alloc, .inferred_alloc_comptime => unreachable, .ret_ptr => { - const ty = air_datas[@intFromEnum(inst)].ty; + const ty = air_datas[@backingInt(inst)].ty; var slot = switch (cg.ret_mcv.long) { else => unreachable, .none => try cg.tempInit(ty, .{ .lea_frame = .{ @@ -60924,7 +60924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .assembly => try cg.airAsm(inst), .bit_and, .bit_or, .xor => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(Mir.Inst.Tag, switch (air_tag) { @@ -61294,7 +61294,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .shr, .shr_exact => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -61858,7 +61858,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .shl, .shl_exact => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -62232,7 +62232,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .shl_sat => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const lhs_ty = cg.typeOf(bin_op.lhs); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -65655,7 +65655,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .not => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -67464,7 +67464,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try cg.genBodyBlock(block.body); }, .repeat => { - const repeat = air_datas[@intFromEnum(inst)].repeat; + const repeat = air_datas[@backingInt(inst)].repeat; const loop = cg.loops.get(repeat.loop_inst).?; try cg.restoreState(loop.state, &.{}, .{ .emit_instructions = true, @@ -67495,7 +67495,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .call_never_tail => try cg.airCall(inst, .never_tail, .{ .safety = true }), .call_never_inline => try cg.airCall(inst, .never_inline, .{ .safety = true }), .clz => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -70600,7 +70600,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .ctz => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -70997,7 +70997,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .popcount => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -71885,7 +71885,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .byte_swap => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -72534,7 +72534,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .bit_reverse => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -75636,7 +75636,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .sqrt => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(un_op)}, &ops, comptime &.{ .{ @@ -76698,7 +76698,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{un_op}, &ops, cg); }, .sin, .cos, .tan, .exp, .exp2, .log, .log2, .log10, .round => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(un_op)}, &ops, switch (air_tag) { @@ -77548,7 +77548,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{un_op}, &ops, cg); }, .abs => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -79099,7 +79099,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .floor, .ceil, .trunc_float => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(un_op)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) { @@ -80435,7 +80435,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{un_op}, &ops, cg); }, .neg, .neg_optimized => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(un_op)}, &ops, comptime &.{ .{ @@ -80983,7 +80983,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .cmp_gt, .cmp_gt_optimized, => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const cmp_op = air_tag.toCmpOp().?; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; @@ -81460,7 +81460,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .cmp_neq, .cmp_neq_optimized, => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const cmp_op = air_tag.toCmpOp().?; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); const ty = cg.typeOf(bin_op.lhs); @@ -82059,7 +82059,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .cmp_vector, .cmp_vector_optimized => |air_tag| { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const vector_cmp = cg.air.extraData(Air.VectorCmp, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ vector_cmp.lhs, vector_cmp.rhs }); var res: [1]Temp = undefined; @@ -89128,7 +89128,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .@"try", .try_cold => try cg.airTry(inst), .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), .dbg_stmt => if (!cg.mod.strip) { - const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; + const dbg_stmt = air_datas[@backingInt(inst)].dbg_stmt; _ = try cg.addInst(.{ .tag = .pseudo, .ops = .pseudo_dbg_line_stmt_line_column, @@ -89164,8 +89164,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }); }, .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => |air_tag| if (!cg.mod.strip) { - const pl_op = air_datas[@intFromEnum(inst)].pl_op; - const air_name: Air.NullTerminatedString = @enumFromInt(pl_op.payload); + const pl_op = air_datas[@backingInt(inst)].pl_op; + const air_name: Air.NullTerminatedString = @fromBackingInt(@intCast(pl_op.payload)); const op_ty = cg.typeOf(pl_op.operand); const local_ty = switch (air_tag) { else => unreachable, @@ -89202,7 +89202,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].die(cg); }, .is_null => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const opt_ty = cg.typeOf(un_op); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); const opt_child_ty = opt_ty.optionalChild(zcu); @@ -89227,7 +89227,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_null.finish(inst, &.{un_op}, &ops, cg); }, .is_non_null => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const opt_ty = cg.typeOf(un_op); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); const opt_child_ty = opt_ty.optionalChild(zcu); @@ -89252,7 +89252,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_non_null.finish(inst, &.{un_op}, &ops, cg); }, .is_null_ptr => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const opt_ty = cg.typeOf(un_op).childType(zcu); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); const opt_child_ty = opt_ty.optionalChild(zcu); @@ -89275,7 +89275,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_null.finish(inst, &.{un_op}, &ops, cg); }, .is_non_null_ptr => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const opt_ty = cg.typeOf(un_op).childType(zcu); const opt_repr_is_pl = opt_ty.optionalReprIsPayload(zcu); const opt_child_ty = opt_ty.optionalChild(zcu); @@ -89298,7 +89298,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_non_null.finish(inst, &.{un_op}, &ops, cg); }, .is_err => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const eu_ty = cg.typeOf(un_op); const eu_err_ty = eu_ty.errorUnionSet(zcu); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -89314,7 +89314,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_err.finish(inst, &.{un_op}, &ops, cg); }, .is_non_err => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const eu_ty = cg.typeOf(un_op); const eu_err_ty = eu_ty.errorUnionSet(zcu); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -89330,7 +89330,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_non_err.finish(inst, &.{un_op}, &ops, cg); }, .is_err_ptr => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const eu_ty = cg.typeOf(un_op).childType(zcu); const eu_err_ty = eu_ty.errorUnionSet(zcu); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -89346,7 +89346,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_err.finish(inst, &.{un_op}, &ops, cg); }, .is_non_err_ptr => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; const eu_ty = cg.typeOf(un_op).childType(zcu); const eu_err_ty = eu_ty.errorUnionSet(zcu); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -89362,7 +89362,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try is_non_err.finish(inst, &.{un_op}, &ops, cg); }, .load => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const val_ty = ty_op.ty.toType(); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; @@ -89414,7 +89414,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { error.SelectFailed => res[0] = try ops[0].load(val_ty, .{ .disp = switch (cg.typeOf(ty_op.operand).ptrInfo(zcu).flags.vector_index) { .none => 0, - else => |vector_index| @intCast(val_ty.abiSize(zcu) * @intFromEnum(vector_index)), + else => |vector_index| @intCast(val_ty.abiSize(zcu) * @backingInt(vector_index)), }, }, cg), else => |e| return e, @@ -89425,7 +89425,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .ret_safe => try cg.airRet(inst, true), .ret_load => try cg.airRetLoad(inst), .store, .store_safe => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); switch (ops[1].tracking(cg).short) { else => {}, @@ -89675,7 +89675,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { error.SelectFailed => try ops[0].store(&ops[1], .{ .disp = switch (cg.typeOf(bin_op.lhs).ptrInfo(zcu).flags.vector_index) { .none => 0, - else => |vector_index| @intCast(cg.typeOf(bin_op.rhs).abiSize(zcu) * @intFromEnum(vector_index)), + else => |vector_index| @intCast(cg.typeOf(bin_op.rhs).abiSize(zcu) * @backingInt(vector_index)), }, .safe = switch (air_tag) { else => unreachable, @@ -89689,7 +89689,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .unreach => {}, .fptrunc => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -91714,7 +91714,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .fpext => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -93389,7 +93389,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .int_cast => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const dst_ty = ty_op.ty.toType(); const src_ty = cg.typeOf(ty_op.operand); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); @@ -98148,7 +98148,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .int_cast_safe => unreachable, .trunc => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -103813,7 +103813,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .optional_payload => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); const pl = if (!hack_around_sema_opv_bugs or ty_op.ty.toType().hasRuntimeBits(zcu)) try ops[0].read(ty_op.ty.toType(), .{}, cg) @@ -103822,12 +103822,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try pl.finish(inst, &.{ty_op.operand}, &ops, cg); }, .optional_payload_ptr => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .optional_payload_ptr_set => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const opt_ty = cg.typeOf(ty_op.operand).childType(zcu); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); if (!opt_ty.optionalReprIsPayload(zcu)) { @@ -103842,7 +103842,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .wrap_optional => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const opt_ty = ty_op.ty.toType(); const opt_pl_ty = cg.typeOf(ty_op.operand); const opt_pl_abi_size: u31 = @intCast(opt_pl_ty.abiSize(zcu)); @@ -103857,7 +103857,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try opt.finish(inst, &.{ty_op.operand}, &ops, cg); }, .unwrap_errunion_payload => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const eu_pl_ty = ty_op.ty.toType(); const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu)); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); @@ -103868,7 +103868,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try pl.finish(inst, &.{ty_op.operand}, &ops, cg); }, .unwrap_errunion_err => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand); const eu_err_ty = ty_op.ty.toType(); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -103878,7 +103878,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try err.finish(inst, &.{ty_op.operand}, &ops, cg); }, .unwrap_errunion_payload_ptr => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); const eu_pl_off: i32 = @intCast(codegen.errUnionPayloadOffset(eu_pl_ty, zcu)); @@ -103887,7 +103887,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .unwrap_errunion_err_ptr => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); const eu_err_ty = ty_op.ty.toType(); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -103898,7 +103898,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try err.finish(inst, &.{ty_op.operand}, &ops, cg); }, .errunion_payload_ptr_set => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const eu_ty = cg.typeOf(ty_op.operand).childType(zcu); const eu_err_ty = eu_ty.errorUnionSet(zcu); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); @@ -103913,7 +103913,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .wrap_errunion_payload => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const eu_ty = ty_op.ty.toType(); const eu_err_ty = eu_ty.errorUnionSet(zcu); const eu_pl_ty = cg.typeOf(ty_op.operand); @@ -103928,7 +103928,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try eu.finish(inst, &.{ty_op.operand}, &ops, cg); }, .wrap_errunion_err => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const eu_ty = ty_op.ty.toType(); const eu_pl_ty = eu_ty.errorUnionPayload(zcu); const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu)); @@ -103938,7 +103938,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try eu.finish(inst, &.{ty_op.operand}, &ops, cg); }, .struct_field_ptr => { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{struct_field.struct_operand}); try ops[0].toOffset(@intCast(codegen.fieldOffset( @@ -103954,7 +103954,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .struct_field_ptr_index_2, .struct_field_ptr_index_3, => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toOffset(@intCast(codegen.fieldOffset( cg.typeOf(ty_op.operand), @@ -103971,7 +103971,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .agg_field_val => { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const struct_field = cg.air.extraData(Air.StructField, ty_pl.payload).data; const agg_ty = cg.typeOf(struct_field.struct_operand); const field_ty = ty_pl.ty.toType(); @@ -103987,7 +103987,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res.finish(inst, &.{struct_field.struct_operand}, &ops, cg); }, .set_union_tag => { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const union_ty = cg.typeOf(bin_op.lhs).childType(zcu); const union_layout = union_ty.unionGetLayout(zcu); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -103998,7 +103998,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res.finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .get_union_tag => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const union_ty = cg.typeOf(ty_op.operand); var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); const union_layout = union_ty.unionGetLayout(zcu); @@ -104009,38 +104009,38 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res.finish(inst, &.{ty_op.operand}, &ops, cg); }, .slice => { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); try ops[0].toPair(&ops[1], cg); try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .slice_len => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toSliceLen(cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .slice_ptr => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toSlicePtr(cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .ptr_slice_len_ptr => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toOffset(8, cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .ptr_slice_ptr_ptr => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].toOffset(0, cg); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .array_elem_val, .legalize_vec_elem_val => { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const array_ty = cg.typeOf(bin_op.lhs); const res_ty = array_ty.childType(zcu); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); @@ -104236,7 +104236,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .slice_elem_val, .ptr_elem_val => { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; const res_ty = cg.typeOf(bin_op.lhs).indexableElem(zcu); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); try ops[0].toSlicePtr(cg); @@ -104359,7 +104359,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .slice_elem_ptr, .ptr_elem_ptr => { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); try ops[0].toSlicePtr(cg); @@ -104406,7 +104406,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); }, .array_to_slice => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var len = try cg.tempInit(.usize, .{ .immediate = cg.typeOf(ty_op.operand).childType(zcu).arrayLen(zcu), @@ -104415,7 +104415,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .int_from_float, .int_from_float_optimized => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -115184,7 +115184,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .int_from_float_safe => unreachable, .int_from_float_optimized_safe => unreachable, .float_from_int => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -127202,7 +127202,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .reduce => |air_tag| { const nan = std.math.nan(f16); - const reduce = air_datas[@intFromEnum(inst)].reduce; + const reduce = air_datas[@backingInt(inst)].reduce; const res_ty = cg.typeOfIndex(inst); var ops = try cg.tempsFromOperands(inst, .{reduce.operand}); var res: [1]Temp = undefined; @@ -161404,7 +161404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .reduce_optimized => |air_tag| { const inf = std.math.inf(f16); - const reduce = air_datas[@intFromEnum(inst)].reduce; + const reduce = air_datas[@backingInt(inst)].reduce; var ops = try cg.tempsFromOperands(inst, .{reduce.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOfIndex(inst)}, &ops, switch (reduce.operation) { @@ -169105,7 +169105,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{reduce.operand}, &ops, cg); }, .splat => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); var res: [1]Temp = undefined; cg.select(&res, &.{ty_op.ty.toType()}, &ops, comptime &.{ .{ @@ -170948,7 +170948,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .memset => try cg.airMemset(inst, false), .memset_safe => try cg.airMemset(inst, true), .memcpy, .memmove => |air_tag| { - const bin_op = air_datas[@intFromEnum(inst)].bin_op; + const bin_op = air_datas[@backingInt(inst)].bin_op; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }) ++ .{undefined}; ops[2] = ops[0].getByteLen(cg) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {f} {f} {f} {f}", .{ @@ -171012,7 +171012,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .atomic_store_seq_cst => try cg.airAtomicStore(inst, .seq_cst), .atomic_rmw => try cg.airAtomicRmw(inst), .is_named_enum_value => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ @@ -171183,7 +171183,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{un_op}, &ops, cg); }, .tag_name => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; cg.select(&res, &.{.slice_const_u8_sentinel_0}, &ops, comptime &.{ .{ @@ -171350,7 +171350,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{un_op}, &ops, cg); }, .error_name => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [2]Temp = undefined; cg.select(&res, &.{ .slice_const_u8_sentinel_0, .usize }, &ops, comptime &.{ .{ @@ -171458,7 +171458,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{un_op}, &ops, cg); }, .error_set_has_value => |air_tag| { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; var ops = try cg.tempsFromOperands(inst, .{ty_op.operand}) ++ .{try cg.tempInit(ty_op.ty.toType(), .none)}; var res: [1]Temp = undefined; cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ @@ -171550,7 +171550,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, ops[0..1], cg); }, .aggregate_init => |air_tag| fallback: { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const agg_ty = ty_pl.ty.toType(); if (agg_ty.isVector(zcu) and agg_ty.childType(zcu).toIntern() == .bool_type) { break :fallback try cg.airAggregateInitBoolVec(inst); @@ -171620,7 +171620,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res.finish(inst, &.{}, &.{}, cg); }, .union_init => { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const union_init = cg.air.extraData(Air.UnionInit, ty_pl.payload).data; const union_ty = ty_pl.ty.toType(); var ops = try cg.tempsFromOperands(inst, .{union_init.init}); @@ -171642,7 +171642,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res.finish(inst, &.{union_init.init}, &ops, cg); }, .prefetch => { - const prefetch = air_datas[@intFromEnum(inst)].prefetch; + const prefetch = air_datas[@backingInt(inst)].prefetch; var ops = try cg.tempsFromOperands(inst, .{prefetch.ptr}); switch (prefetch.cache) { .instruction => {}, // prefetchi requires rip-relative addressing, which is currently non-trivial to emit from an arbitrary ptr value @@ -171669,7 +171669,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res.finish(inst, &.{prefetch.ptr}, &ops, cg); }, .mul_add => |air_tag| { - const pl_op = air_datas[@intFromEnum(inst)].pl_op; + const pl_op = air_datas[@backingInt(inst)].pl_op; const bin_op = cg.air.extraData(Air.Bin, pl_op.payload).data; var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs, pl_op.operand }); var res: [1]Temp = undefined; @@ -173070,7 +173070,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs, pl_op.operand }, &ops, cg); }, .field_parent_ptr => { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const field_parent_ptr = cg.air.extraData(Air.FieldParentPtr, ty_pl.payload).data; var ops = try cg.tempsFromOperands(inst, .{field_parent_ptr.field_ptr}); try ops[0].toOffset(-@as(i32, @intCast(codegen.fieldOffset( @@ -173083,7 +173083,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .wasm_memory_size, .wasm_memory_grow => unreachable, .cmp_lte_errors_len => |air_tag| { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); var res: [1]Temp = undefined; cg.select(&res, &.{.bool}, &ops, comptime &.{ .{ @@ -173172,7 +173172,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try ert.finish(inst, &.{}, &.{}, cg); }, .set_err_return_trace => { - const un_op = air_datas[@intFromEnum(inst)].un_op; + const un_op = air_datas[@backingInt(inst)].un_op; var ops = try cg.tempsFromOperands(inst, .{un_op}); switch (ops[0].unwrap(cg)) { .ref => { @@ -173191,12 +173191,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } }, .addrspace_cast => { - const ty_op = air_datas[@intFromEnum(inst)].ty_op; + const ty_op = air_datas[@backingInt(inst)].ty_op; const ops = try cg.tempsFromOperands(inst, .{ty_op.operand}); try ops[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, .save_err_return_trace_index => { - const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; + const ty_pl = air_datas[@backingInt(inst)].ty_pl; const agg_ty = ty_pl.ty.toType(); assert(agg_ty.containerLayout(zcu) != .@"packed"); var ert: Temp = .{ .index = err_ret_trace_index }; @@ -173205,7 +173205,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res.finish(inst, &.{}, &.{}, cg); }, .runtime_nav_ptr => { - const ty_nav = air_datas[@intFromEnum(inst)].ty_nav; + const ty_nav = air_datas[@backingInt(inst)].ty_nav; const nav = ip.getNav(ty_nav.nav); const is_threadlocal = zcu.comp.config.any_non_single_threaded and nav.resolved.?.@"threadlocal"; @@ -173250,7 +173250,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .c_va_end => try cg.airVaEnd(inst), .c_va_start => try cg.airVaStart(inst), .legalize_vec_store_elem => { - const pl_op = air_datas[@intFromEnum(inst)].pl_op; + const pl_op = air_datas[@backingInt(inst)].pl_op; const bin = cg.air.extraData(Air.Bin, pl_op.payload).data; // vector_ptr, index, elem_val var ops = try cg.tempsFromOperands(inst, .{ pl_op.operand, bin.lhs, bin.rhs }); @@ -173885,7 +173885,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .work_item_id, .work_group_size, .work_group_id, .spirv_runtime_array_len => unreachable, } - try cg.resetTemps(@enumFromInt(0)); + try cg.resetTemps(@fromBackingInt(@intCast(0))); cg.checkInvariantsAfterAirInst(); } verbose_tracking_log.debug("{f}", .{cg.fmtTracking()}); @@ -174007,7 +174007,7 @@ fn genLazy(cg: *CodeGen, lazy_sym: link.File.LazySymbol) InnerError!void { .{ @tagName(lazy_sym.kind), Type.fromInterned(lazy_sym.ty).fmt(pt) }, ), } - try cg.resetTemps(@enumFromInt(0)); + try cg.resetTemps(@fromBackingInt(@intCast(0))); cg.checkInvariantsAfterAirInst(); } @@ -174059,7 +174059,7 @@ fn processDeath(self: *CodeGen, inst: Air.Inst.Index, comptime opts: FreeOptions } fn finishAirResult(self: *CodeGen, inst: Air.Inst.Index, result: MCValue) void { - if (self.liveness.isUnused(inst) and self.air.instructions.items(.tag)[@intFromEnum(inst)] != .arg) switch (result) { + if (self.liveness.isUnused(inst) and self.air.instructions.items(.tag)[@backingInt(inst)] != .arg) switch (result) { .none, .dead, .unreach => {}, else => unreachable, // Why didn't the result die? } else { @@ -174100,7 +174100,7 @@ fn setFrameLoc( offset: *i32, comptime aligned: bool, ) void { - const frame_i = @intFromEnum(frame_index); + const frame_i = @backingInt(frame_index); if (aligned) { const alignment = self.frame_allocs.items(.abi_align)[frame_i]; offset.* = @intCast(alignment.forward(@intCast(offset.*))); @@ -174120,21 +174120,21 @@ fn computeFrameLayout(self: *CodeGen, cc: std.lang.CallingConvention.Tag) !Frame const frame_offset = self.frame_locs.items(.disp); for (stack_frame_order, FrameIndex.named_count..) |*frame_order, frame_index| - frame_order.* = @enumFromInt(frame_index); + frame_order.* = @fromBackingInt(@intCast(frame_index)); { const SortContext = struct { frame_align: @TypeOf(frame_align), pub fn lessThan(context: @This(), lhs: FrameIndex, rhs: FrameIndex) bool { - return context.frame_align[@intFromEnum(lhs)].compare(.gt, context.frame_align[@intFromEnum(rhs)]); + return context.frame_align[@backingInt(lhs)].compare(.gt, context.frame_align[@backingInt(rhs)]); } }; const sort_context = SortContext{ .frame_align = frame_align }; std.mem.sort(FrameIndex, stack_frame_order, sort_context, SortContext.lessThan); } - const call_frame_align = frame_align[@intFromEnum(FrameIndex.call_frame)]; - const stack_frame_align = frame_align[@intFromEnum(FrameIndex.stack_frame)]; - const args_frame_align = frame_align[@intFromEnum(FrameIndex.args_frame)]; + const call_frame_align = frame_align[@backingInt(FrameIndex.call_frame)]; + const stack_frame_align = frame_align[@backingInt(FrameIndex.stack_frame)]; + const args_frame_align = frame_align[@backingInt(FrameIndex.args_frame)]; const needed_align = call_frame_align.max(stack_frame_align); const need_align_stack = needed_align.compare(.gt, args_frame_align); @@ -174155,7 +174155,7 @@ fn computeFrameLayout(self: *CodeGen, cc: std.lang.CallingConvention.Tag) !Frame const stack_frame_align_offset = if (need_align_stack) 0 else - save_reg_list.size(self.target) + frame_offset[@intFromEnum(FrameIndex.args_frame)]; + save_reg_list.size(self.target) + frame_offset[@backingInt(FrameIndex.args_frame)]; var rsp_offset: i32 = 0; self.setFrameLoc(.call_frame, .rsp, &rsp_offset, true); @@ -174164,23 +174164,23 @@ fn computeFrameLayout(self: *CodeGen, cc: std.lang.CallingConvention.Tag) !Frame rsp_offset += stack_frame_align_offset; rsp_offset = @intCast(needed_align.forward(@intCast(rsp_offset))); rsp_offset -= stack_frame_align_offset; - frame_size[@intFromEnum(FrameIndex.call_frame)] = - @intCast(rsp_offset - frame_offset[@intFromEnum(FrameIndex.stack_frame)]); + frame_size[@backingInt(FrameIndex.call_frame)] = + @intCast(rsp_offset - frame_offset[@backingInt(FrameIndex.stack_frame)]); return .{ - .stack_mask = @as(u32, std.math.maxInt(u32)) << @intCast(if (need_align_stack) @intFromEnum(needed_align) else 0), - .stack_adjust = @intCast(rsp_offset - frame_offset[@intFromEnum(FrameIndex.call_frame)]), + .stack_mask = @as(u32, std.math.maxInt(u32)) << @intCast(if (need_align_stack) @backingInt(needed_align) else 0), + .stack_adjust = @intCast(rsp_offset - frame_offset[@backingInt(FrameIndex.call_frame)]), .save_reg_list = save_reg_list, }; } fn getFrameAddrAlignment(self: *CodeGen, frame_addr: bits.FrameAddr) InternPool.Alignment { - const alloc_align = self.frame_allocs.get(@intFromEnum(frame_addr.index)).abi_align; - return @enumFromInt(@min(@intFromEnum(alloc_align), @ctz(frame_addr.off))); + const alloc_align = self.frame_allocs.get(@backingInt(frame_addr.index)).abi_align; + return @fromBackingInt(@intCast(@min(@backingInt(alloc_align), @ctz(frame_addr.off)))); } fn getFrameAddrSize(self: *CodeGen, frame_addr: bits.FrameAddr) u32 { - return self.frame_allocs.get(@intFromEnum(frame_addr.index)).abi_size - @as(u31, @intCast(frame_addr.off)); + return self.frame_allocs.get(@backingInt(frame_addr.index)).abi_size - @as(u31, @intCast(frame_addr.off)); } fn allocFrameIndex(self: *CodeGen, alloc: FrameAlloc) !FrameIndex { @@ -174188,19 +174188,19 @@ fn allocFrameIndex(self: *CodeGen, alloc: FrameAlloc) !FrameIndex { const frame_size = frame_allocs_slice.items(.abi_size); const frame_align = frame_allocs_slice.items(.abi_align); - const stack_frame_align = &frame_align[@intFromEnum(FrameIndex.stack_frame)]; + const stack_frame_align = &frame_align[@backingInt(FrameIndex.stack_frame)]; stack_frame_align.* = stack_frame_align.max(alloc.abi_align); for (self.free_frame_indices.keys(), 0..) |frame_index, free_i| { - const abi_size = frame_size[@intFromEnum(frame_index)]; + const abi_size = frame_size[@backingInt(frame_index)]; if (abi_size != alloc.abi_size) continue; - const abi_align = &frame_align[@intFromEnum(frame_index)]; + const abi_align = &frame_align[@backingInt(frame_index)]; abi_align.* = abi_align.max(alloc.abi_align); _ = self.free_frame_indices.swapRemoveAt(free_i); return frame_index; } - const frame_index: FrameIndex = @enumFromInt(self.frame_allocs.len); + const frame_index: FrameIndex = @fromBackingInt(@intCast(self.frame_allocs.len)); try self.frame_allocs.append(self.gpa, alloc); return frame_index; } @@ -174318,7 +174318,7 @@ fn initRetroactiveState(self: *CodeGen) State { self.scope_generation = scope_generation; var state: State = undefined; - state.next_temp_index = @enumFromInt(0); + state.next_temp_index = @fromBackingInt(@intCast(0)); state.inst_tracking_len = @intCast(self.inst_tracking.count()); state.scope_generation = scope_generation; return state; @@ -174350,8 +174350,8 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co }) !void { if (opts.close_scope) { for ( - self.inst_tracking.keys()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)], - self.inst_tracking.values()[@intFromEnum(state.next_temp_index)..@intFromEnum(self.next_temp_index)], + self.inst_tracking.keys()[@backingInt(state.next_temp_index)..@backingInt(self.next_temp_index)], + self.inst_tracking.values()[@backingInt(state.next_temp_index)..@backingInt(self.next_temp_index)], ) |inst, *tracking| try tracking.die(self, inst, .{ .emit_instructions = opts.emit_instructions }); self.next_temp_index = state.next_temp_index; for ( @@ -174363,8 +174363,8 @@ fn restoreState(self: *CodeGen, state: State, deaths: []const Air.Inst.Index, co if (opts.resurrect) { for ( - self.inst_tracking.keys()[0..@intFromEnum(state.next_temp_index)], - self.inst_tracking.values()[0..@intFromEnum(state.next_temp_index)], + self.inst_tracking.keys()[0..@backingInt(state.next_temp_index)], + self.inst_tracking.values()[0..@backingInt(state.next_temp_index)], ) |inst, *tracking| try tracking.resurrect(self, inst, state.scope_generation); for ( self.inst_tracking.keys()[Temp.Index.max..state.inst_tracking_len], @@ -176367,10 +176367,10 @@ fn genCall(cg: *CodeGen, info: union(enum) { }); const frame_allocs_slice = cg.frame_allocs.slice(); const stack_frame_size = - &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)]; + &frame_allocs_slice.items(.abi_size)[@backingInt(FrameIndex.call_frame)]; stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size); const stack_frame_align = - &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)]; + &frame_allocs_slice.items(.abi_align)[@backingInt(FrameIndex.call_frame)]; stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align); } @@ -176762,7 +176762,7 @@ fn genCall(cg: *CodeGen, info: union(enum) { } fn airRet(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; const ret_ty = cg.fn_type.fnReturnType(cg.pt.zcu); switch (cg.ret_mcv.short) { @@ -176828,7 +176828,7 @@ fn airRet(cg: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { } fn airRetLoad(cg: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = cg.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = cg.air.instructions.items(.data)[@backingInt(inst)].un_op; switch (cg.ret_mcv.short) { .none => {}, .register, @@ -177341,7 +177341,7 @@ fn lowerSwitchBr( const cc = cc_temp.tracking(cg).short.eflags; try cc_temp.die(cg); try cond_temp.die(cg); - try cg.resetTemps(@enumFromInt(0)); + try cg.resetTemps(@fromBackingInt(@intCast(0))); break :cc cc; }, }; @@ -177394,7 +177394,7 @@ fn lowerSwitchBr( }, }; try cond_temp.die(cg); - try cg.resetTemps(@enumFromInt(0)); + try cg.resetTemps(@fromBackingInt(@intCast(0))); // "Success" case is in `reloc`.... if (lte_max) |cc| { reloc.* = try cg.asmJccReloc(cc, undefined); @@ -177498,7 +177498,7 @@ fn airLoopSwitchBr(self: *CodeGen, inst: Air.Inst.Index) !void { } fn airSwitchDispatch(self: *CodeGen, inst: Air.Inst.Index) !void { - const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = self.air.instructions.items(.data)[@backingInt(inst)].br; const block_ty = self.typeOfIndex(br.block_inst); const loop_data = self.loops.getPtr(br.block_inst).?; @@ -177630,7 +177630,7 @@ fn performReloc(self: *CodeGen, reloc: Mir.Inst.Index) void { fn airBr(self: *CodeGen, inst: Air.Inst.Index) !void { const zcu = self.pt.zcu; - const br = self.air.instructions.items(.data)[@intFromEnum(inst)].br; + const br = self.air.instructions.items(.data)[@backingInt(inst)].br; const block_ty = self.typeOfIndex(br.block_inst); const block_unused = !block_ty.hasRuntimeBits(zcu) or self.liveness.isUnused(br.block_inst); @@ -178498,7 +178498,7 @@ const MoveStrategy = union(enum) { .load_store_x87 => if (dst_reg != .st0 and cg.register_manager.isKnownRegFree(.st7)) { try cg.asmMemory(.{ .f_, .ld }, src_mem); switch (dst_reg) { - .st1, .st2, .st3, .st4, .st5, .st6 => try cg.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)), + .st1, .st2, .st3, .st4, .st5, .st6 => try cg.asmRegister(.{ .f_p, .st }, @fromBackingInt(@intCast(@backingInt(dst_reg) + 1))), .st7 => try cg.asmOpOnly(.{ .f_cstp, .in }), else => unreachable, } @@ -179239,11 +179239,11 @@ fn genSetReg( .st1, .st2, .st3, .st4, .st5, .st6 => switch (dst_reg) { .st0 => { try cg.asmRegister(.{ .f_p, .st }, .st0); - try cg.asmRegister(.{ .f_, .ld }, @enumFromInt(@intFromEnum(src_reg) - 1)); + try cg.asmRegister(.{ .f_, .ld }, @fromBackingInt(@intCast(@backingInt(src_reg) - 1))); }, .st2, .st3, .st4, .st5, .st6 => if (cg.register_manager.isKnownRegFree(.st7)) { try cg.asmRegister(.{ .f_, .ld }, src_reg); - try cg.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1)); + try cg.asmRegister(.{ .f_p, .st }, @fromBackingInt(@intCast(@backingInt(dst_reg) + 1))); } else { try cg.asmRegister(.{ .f_, .xch }, src_reg); try cg.asmRegister(.{ .f_, .xch }, dst_reg); @@ -179802,8 +179802,8 @@ fn genSetMem( const mem_size = switch (base) { .frame => |base_fi| mem_size: { assert(disp >= 0); - const frame_abi_size = cg.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)]; - const frame_spill_pad = cg.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)]; + const frame_abi_size = cg.frame_allocs.items(.abi_size)[@backingInt(base_fi)]; + const frame_spill_pad = cg.frame_allocs.items(.spill_pad)[@backingInt(base_fi)]; assert(frame_abi_size - frame_spill_pad - disp >= abi_size); break :mem_size if (frame_abi_size - frame_spill_pad - disp == abi_size) frame_abi_size else abi_size; }, @@ -180097,7 +180097,7 @@ fn genInlineMemset( fn airBitCast(self: *CodeGen, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const dst_ty = self.typeOfIndex(inst); const src_ty = self.typeOf(ty_op.operand); @@ -180218,7 +180218,7 @@ fn airBitCast(self: *CodeGen, inst: Air.Inst.Index) !void { fn airCmpxchg(self: *CodeGen, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const extra = self.air.extraData(Air.Cmpxchg, ty_pl.payload).data; const dst_ty = self.typeOfIndex(inst); @@ -180673,7 +180673,7 @@ fn atomicOp( } fn airAtomicRmw(self: *CodeGen, inst: Air.Inst.Index) !void { - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.AtomicRmw, pl_op.payload).data; try self.spillRegisters(&.{ .rax, .rdx, .rbx, .rcx }); @@ -180694,7 +180694,7 @@ fn airAtomicRmw(self: *CodeGen, inst: Air.Inst.Index) !void { } fn airAtomicLoad(self: *CodeGen, inst: Air.Inst.Index) !void { - const atomic_load = self.air.instructions.items(.data)[@intFromEnum(inst)].atomic_load; + const atomic_load = self.air.instructions.items(.data)[@backingInt(inst)].atomic_load; const result: MCValue = result: { const ptr_ty = self.typeOf(atomic_load.ptr); const ptr_mcv = try self.resolveInst(atomic_load.ptr); @@ -180721,7 +180721,7 @@ fn airAtomicLoad(self: *CodeGen, inst: Air.Inst.Index) !void { } fn airAtomicStore(self: *CodeGen, inst: Air.Inst.Index, order: std.lang.AtomicOrder) !void { - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; const ptr_ty = self.typeOf(bin_op.lhs); const ptr_mcv = try self.resolveInst(bin_op.lhs); @@ -180736,7 +180736,7 @@ fn airAtomicStore(self: *CodeGen, inst: Air.Inst.Index, order: std.lang.AtomicOr fn airMemset(self: *CodeGen, inst: Air.Inst.Index, safety: bool) !void { const pt = self.pt; const zcu = pt.zcu; - const bin_op = self.air.instructions.items(.data)[@intFromEnum(inst)].bin_op; + const bin_op = self.air.instructions.items(.data)[@backingInt(inst)].bin_op; result: { if (!safety and (try self.resolveInst(bin_op.rhs)) == .undef) break :result; @@ -180879,7 +180879,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; const io = zcu.comp.io; - const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; + const pl_op = self.air.instructions.items(.data)[@backingInt(inst)].pl_op; const extra = self.air.extraData(Air.Bin, pl_op.payload).data; const ty = self.typeOfIndex(inst); const vec_len = ty.vectorLen(zcu); @@ -181351,7 +181351,7 @@ fn airAggregateInitBoolVec(self: *CodeGen, inst: Air.Inst.Index) !void { const zcu = pt.zcu; const result_ty = self.typeOfIndex(inst); const len: usize = @intCast(result_ty.arrayLen(zcu)); - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; + const ty_pl = self.air.instructions.items(.data)[@backingInt(inst)].ty_pl; const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra.items[ty_pl.payload..][0..len]); assert(result_ty.zigTypeTag(zcu) == .vector); @@ -181411,7 +181411,7 @@ fn airAggregateInitBoolVec(self: *CodeGen, inst: Air.Inst.Index) !void { fn airVaStart(self: *CodeGen, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const va_list_ty = self.air.instructions.items(.data)[@intFromEnum(inst)].ty; + const va_list_ty = self.air.instructions.items(.data)[@backingInt(inst)].ty; const ptr_anyopaque_ty = try pt.singleMutPtrType(.anyopaque); const result: MCValue = switch (self.fn_type.fnCallingConvention(zcu)) { @@ -181477,7 +181477,7 @@ fn airVaStart(self: *CodeGen, inst: Air.Inst.Index) !void { fn airVaArg(self: *CodeGen, inst: Air.Inst.Index) !void { const pt = self.pt; const zcu = pt.zcu; - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const ty = self.typeOfIndex(inst); const promote_ty = self.promoteVarArg(ty); const ptr_anyopaque_ty = try pt.singleMutPtrType(.anyopaque); @@ -181705,7 +181705,7 @@ fn convertFloatVarArg( } fn airVaCopy(self: *CodeGen, inst: Air.Inst.Index) !void { - const ty_op = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_op; + const ty_op = self.air.instructions.items(.data)[@backingInt(inst)].ty_op; const ptr_va_list_ty = self.typeOf(ty_op.operand); const dst_mcv = try self.allocRegOrMem(inst, true); @@ -181714,7 +181714,7 @@ fn airVaCopy(self: *CodeGen, inst: Air.Inst.Index) !void { } fn airVaEnd(self: *CodeGen, inst: Air.Inst.Index) !void { - const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; + const un_op = self.air.instructions.items(.data)[@backingInt(inst)].un_op; return self.finishAir(inst, .unreach, .{ un_op, .none, .none }); } @@ -182302,9 +182302,9 @@ fn fail(cg: *CodeGen, comptime format: []const u8, args: anytype) error{ OutOfMe } fn parseRegName(name: []const u8) ?Register { - if (std.mem.startsWith(u8, name, "db")) return @enumFromInt( - @intFromEnum(Register.dr0) + (std.fmt.parseInt(u4, name["db".len..], 0) catch return null), - ); + if (std.mem.startsWith(u8, name, "db")) return @fromBackingInt(@intCast( + @backingInt(Register.dr0) + (std.fmt.parseInt(u4, name["db".len..], 0) catch return null), + )); return std.meta.stringToEnum(Register, name); } @@ -182685,7 +182685,7 @@ const Temp = struct { .ref => |ref| return .{ .ref = ref }, .target => |target_index| { if (temp.index == err_ret_trace_index) return .err_ret_trace; - const temp_index: Index = @enumFromInt(target_index); + const temp_index: Index = @fromBackingInt(@intCast(target_index)); assert(temp_index.isValid(cg)); return .{ .temp = temp_index }; }, @@ -182694,7 +182694,7 @@ const Temp = struct { fn typeOf(temp: Temp, cg: *CodeGen) Type { return switch (temp.unwrap(cg)) { - .ref => switch (cg.air.instructions.items(.tag)[@intFromEnum(temp.index)]) { + .ref => switch (cg.air.instructions.items(.tag)[@backingInt(temp.index)]) { .loop_switch_br => cg.typeOf(cg.air.unwrapSwitch(temp.index).operand), else => cg.air.typeOfIndex(temp.index, &cg.pt.zcu.intern_pool), }, @@ -182754,8 +182754,8 @@ const Temp = struct { fn getOffset(temp: Temp, off: i32, cg: *CodeGen) InnerError!Temp { const new_temp_index = cg.next_temp_index; - cg.temp_type[@intFromEnum(new_temp_index)] = .usize; - cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1); + cg.temp_type[@backingInt(new_temp_index)] = .usize; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(new_temp_index) + 1)); const mcv = temp.tracking(cg).short; switch (mcv) { else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }), @@ -182830,7 +182830,7 @@ const Temp = struct { fn getLimb(temp: Temp, limb_ty: Type, limb_index: u28, cg: *CodeGen) InnerError!Temp { const new_temp_index = cg.next_temp_index; - cg.temp_type[@intFromEnum(new_temp_index)] = limb_ty; + cg.temp_type[@backingInt(new_temp_index)] = limb_ty; switch (temp.tracking(cg).short) { else => |mcv| std.debug.panic("{s}: {f}\n", .{ @src().fn_name, mcv }), .immediate => |imm| { @@ -182941,7 +182941,7 @@ const Temp = struct { new_temp_index.tracking(cg).* = .init(.{ .lea_extern_func = extern_func }); }, } - cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(new_temp_index) + 1)); return .{ .index = new_temp_index.toIndex() }; } @@ -182997,7 +182997,7 @@ const Temp = struct { else => {}, .register, .lea_frame, .lea_nav, .lea_uav, .lea_lazy_sym => { assert(limb_index == 0); - cg.temp_type[@intFromEnum(temp_index)] = limb_ty; + cg.temp_type[@backingInt(temp_index)] = limb_ty; return; }, .register_pair => |regs| { @@ -183009,7 +183009,7 @@ const Temp = struct { for (regs, 0..) |reg, reg_index| if (reg_index != limb_index) cg.register_manager.freeReg(reg); temp_tracking.* = .init(.{ .register = regs[limb_index] }); - cg.temp_type[@intFromEnum(temp_index)] = limb_ty; + cg.temp_type[@backingInt(temp_index)] = limb_ty; return; }, .load_frame => |frame_addr| if (!frame_addr.index.isNamed()) { @@ -183018,7 +183018,7 @@ const Temp = struct { .index = frame_addr.index, .off = frame_addr.off + @as(u31, limb_index) * 8, } }); - cg.temp_type[@intFromEnum(temp_index)] = limb_ty; + cg.temp_type[@backingInt(temp_index)] = limb_ty; return; }, } @@ -183051,9 +183051,9 @@ const Temp = struct { .err_ret_trace => .usize, }; const new_temp_index = cg.next_temp_index; - cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(new_temp_index) + 1)); try cg.register_manager.getReg(new_reg, new_temp_index.toIndex()); - cg.temp_type[@intFromEnum(new_temp_index)] = ty; + cg.temp_type[@backingInt(new_temp_index)] = ty; new_temp_index.tracking(cg).* = .init(.{ .register = new_reg }); while (try temp.toBase(false, cg)) {} try temp.readTo(ty, .{ .register = new_reg }, .{}, cg); @@ -183074,9 +183074,9 @@ const Temp = struct { .err_ret_trace => .usize, }; const new_temp_index = cg.next_temp_index; - cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(new_temp_index) + 1)); for (new_regs) |new_reg| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex()); - cg.temp_type[@intFromEnum(new_temp_index)] = ty; + cg.temp_type[@backingInt(new_temp_index)] = ty; new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs }); while (try temp.toBase(false, cg)) {} for (new_regs, 0..) |new_reg, reg_index| try temp.readTo( @@ -183099,12 +183099,12 @@ const Temp = struct { }; const ty = temp.typeOf(cg); const new_temp_index = cg.next_temp_index; - cg.temp_type[@intFromEnum(new_temp_index)] = ty; + cg.temp_type[@backingInt(new_temp_index)] = ty; const new_reg = try cg.register_manager.allocReg(new_temp_index.toIndex(), regSetForRegClass(rc)); try cg.genSetReg(new_reg, ty, val, .{}); new_temp_index.tracking(cg).* = .init(.{ .register = new_reg }); try temp.die(cg); - cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(new_temp_index) + 1)); temp.* = .{ .index = new_temp_index.toIndex() }; return true; } @@ -183124,8 +183124,8 @@ const Temp = struct { assert(cg.reuseTemp(result_temp.index, first_temp.index, first_temp_tracking)); assert(cg.reuseTemp(result_temp.index, second_temp.index, second_temp_tracking)); result_temp_index.tracking(cg).* = .init(result); - cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8; - cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1); + cg.temp_type[@backingInt(result_temp_index)] = .slice_const_u8; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(result_temp_index) + 1)); first_temp.* = result_temp; second_temp.* = result_temp; } @@ -183142,8 +183142,8 @@ const Temp = struct { assert(cg.reuseTemp(result_temp.index, temp.index, temp_tracking)); assert(cg.reuseTemp(result_temp.index, overflow_temp.index, overflow_temp_tracking)); result_temp_index.tracking(cg).* = .init(.{ .register_overflow = .{ .reg = reg, .eflags = overflow_cc } }); - cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8; - cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1); + cg.temp_type[@backingInt(result_temp_index)] = .slice_const_u8; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(result_temp_index) + 1)); temp.* = result_temp; overflow_temp.* = result_temp; return; @@ -183154,8 +183154,8 @@ const Temp = struct { assert(cg.reuseTemp(result_temp.index, temp.index, temp_tracking)); assert(cg.reuseTemp(result_temp.index, overflow_temp.index, overflow_temp_tracking)); result_temp_index.tracking(cg).* = .init(.{ .register_pair = .{ reg, overflow_reg } }); - cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8; - cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1); + cg.temp_type[@backingInt(result_temp_index)] = .slice_const_u8; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(result_temp_index) + 1)); temp.* = result_temp; overflow_temp.* = result_temp; return; @@ -183231,12 +183231,12 @@ const Temp = struct { if ((!mut or temp.isMut(cg)) and temp_tracking.short.isMemory()) return false; const new_temp_index = cg.next_temp_index; const ty = temp.typeOf(cg); - cg.temp_type[@intFromEnum(new_temp_index)] = ty; + cg.temp_type[@backingInt(new_temp_index)] = ty; const new_frame_index = try cg.allocFrameIndex(.initSpill(ty, cg.pt.zcu)); try cg.genSetMem(.{ .frame = new_frame_index }, 0, ty, temp_tracking.short, .{}); new_temp_index.tracking(cg).* = .init(.{ .load_frame = .{ .index = new_frame_index } }); try temp.die(cg); - cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(new_temp_index) + 1)); temp.* = .{ .index = new_temp_index.toIndex() }; return true; } @@ -183247,13 +183247,13 @@ const Temp = struct { if ((!mut or temp.isMut(cg)) and temp_tracking.short.isBase()) return false; if (try temp.toMemory(mut, cg)) return true; const new_temp_index = cg.next_temp_index; - cg.temp_type[@intFromEnum(new_temp_index)] = temp.typeOf(cg); + cg.temp_type[@backingInt(new_temp_index)] = temp.typeOf(cg); const new_reg = try cg.register_manager.allocReg(new_temp_index.toIndex(), abi.RegisterClass.gp); try cg.genSetReg(new_reg, .usize, temp_tracking.short.address(), .{}); new_temp_index.tracking(cg).* = .init(.{ .indirect = .{ .reg = new_reg } }); try temp.die(cg); - cg.next_temp_index = @enumFromInt(@intFromEnum(new_temp_index) + 1); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(new_temp_index) + 1)); temp.* = .{ .index = new_temp_index.toIndex() }; return true; } @@ -189703,25 +189703,25 @@ const Temp = struct { _, fn toIndex(index: Index) Air.Inst.Index { - return .fromTargetIndex(@intFromEnum(index)); + return .fromTargetIndex(@backingInt(index)); } fn fromIndex(index: Air.Inst.Index) Index { - return @enumFromInt(index.toTargetIndex()); + return @fromBackingInt(@intCast(index.toTargetIndex())); } fn tracking(index: Index, cg: *CodeGen) *InstTracking { - return &cg.inst_tracking.values()[@intFromEnum(index)]; + return &cg.inst_tracking.values()[@backingInt(index)]; } fn isValid(index: Index, cg: *CodeGen) bool { - return @intFromEnum(index) < @intFromEnum(cg.next_temp_index) and + return @backingInt(index) < @backingInt(cg.next_temp_index) and index.tracking(cg).short != .dead; } fn typeOf(index: Index, cg: *CodeGen) Type { assert(index.isValid(cg)); - return cg.temp_type[@intFromEnum(index)]; + return cg.temp_type[@backingInt(index)]; } const max = std.math.maxInt(@typeInfo(Index).@"enum".tag_type); @@ -189747,8 +189747,8 @@ const Temp = struct { fn resetTemps(cg: *CodeGen, from_index: Temp.Index) InnerError!void { var any_valid = false; - for (@intFromEnum(from_index)..@intFromEnum(cg.next_temp_index)) |temp_index| { - const temp: Temp.Index = @enumFromInt(temp_index); + for (@backingInt(from_index)..@backingInt(cg.next_temp_index)) |temp_index| { + const temp: Temp.Index = @fromBackingInt(@intCast(temp_index)); if (temp.isValid(cg)) { any_valid = true; tracking_log.err("failed to kill {f}: {f}", .{ @@ -189796,8 +189796,8 @@ fn tempAlloc(cg: *CodeGen, ty: Type) InnerError!Temp { temp_index.tracking(cg).* = .init( try cg.allocRegOrMemAdvanced(ty, temp_index.toIndex(), true), ); - cg.temp_type[@intFromEnum(temp_index)] = ty; - cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1); + cg.temp_type[@backingInt(temp_index)] = ty; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(temp_index) + 1)); return .{ .index = temp_index.toIndex() }; } @@ -189806,8 +189806,8 @@ fn tempAllocReg(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) Inne temp_index.tracking(cg).* = .init( .{ .register = try cg.register_manager.allocReg(temp_index.toIndex(), rs) }, ); - cg.temp_type[@intFromEnum(temp_index)] = ty; - cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1); + cg.temp_type[@backingInt(temp_index)] = ty; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(temp_index) + 1)); return .{ .index = temp_index.toIndex() }; } @@ -189816,8 +189816,8 @@ fn tempAllocRegPair(cg: *CodeGen, ty: Type, rs: RegisterManager.RegisterBitSet) temp_index.tracking(cg).* = .init( .{ .register_pair = try cg.register_manager.allocRegs(2, @splat(temp_index.toIndex()), rs) }, ); - cg.temp_type[@intFromEnum(temp_index)] = ty; - cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1); + cg.temp_type[@backingInt(temp_index)] = ty; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(temp_index) + 1)); return .{ .index = temp_index.toIndex() }; } @@ -189826,17 +189826,17 @@ fn tempAllocMem(cg: *CodeGen, ty: Type) InnerError!Temp { temp_index.tracking(cg).* = .init( try cg.allocRegOrMemAdvanced(ty, temp_index.toIndex(), false), ); - cg.temp_type[@intFromEnum(temp_index)] = ty; - cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1); + cg.temp_type[@backingInt(temp_index)] = ty; + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(temp_index) + 1)); return .{ .index = temp_index.toIndex() }; } fn tempInit(cg: *CodeGen, ty: Type, value: MCValue) InnerError!Temp { const temp_index = cg.next_temp_index; temp_index.tracking(cg).* = .init(value); - cg.temp_type[@intFromEnum(temp_index)] = ty; + cg.temp_type[@backingInt(temp_index)] = ty; try cg.getValue(value, temp_index.toIndex()); - cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(temp_index) + 1)); return .{ .index = temp_index.toIndex() }; } @@ -189870,8 +189870,8 @@ fn tempFromOperand(cg: *CodeGen, op_ref: Air.Inst.Ref, op_dies: bool) InnerError const tracking = cg.getResolvedInstValue(op_inst); temp_index.tracking(cg).* = tracking.*; if (!cg.reuseTemp(temp.index, op_inst, tracking)) return .{ .index = op_ref.toIndex().? }; - cg.temp_type[@intFromEnum(temp_index)] = cg.typeOf(op_ref); - cg.next_temp_index = @enumFromInt(@intFromEnum(temp_index) + 1); + cg.temp_type[@backingInt(temp_index)] = cg.typeOf(op_ref); + cg.next_temp_index = @fromBackingInt(@intCast(@backingInt(temp_index) + 1)); return temp; } @@ -189910,9 +189910,9 @@ const Operand = union(enum) { const Select = struct { cg: *CodeGen, - types: [@intFromEnum(Select.Operand.Ref.none)]Type, - temps: [@intFromEnum(Select.Operand.Ref.none)]Temp, - labels: [@intFromEnum(Label._)]struct { + types: [@backingInt(Select.Operand.Ref.none)]Type, + temps: [@backingInt(Select.Operand.Ref.none)]Temp, + labels: [@backingInt(Label._)]struct { backward: ?Mir.Inst.Index, forward: [3]?Mir.Inst.Index, }, @@ -189921,8 +189921,8 @@ const Select = struct { const Error = InnerError || error{SelectFailed}; fn emitLabel(s: *Select, label_index: Label) void { - assert(@intFromEnum(label_index) < @intFromEnum(Label._)); - const label = &s.labels[@intFromEnum(label_index)]; + assert(@backingInt(label_index) < @backingInt(Label._)); + const label = &s.labels[@backingInt(label_index)]; for (&label.forward) |*reloc| { if (reloc.*) |r| s.cg.performReloc(r); reloc.* = null; @@ -190072,19 +190072,19 @@ const Select = struct { } fn lowerReg(s: *const Select, reg: Register) Register { - return if (reg.isClass(.x87)) @enumFromInt(@intFromEnum(Register.st0) + (@as(u3, @intCast(reg.enc())) -% s.top)) else reg; + return if (reg.isClass(.x87)) @fromBackingInt(@intCast(@backingInt(Register.st0) + (@as(u3, @intCast(reg.enc())) -% s.top))) else reg; } const Case = struct { required_abi: enum { any, gnu, msvc } = .any, required_cc_abi: enum { any, sysv64, win64 } = .any, required_features: [4]?std.Target.x86.Feature = @splat(null), - src_constraints: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Constraint = @splat(.any), - dst_constraints: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]Constraint = @splat(.any), + src_constraints: [@backingInt(Select.Operand.Ref.none) - @backingInt(Select.Operand.Ref.src0)]Constraint = @splat(.any), + dst_constraints: [@backingInt(Select.Operand.Ref.src0) - @backingInt(Select.Operand.Ref.dst0)]Constraint = @splat(.any), patterns: []const Select.Pattern, call_frame: packed struct(u16) { size: u10 = 0, alignment: InternPool.Alignment } = .{ .size = 0, .alignment = .none }, - extra_temps: [@intFromEnum(Select.Operand.Ref.dst0) - @intFromEnum(Select.Operand.Ref.tmp0)]TempSpec = @splat(.unused), - dst_temps: [@intFromEnum(Select.Operand.Ref.src0) - @intFromEnum(Select.Operand.Ref.dst0)]TempSpec.Kind = @splat(.unused), + extra_temps: [@backingInt(Select.Operand.Ref.dst0) - @backingInt(Select.Operand.Ref.tmp0)]TempSpec = @splat(.unused), + dst_temps: [@backingInt(Select.Operand.Ref.src0) - @backingInt(Select.Operand.Ref.dst0)]TempSpec.Kind = @splat(.unused), clobbers: packed struct { eflags: bool = false, caller_preserved: CallConv = .none, @@ -190452,7 +190452,7 @@ const Select = struct { }; const Pattern = struct { - src: [@intFromEnum(Select.Operand.Ref.none) - @intFromEnum(Select.Operand.Ref.src0)]Src, + src: [@backingInt(Select.Operand.Ref.none) - @backingInt(Select.Operand.Ref.src0)]Src, commute: struct { u8, u8 } = .{ 0, 0 }, const Src = union(enum) { @@ -191203,7 +191203,7 @@ const Select = struct { else => {}, inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, cg), } - cg.temp_type[@intFromEnum(temp.unwrap(cg).temp)] = spec.type; + cg.temp_type[@backingInt(temp.unwrap(cg).temp)] = spec.type; } }; @@ -191602,17 +191602,17 @@ const Select = struct { }; fn typeOf(ref: Ref, s: *const Select) Type { - return s.types[@intFromEnum(ref)]; + return s.types[@backingInt(ref)]; } fn tempOf(ref: Ref, s: *const Select) Temp { - return s.temps[@intFromEnum(ref)]; + return s.temps[@backingInt(ref)]; } fn valueOf(ref: Ref, s: *const Select) MCValue { return switch (ref) { .none => .none, - else => s.temps[@intFromEnum(ref)].tracking(s.cg).short, + else => s.temps[@backingInt(ref)].tracking(s.cg).short, }; } }; @@ -192281,7 +192281,7 @@ const Select = struct { Select.Operand.Ref.src1.valueOf(s).immediate), .vector_index => switch (op.flags.base.ref.typeOf(s).ptrInfo(s.cg.pt.zcu).flags.vector_index) { .none => unreachable, - else => |vector_index| @intFromEnum(vector_index), + else => |vector_index| @backingInt(vector_index), }, .src1 => @intCast(Select.Operand.Ref.src1.valueOf(s).immediate), .src1_sub_bit_size => @as(SignedImm, @intCast(Select.Operand.Ref.src1.valueOf(s).immediate)) - @@ -192465,14 +192465,14 @@ fn select( if (case.call_frame.alignment != .none) { const frame_allocs_slice = cg.frame_allocs.slice(); const stack_frame_size = - &frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)]; + &frame_allocs_slice.items(.abi_size)[@backingInt(FrameIndex.call_frame)]; stack_frame_size.* = @max(stack_frame_size.*, switch (cg.target.cCallingConvention().?) { .x86_64_sysv => case.call_frame.size, .x86_64_win => win64_shadow_space + case.call_frame.size, else => unreachable, }); const stack_frame_align = - &frame_allocs_slice.items(.abi_align)[@intFromEnum(FrameIndex.call_frame)]; + &frame_allocs_slice.items(.abi_align)[@backingInt(FrameIndex.call_frame)]; stack_frame_align.* = stack_frame_align.max(case.call_frame.alignment); } @@ -192483,12 +192483,12 @@ fn select( .labels = @splat(.{ .forward = @splat(null), .backward = null }), .top = 0, }; - const s_tmp_types = s.types[@intFromEnum(Select.Operand.Ref.tmp0)..@intFromEnum(Select.Operand.Ref.dst0)]; - const s_tmp_temps = s.temps[@intFromEnum(Select.Operand.Ref.tmp0)..@intFromEnum(Select.Operand.Ref.dst0)]; - const s_dst_types = s.types[@intFromEnum(Select.Operand.Ref.dst0)..@intFromEnum(Select.Operand.Ref.src0)]; - const s_dst_temps = s.temps[@intFromEnum(Select.Operand.Ref.dst0)..@intFromEnum(Select.Operand.Ref.src0)]; - const s_src_types = s.types[@intFromEnum(Select.Operand.Ref.src0)..@intFromEnum(Select.Operand.Ref.none)]; - const s_src_temps = s.temps[@intFromEnum(Select.Operand.Ref.src0)..@intFromEnum(Select.Operand.Ref.none)]; + const s_tmp_types = s.types[@backingInt(Select.Operand.Ref.tmp0)..@backingInt(Select.Operand.Ref.dst0)]; + const s_tmp_temps = s.temps[@backingInt(Select.Operand.Ref.tmp0)..@backingInt(Select.Operand.Ref.dst0)]; + const s_dst_types = s.types[@backingInt(Select.Operand.Ref.dst0)..@backingInt(Select.Operand.Ref.src0)]; + const s_dst_temps = s.temps[@backingInt(Select.Operand.Ref.dst0)..@backingInt(Select.Operand.Ref.src0)]; + const s_src_types = s.types[@backingInt(Select.Operand.Ref.src0)..@backingInt(Select.Operand.Ref.none)]; + const s_src_temps = s.temps[@backingInt(Select.Operand.Ref.src0)..@backingInt(Select.Operand.Ref.none)]; for (s_tmp_types, case.extra_temps) |*ty, spec| ty.* = spec.type; @memcpy(s_dst_types[0..dst_tys.len], dst_tys); diff --git a/src/codegen/x86_64/Disassembler.zig b/src/codegen/x86_64/Disassembler.zig index 7aeb06f9638fccd2db163c4ad137ee228c455cfb..4cbd66e9c834dd4efae40c438679e505c8632112 100644 --- a/src/codegen/x86_64/Disassembler.zig +++ b/src/codegen/x86_64/Disassembler.zig @@ -379,7 +379,7 @@ fn parseEncoding(dis: *Disassembler, prefixes: Prefixes) !?Encoding { fn parseGpRegister(low_enc: u3, is_extended: bool, rex: Rex, bit_size: u64) Register { const reg_id: u4 = @as(u4, @intCast(@intFromBool(is_extended))) << 3 | low_enc; - const reg = @as(Register, @enumFromInt(reg_id)).toBitSize(bit_size); + const reg = @as(Register, @fromBackingInt(@intCast(reg_id))).toBitSize(bit_size); return switch (reg) { .spl => if (rex.present or rex.isSet()) .spl else .ah, .dil => if (rex.present or rex.isSet()) .dil else .bh, diff --git a/src/codegen/x86_64/Emit.zig b/src/codegen/x86_64/Emit.zig index d5ec79ce22a8f650992ae77567b3d9f303dd2b82..0852a6d5ce77f5d40e20149e5cac7b15d64ea3b3 100644 --- a/src/codegen/x86_64/Emit.zig +++ b/src/codegen/x86_64/Emit.zig @@ -135,33 +135,33 @@ pub fn emitMir(emit: *Emit) Error!void { } }, .lazy_sym => |lazy_sym| .{ .symbol = .{ .symbol = if (emit.bin_file.cast(.elf)) |elf_file| - @enumFromInt( + @fromBackingInt(@intCast( elf_file.zigObjectPtr().?.getOrCreateMetadataForLazySymbol(elf_file, emit.pt, lazy_sym) catch |err| return emit.fail("{s} creating lazy symbol", .{@errorName(err)}), - ) + )) else if (emit.bin_file.cast(.elf2)) |elf| try elf.lazySymbol(lazy_sym) else if (emit.bin_file.cast(.macho)) |macho_file| - @enumFromInt(macho_file.getZigObject().?.getOrCreateMetadataForLazySymbol(macho_file, emit.pt, lazy_sym) catch |err| - return emit.fail("{s} creating lazy symbol", .{@errorName(err)})) + @fromBackingInt(@intCast(macho_file.getZigObject().?.getOrCreateMetadataForLazySymbol(macho_file, emit.pt, lazy_sym) catch |err| + return emit.fail("{s} creating lazy symbol", .{@errorName(err)}))) else if (emit.bin_file.cast(.coff2)) |coff| - @enumFromInt(@intFromEnum(try coff.lazySymbol(lazy_sym))) + @fromBackingInt(@intCast(@backingInt(try coff.lazySymbol(lazy_sym)))) else return emit.fail("lazy symbols unimplemented for {s}", .{@tagName(emit.bin_file.tag)}), .is_extern = false, } }, .extern_func => |extern_func| .{ .symbol = .{ .symbol = if (emit.bin_file.cast(.elf)) |elf_file| - @enumFromInt(try elf_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null)) + @fromBackingInt(@intCast(try elf_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null))) else if (emit.bin_file.cast(.elf2)) |elf| try elf.externSymbol(.{ .name = extern_func.toSlice(&emit.lower.mir).?, .lib_name = null, .type = .FUNC, }) else if (emit.bin_file.cast(.macho)) |macho_file| - @enumFromInt(try macho_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null)) - else if (emit.bin_file.cast(.coff2)) |coff| @enumFromInt(@intFromEnum(try coff.globalSymbol(.{ + @fromBackingInt(@intCast(try macho_file.getGlobalSymbol(extern_func.toSlice(&emit.lower.mir).?, null))) + else if (emit.bin_file.cast(.coff2)) |coff| @fromBackingInt(@intCast(@backingInt(try coff.globalSymbol(.{ .name = extern_func.toSlice(&emit.lower.mir).?, - }))) else return emit.fail("external symbol unimplemented for {s}", .{@tagName(emit.bin_file.tag)}), + })))) else return emit.fail("external symbol unimplemented for {s}", .{@tagName(emit.bin_file.tag)}), .is_extern = true, } }, }, @@ -309,10 +309,10 @@ pub fn emitMir(emit: *Emit) Error!void { }, emit.lower.target), &.{.{ .op_index = 0, .target = .{ .branch = .{ - .symbol = if (emit.bin_file.cast(.elf)) |elf_file| @enumFromInt(try elf_file.getGlobalSymbol( + .symbol = if (emit.bin_file.cast(.elf)) |elf_file| @fromBackingInt(@intCast(try elf_file.getGlobalSymbol( "__tls_get_addr", if (comp.config.link_libc) "c" else null, - )) else if (emit.bin_file.cast(.elf2)) |elf| try elf.externSymbol(.{ + ))) else if (emit.bin_file.cast(.elf2)) |elf| try elf.externSymbol(.{ .name = "__tls_get_addr", .lib_name = if (comp.config.link_libc) "c" else null, .type = .FUNC, @@ -391,9 +391,9 @@ pub fn emitMir(emit: *Emit) Error!void { }, emit.lower.target), &.{.{ .op_index = 1, .target = .{ .symbol = .{ - .symbol = @enumFromInt(@intFromEnum( + .symbol = @fromBackingInt(@intCast(@backingInt( try coff.globalSymbol(.{ .name = "__tls_index" }), - )), + ))), .is_extern = false, } }, }}); @@ -426,9 +426,9 @@ pub fn emitMir(emit: *Emit) Error!void { }, emit.lower.target), &.{.{ .op_index = 1, .target = .{ .symbol = .{ - .symbol = @enumFromInt(@intFromEnum( + .symbol = @fromBackingInt(@intCast(@backingInt( try coff.globalSymbol(.{ .name = "_tls_index" }), - )), + ))), .is_extern = false, } }, }}); @@ -680,17 +680,17 @@ pub fn emitMir(emit: *Emit) Error!void { var table_offset = std.mem.alignForward(u32, @intCast(emit.w.end), ptr_size); if (emit.bin_file.cast(.elf)) |elf_file| { const zo = elf_file.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(emit.atom_id)).atom(elf_file).?; + const atom = zo.symbol(@backingInt(emit.atom_id)).atom(elf_file).?; for (emit.table_relocs.items) |table_reloc| try atom.addReloc(gpa, .{ .r_offset = table_reloc.source_offset, - .r_info = @as(u64, @intFromEnum(emit.atom_id)) << 32 | @intFromEnum(std.elf.R_X86_64.@"32S"), + .r_info = @as(u64, @backingInt(emit.atom_id)) << 32 | @backingInt(std.elf.R_X86_64.@"32S"), .r_addend = @as(i64, table_offset) + table_reloc.target_offset, }, zo); for (emit.lower.mir.table) |entry| { try atom.addReloc(gpa, .{ .r_offset = table_offset, - .r_info = @as(u64, @intFromEnum(emit.atom_id)) << 32 | @intFromEnum(std.elf.R_X86_64.@"64"), + .r_info = @as(u64, @backingInt(emit.atom_id)) << 32 | @backingInt(std.elf.R_X86_64.@"64"), .r_addend = emit.code_offset_mapping.items[entry], }, zo); table_offset += ptr_size; @@ -793,7 +793,7 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI }), .symbol => |target| if (emit.bin_file.cast(.elf)) |elf_file| { const zo = elf_file.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(emit.atom_id)).atom(elf_file).?; + const atom = zo.symbol(@backingInt(emit.atom_id)).atom(elf_file).?; const r_type: std.elf.R_X86_64 = if (!emit.pic) .@"32S" else if (target.is_extern and !target.force_pcrel_direct) @@ -802,23 +802,23 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI .PC32; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @intFromEnum(target.symbol)) << 32 | @intFromEnum(r_type), + .r_info = @as(u64, @backingInt(target.symbol)) << 32 | @backingInt(r_type), .r_addend = if (emit.pic) reloc.off - 4 else reloc.off, }, zo); } else if (emit.bin_file.cast(.macho)) |macho_file| { const zo = macho_file.getZigObject().?; - const atom = zo.symbols.items[@intFromEnum(emit.atom_id)].getAtom(macho_file).?; + const atom = zo.symbols.items[@backingInt(emit.atom_id)].getAtom(macho_file).?; try atom.addReloc(macho_file, .{ .tag = .@"extern", .offset = end_offset - 4, - .target = @intFromEnum(target.symbol), + .target = @backingInt(target.symbol), .addend = reloc.off, .type = if (target.is_extern and !target.force_pcrel_direct) .got_load else .signed, .meta = .{ .pcrel = true, .has_subtractor = false, .length = 2, - .symbolnum = @intCast(@intFromEnum(target.symbol)), + .symbolnum = @intCast(@backingInt(target.symbol)), }, }); } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc( @@ -832,19 +832,19 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI break :rt .PC32; } }, ) else if (emit.bin_file.cast(.coff2)) |coff| try coff.addReloc( - @enumFromInt(@intFromEnum(emit.atom_id)), + @fromBackingInt(@intCast(@backingInt(emit.atom_id))), end_offset - 4, - @enumFromInt(@intFromEnum(target.symbol)), + @fromBackingInt(@intCast(@backingInt(target.symbol))), .{ .known = reloc.off }, .{ .AMD64 = .REL32 }, ) else unreachable, .branch => |target| if (emit.bin_file.cast(.elf)) |elf_file| { const zo = elf_file.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(emit.atom_id)).atom(elf_file).?; + const atom = zo.symbol(@backingInt(emit.atom_id)).atom(elf_file).?; const r_type: std.elf.R_X86_64 = .PLT32; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @intFromEnum(target.symbol)) << 32 | @intFromEnum(r_type), + .r_info = @as(u64, @backingInt(target.symbol)) << 32 | @backingInt(r_type), .r_addend = reloc.off - 4, }, zo); } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc( @@ -855,24 +855,24 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI .{ .X86_64 = .PLT32 }, ) else if (emit.bin_file.cast(.macho)) |macho_file| { const zo = macho_file.getZigObject().?; - const atom = zo.symbols.items[@intFromEnum(emit.atom_id)].getAtom(macho_file).?; + const atom = zo.symbols.items[@backingInt(emit.atom_id)].getAtom(macho_file).?; try atom.addReloc(macho_file, .{ .tag = .@"extern", .offset = end_offset - 4, - .target = @intFromEnum(target.symbol), + .target = @backingInt(target.symbol), .addend = reloc.off, .type = .branch, .meta = .{ .pcrel = true, .has_subtractor = false, .length = 2, - .symbolnum = @intCast(@intFromEnum(target.symbol)), + .symbolnum = @intCast(@backingInt(target.symbol)), }, }); } else if (emit.bin_file.cast(.coff2)) |coff| try coff.addReloc( - @enumFromInt(@intFromEnum(emit.atom_id)), + @fromBackingInt(@intCast(@backingInt(emit.atom_id))), end_offset - 4, - @enumFromInt(@intFromEnum(target.symbol)), + @fromBackingInt(@intCast(@backingInt(target.symbol))), .{ .known = reloc.off }, .{ .AMD64 = .REL32 }, ) else return emit.fail("TODO implement {s} reloc for {s}", .{ @@ -880,11 +880,11 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI }), .tls => |target_symbol| if (emit.bin_file.cast(.elf)) |elf_file| { const zo = elf_file.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(emit.atom_id)).atom(elf_file).?; + const atom = zo.symbol(@backingInt(emit.atom_id)).atom(elf_file).?; const r_type: std.elf.R_X86_64 = if (emit.pic) .TLSLD else unreachable; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @intFromEnum(target_symbol)) << 32 | @intFromEnum(r_type), + .r_info = @as(u64, @backingInt(target_symbol)) << 32 | @backingInt(r_type), .r_addend = reloc.off - 4, }, zo); } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc( @@ -898,11 +898,11 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI }), .tlv => |target| if (emit.bin_file.cast(.elf)) |elf_file| { const zo = elf_file.zigObjectPtr().?; - const atom = zo.symbol(@intFromEnum(emit.atom_id)).atom(elf_file).?; + const atom = zo.symbol(@backingInt(emit.atom_id)).atom(elf_file).?; const r_type: std.elf.R_X86_64 = if (emit.pic) .DTPOFF32 else .TPOFF32; try atom.addReloc(gpa, .{ .r_offset = end_offset - 4, - .r_info = @as(u64, @intFromEnum(target.symbol)) << 32 | @intFromEnum(r_type), + .r_info = @as(u64, @backingInt(target.symbol)) << 32 | @backingInt(r_type), .r_addend = reloc.off, }, zo); } else if (emit.bin_file.cast(.elf2)) |elf| try elf.addReloc( @@ -913,24 +913,24 @@ fn encodeInst(emit: *Emit, lowered_inst: Instruction, reloc_info: []const RelocI .{ .X86_64 = if (emit.pic) .DTPOFF32 else .TPOFF32 }, ) else if (emit.bin_file.cast(.macho)) |macho_file| { const zo = macho_file.getZigObject().?; - const atom = zo.symbols.items[@intFromEnum(emit.atom_id)].getAtom(macho_file).?; + const atom = zo.symbols.items[@backingInt(emit.atom_id)].getAtom(macho_file).?; try atom.addReloc(macho_file, .{ .tag = .@"extern", .offset = end_offset - 4, - .target = @intFromEnum(target.symbol), + .target = @backingInt(target.symbol), .addend = reloc.off, .type = .tlv, .meta = .{ .pcrel = true, .has_subtractor = false, .length = 2, - .symbolnum = @intCast(@intFromEnum(target.symbol)), + .symbolnum = @intCast(@backingInt(target.symbol)), }, }); } else if (emit.bin_file.cast(.coff2)) |coff| try coff.addReloc( - @enumFromInt(@intFromEnum(emit.atom_id)), + @fromBackingInt(@intCast(@backingInt(emit.atom_id))), end_offset - 4, - @enumFromInt(@intFromEnum(target.symbol)), + @fromBackingInt(@intCast(@backingInt(target.symbol))), .{ .known = reloc.off }, .{ .AMD64 = .SECREL }, ) else return emit.fail("TODO implement {s} reloc for {s}", .{ diff --git a/src/codegen/x86_64/Encoding.zig b/src/codegen/x86_64/Encoding.zig index 8115efeee563a37c95eb8713fe42c41942ab44f8..c62f558b7cfec6167ff35fc087244c1bc602b263 100644 --- a/src/codegen/x86_64/Encoding.zig +++ b/src/codegen/x86_64/Encoding.zig @@ -57,7 +57,7 @@ pub fn findByMnemonic( var shortest_enc: ?Encoding = null; var shortest_len: ?usize = null; - next: for (mnemonic_to_encodings_map[@intFromEnum(mnemonic)]) |data| { + next: for (mnemonic_to_encodings_map[@backingInt(mnemonic)]) |data| { if (!switch (data.feature) { .none => true, .@"32bit" => switch (target.cpu.arch) { @@ -122,7 +122,7 @@ pub fn findByOpcode(opc: []const u8, prefixes: struct { rex: Rex, }, modrm_ext: ?u3) ?Encoding { for (mnemonic_to_encodings_map, 0..) |encs, mnemonic_int| for (encs) |data| { - const enc = Encoding{ .mnemonic = @as(Mnemonic, @enumFromInt(mnemonic_int)), .data = data }; + const enc = Encoding{ .mnemonic = @as(Mnemonic, @fromBackingInt(@intCast(mnemonic_int))), .data = data }; if (modrm_ext) |ext| if (ext != data.modrm_ext) continue; if (!std.mem.eql(u8, opc, enc.opcode())) continue; if (prefixes.rex.w) { @@ -1030,7 +1030,7 @@ const mnemonic_to_encodings_map = init: { const mnemonic_count = @typeInfo(Mnemonic).@"enum".field_names.len; var mnemonic_map: [mnemonic_count][]Data = @splat(&.{}); - for (encodings) |entry| mnemonic_map[@intFromEnum(entry[0])].len += 1; + for (encodings) |entry| mnemonic_map[@backingInt(entry[0])].len += 1; var data_storage: [encodings.len]Data = undefined; var storage_index: usize = 0; for (&mnemonic_map) |*value| { @@ -1041,8 +1041,8 @@ const mnemonic_to_encodings_map = init: { const ops_len = @typeInfo(@FieldType(Data, "ops")).array.len; const opc_len = @typeInfo(@FieldType(Data, "opc")).array.len; for (encodings) |entry| { - const index = &mnemonic_index[@intFromEnum(entry[0])]; - mnemonic_map[@intFromEnum(entry[0])][index.*] = .{ + const index = &mnemonic_index[@backingInt(entry[0])]; + mnemonic_map[@backingInt(entry[0])][index.*] = .{ .op_en = entry[1], .ops = ops: { var ops: [ops_len]Op = @splat(.none); diff --git a/src/codegen/x86_64/Lower.zig b/src/codegen/x86_64/Lower.zig index 9cf97cc7caefce9cb5ce2cd2d31765a23ccb54c4..f471d990d1f19bd10d120d2d69f53266ab5538d3 100644 --- a/src/codegen/x86_64/Lower.zig +++ b/src/codegen/x86_64/Lower.zig @@ -433,7 +433,7 @@ const mnemonic_table: [inst_tags_len * inst_fixes_len]?Mnemonic = table: { @setEvalBranchQuota(80_000); var table: [inst_tags_len * inst_fixes_len]?Mnemonic = undefined; for (0..inst_fixes_len) |fixes_i| { - const fixes: Mir.Inst.Fixes = @enumFromInt(fixes_i); + const fixes: Mir.Inst.Fixes = @fromBackingInt(@intCast(fixes_i)); const prefix, const suffix = affix: { const pattern = if (std.mem.indexOfScalar(u8, @tagName(fixes), ' ')) |i| @tagName(fixes)[i + 1 ..] @@ -443,7 +443,7 @@ const mnemonic_table: [inst_tags_len * inst_fixes_len]?Mnemonic = table: { break :affix .{ pattern[0..wildcard_idx], pattern[wildcard_idx + 1 ..] }; }; for (0..inst_tags_len) |inst_tag_i| { - const inst_tag: Mir.Inst.Tag = @enumFromInt(inst_tag_i); + const inst_tag: Mir.Inst.Tag = @fromBackingInt(@intCast(inst_tag_i)); const name = prefix ++ @tagName(inst_tag) ++ suffix; const idx = inst_tag_i * inst_fixes_len + fixes_i; table[idx] = if (@hasField(Mnemonic, name)) @field(Mnemonic, name) else null; @@ -482,7 +482,7 @@ fn generic(lower: *Lower, inst: Mir.Inst) Error!void { else .none, }, mnemonic: { - if (mnemonic_table[@intFromEnum(inst.tag) * inst_fixes_len + @intFromEnum(fixes)]) |mnemonic| { + if (mnemonic_table[@backingInt(inst.tag) * inst_fixes_len + @backingInt(fixes)]) |mnemonic| { break :mnemonic mnemonic; } // This combination is invalid; make the theoretical mnemonic name and emit an error with it. diff --git a/src/codegen/x86_64/Mir.zig b/src/codegen/x86_64/Mir.zig index cb8ba6e2683c65a8396026b9166a6e570357e0f4..90fbbdf3125b2e449dc9723a0b98ce26a6b228c2 100644 --- a/src/codegen/x86_64/Mir.zig +++ b/src/codegen/x86_64/Mir.zig @@ -1822,7 +1822,7 @@ pub const NullTerminatedString = enum(u32) { pub fn toSlice(nts: NullTerminatedString, mir: *const Mir) ?[:0]const u8 { if (nts == .none) return null; - const string_bytes = mir.string_bytes[@intFromEnum(nts)..]; + const string_bytes = mir.string_bytes[@backingInt(nts)..]; return string_bytes[0..std.mem.indexOfScalar(u8, string_bytes, 0).? :0]; } }; @@ -1890,13 +1890,13 @@ pub const Memory = struct { }, .base = switch (mem.base) { .none, .table => undefined, - .reg => |reg| @intFromEnum(reg), - .frame => |frame_index| @intFromEnum(frame_index), + .reg => |reg| @backingInt(reg), + .frame => |frame_index| @backingInt(frame_index), .rip_inst => |inst_index| inst_index, - .nav => |nav| @intFromEnum(nav), - .uav => |uav| @intFromEnum(uav.val), - .lazy_sym => |lazy_sym| @intFromEnum(lazy_sym.ty), - .extern_func => |extern_func| @intFromEnum(extern_func), + .nav => |nav| @backingInt(nav), + .uav => |uav| @backingInt(uav.val), + .lazy_sym => |lazy_sym| @backingInt(lazy_sym.ty), + .extern_func => |extern_func| @backingInt(extern_func), }, .off = switch (mem.mod) { .rm => |rm| @bitCast(rm.disp), @@ -1905,8 +1905,8 @@ pub const Memory = struct { .extra = switch (mem.mod) { .rm => switch (mem.base) { else => undefined, - .uav => |uav| @intFromEnum(uav.orig_ty), - .lazy_sym => |lazy_sym| @intFromEnum(lazy_sym.kind), + .uav => |uav| @backingInt(uav.orig_ty), + .lazy_sym => |lazy_sym| @backingInt(lazy_sym.kind), }, .off => switch (mem.base) { .reg => @intCast(mem.mod.off >> 32), @@ -1919,7 +1919,7 @@ pub const Memory = struct { pub fn decode(mem: Memory) encoder.Instruction.Memory { switch (mem.info.mod) { .rm => { - if (mem.info.base == .reg and @as(Register, @enumFromInt(mem.base)) == .rip) { + if (mem.info.base == .reg and @as(Register, @fromBackingInt(@intCast(mem.base))) == .rip) { assert(mem.info.index == .none and mem.info.scale == .@"1"); return encoder.Instruction.Memory.initRip(mem.info.size, @bitCast(mem.off)); } @@ -1927,14 +1927,14 @@ pub const Memory = struct { .disp = @bitCast(mem.off), .base = switch (mem.info.base) { .none => .none, - .reg => .{ .reg = @enumFromInt(mem.base) }, - .frame => .{ .frame = @enumFromInt(mem.base) }, + .reg => .{ .reg = @fromBackingInt(@intCast(mem.base)) }, + .frame => .{ .frame = @fromBackingInt(@intCast(mem.base)) }, .table => .table, .rip_inst => .{ .rip_inst = mem.base }, - .nav => .{ .nav = @enumFromInt(mem.base) }, - .uav => .{ .uav = .{ .val = @enumFromInt(mem.base), .orig_ty = @enumFromInt(mem.extra) } }, - .lazy_sym => .{ .lazy_sym = .{ .kind = @enumFromInt(mem.extra), .ty = @enumFromInt(mem.base) } }, - .extern_func => .{ .extern_func = @enumFromInt(mem.base) }, + .nav => .{ .nav = @fromBackingInt(@intCast(mem.base)) }, + .uav => .{ .uav = .{ .val = @fromBackingInt(@intCast(mem.base)), .orig_ty = @fromBackingInt(@intCast(mem.extra)) } }, + .lazy_sym => .{ .lazy_sym = .{ .kind = @fromBackingInt(@intCast(mem.extra)), .ty = @fromBackingInt(@intCast(mem.base)) } }, + .extern_func => .{ .extern_func = @fromBackingInt(@intCast(mem.base)) }, }, .scale_index = switch (mem.info.index) { .none => null, @@ -1951,7 +1951,7 @@ pub const Memory = struct { .off => { assert(mem.info.base == .reg); return encoder.Instruction.Memory.initMoffs( - @enumFromInt(mem.base), + @fromBackingInt(@intCast(mem.base)), @as(u64, mem.extra) << 32 | mem.off, ); }, @@ -2074,7 +2074,7 @@ pub fn extraData(mir: Mir, comptime T: type, index: u32) struct { data: T, end: @field(result, field_name) = switch (field_type) { u32 => mir.extra[i], i32, Memory.Info => @bitCast(mir.extra[i]), - bits.FrameIndex => @enumFromInt(mir.extra[i]), + bits.FrameIndex => @fromBackingInt(@intCast(mir.extra[i])), else => @compileError("bad field type: " ++ field_name ++ ": " ++ @typeName(field_type)), }; i += 1; @@ -2091,7 +2091,7 @@ pub const FrameLoc = struct { }; pub fn resolveFrameAddr(mir: Mir, frame_addr: bits.FrameAddr) bits.RegisterOffset { - const frame_loc = mir.frame_locs.get(@intFromEnum(frame_addr.index)); + const frame_loc = mir.frame_locs.get(@backingInt(frame_addr.index)); return .{ .reg = frame_loc.base, .off = frame_loc.disp + frame_addr.off }; } @@ -2107,7 +2107,7 @@ pub fn resolveMemoryExtra(mir: Mir, payload: u32) Memory { .index = mem.info.index, .scale = mem.info.scale, }, - .base = @intFromEnum(mir.frame_locs.items(.base)[mem.base]), + .base = @backingInt(mir.frame_locs.items(.base)[mem.base]), .off = @bitCast(mir.frame_locs.items(.disp)[mem.base] + @as(i32, @bitCast(mem.off))), .extra = mem.extra, } else mem, diff --git a/src/codegen/x86_64/bits.zig b/src/codegen/x86_64/bits.zig index ece1ad1cf0354820d8daa530c3faf31859656867..cd4342b7f68b86a02834a36451b38a0cfa3e4444 100644 --- a/src/codegen/x86_64/bits.zig +++ b/src/codegen/x86_64/bits.zig @@ -241,7 +241,7 @@ pub const SseFloatPredicate = enum(u3) { pub const ord_q: SseFloatPredicate = .ord; pub fn imm(pred: SseFloatPredicate) Immediate { - return .u(@intFromEnum(pred)); + return .u(@backingInt(pred)); } }; @@ -342,7 +342,7 @@ pub const VexFloatPredicate = enum(u5) { pub const @"true": VexFloatPredicate = .true_uq; pub fn imm(pred: VexFloatPredicate) Immediate { - return .u(@intFromEnum(pred)); + return .u(@backingInt(pred)); } }; @@ -407,7 +407,7 @@ pub const Register = enum(u8) { }; pub fn class(reg: Register) Class { - return switch (@intFromEnum(reg)) { + return switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.rax) ... @intFromEnum(Register.r15) => .general_purpose, @intFromEnum(Register.eax) ... @intFromEnum(Register.r15d) => .general_purpose, @@ -442,7 +442,7 @@ pub const Register = enum(u8) { } pub fn id(reg: Register) u7 { - const base = switch (@intFromEnum(reg)) { + const base = switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.rax) ... @intFromEnum(Register.r15) => @intFromEnum(Register.rax), @intFromEnum(Register.eax) ... @intFromEnum(Register.r15d) => @intFromEnum(Register.eax), @@ -462,11 +462,11 @@ pub const Register = enum(u8) { else => unreachable, // zig fmt: on }; - return @intCast(@intFromEnum(reg) - base); + return @intCast(@backingInt(reg) - base); } pub fn size(reg: Register) Memory.Size { - return switch (@intFromEnum(reg)) { + return switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.rax) ... @intFromEnum(Register.r15) => .qword, @intFromEnum(Register.eax) ... @intFromEnum(Register.r15d) => .dword, @@ -491,7 +491,7 @@ pub const Register = enum(u8) { } pub fn isExtended(reg: Register) bool { - return switch (@intFromEnum(reg)) { + return switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.r8) ... @intFromEnum(Register.r15) => true, @intFromEnum(Register.r8d) ... @intFromEnum(Register.r15d) => true, @@ -511,7 +511,7 @@ pub const Register = enum(u8) { } pub fn enc(reg: Register) u5 { - const base = switch (@intFromEnum(reg)) { + const base = switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.rax) ... @intFromEnum(Register.r15) => @intFromEnum(Register.rax), @intFromEnum(Register.eax) ... @intFromEnum(Register.r15d) => @intFromEnum(Register.eax), @@ -532,7 +532,7 @@ pub const Register = enum(u8) { else => unreachable, // zig fmt: on }; - return @truncate(@intFromEnum(reg) - base); + return @truncate(@backingInt(reg) - base); } pub fn toBitSize(reg: Register, bit_size: u64) Register { @@ -572,7 +572,7 @@ pub const Register = enum(u8) { } fn gpBase(reg: Register) u7 { - return switch (@intFromEnum(reg)) { + return switch (@backingInt(reg)) { // zig fmt: off @intFromEnum(Register.rax) ... @intFromEnum(Register.r15) => @intFromEnum(Register.rax), @intFromEnum(Register.eax) ... @intFromEnum(Register.r15d) => @intFromEnum(Register.eax), @@ -586,7 +586,7 @@ pub const Register = enum(u8) { pub fn to64(reg: Register) Register { return switch (reg.class()) { - .general_purpose, .gphi => @enumFromInt(@intFromEnum(reg) - reg.gpBase() + @intFromEnum(Register.rax)), + .general_purpose, .gphi => @fromBackingInt(@intCast(@backingInt(reg) - reg.gpBase() + @backingInt(Register.rax))), .segment => unreachable, .x87, .mmx, .cr, .dr => reg, .sse => reg.to128(), @@ -596,7 +596,7 @@ pub const Register = enum(u8) { pub fn to32(reg: Register) Register { return switch (reg.class()) { - .general_purpose, .gphi => @enumFromInt(@intFromEnum(reg) - reg.gpBase() + @intFromEnum(Register.eax)), + .general_purpose, .gphi => @fromBackingInt(@intCast(@backingInt(reg) - reg.gpBase() + @backingInt(Register.eax))), .segment => unreachable, .x87, .mmx, .cr, .dr => reg, .sse => reg.to128(), @@ -606,7 +606,7 @@ pub const Register = enum(u8) { pub fn to16(reg: Register) Register { return switch (reg.class()) { - .general_purpose, .gphi => @enumFromInt(@intFromEnum(reg) - reg.gpBase() + @intFromEnum(Register.ax)), + .general_purpose, .gphi => @fromBackingInt(@intCast(@backingInt(reg) - reg.gpBase() + @backingInt(Register.ax))), .segment, .x87, .mmx, .cr, .dr => reg, .sse => reg.to128(), .ip => .ip, @@ -623,12 +623,12 @@ pub const Register = enum(u8) { } pub fn toLo8(reg: Register) Register { - return @enumFromInt(@intFromEnum(reg) - reg.gpBase() + @intFromEnum(Register.al)); + return @fromBackingInt(@intCast(@backingInt(reg) - reg.gpBase() + @backingInt(Register.al))); } pub fn toHi8(reg: Register) Register { assert(reg.isClass(.gphi)); - return @enumFromInt(@intFromEnum(reg) - reg.gpBase() + @intFromEnum(Register.ah)); + return @fromBackingInt(@intCast(@backingInt(reg) - reg.gpBase() + @backingInt(Register.ah))); } pub fn to80(reg: Register) Register { @@ -638,24 +638,24 @@ pub const Register = enum(u8) { fn sseBase(reg: Register) u8 { assert(reg.isClass(.sse)); - return switch (@intFromEnum(reg)) { - @intFromEnum(Register.zmm0)...@intFromEnum(Register.zmm31) => @intFromEnum(Register.zmm0), - @intFromEnum(Register.ymm0)...@intFromEnum(Register.ymm31) => @intFromEnum(Register.ymm0), - @intFromEnum(Register.xmm0)...@intFromEnum(Register.xmm31) => @intFromEnum(Register.xmm0), + return switch (@backingInt(reg)) { + @backingInt(Register.zmm0)...@backingInt(Register.zmm31) => @backingInt(Register.zmm0), + @backingInt(Register.ymm0)...@backingInt(Register.ymm31) => @backingInt(Register.ymm0), + @backingInt(Register.xmm0)...@backingInt(Register.xmm31) => @backingInt(Register.xmm0), else => unreachable, }; } pub fn to512(reg: Register) Register { - return @enumFromInt(@intFromEnum(reg) - reg.sseBase() + @intFromEnum(Register.zmm0)); + return @fromBackingInt(@intCast(@backingInt(reg) - reg.sseBase() + @backingInt(Register.zmm0))); } pub fn to256(reg: Register) Register { - return @enumFromInt(@intFromEnum(reg) - reg.sseBase() + @intFromEnum(Register.ymm0)); + return @fromBackingInt(@intCast(@backingInt(reg) - reg.sseBase() + @backingInt(Register.ymm0))); } pub fn to128(reg: Register) Register { - return @enumFromInt(@intFromEnum(reg) - reg.sseBase() + @intFromEnum(Register.xmm0)); + return @fromBackingInt(@intCast(@backingInt(reg) - reg.sseBase() + @backingInt(Register.xmm0))); } /// DWARF register encoding @@ -725,14 +725,14 @@ pub const FrameIndex = enum(u32) { pub const named_count = @typeInfo(FrameIndex).@"enum".field_names.len; pub fn isNamed(fi: FrameIndex) bool { - return @intFromEnum(fi) < named_count; + return @backingInt(fi) < named_count; } pub fn format(fi: FrameIndex, writer: *std.Io.Writer) std.Io.Writer.Error!void { if (fi.isNamed()) { try writer.print("FrameIndex.{t}", .{fi}); } else { - try writer.print("FrameIndex({d})", .{@intFromEnum(fi)}); + try writer.print("FrameIndex({d})", .{@backingInt(fi)}); } } }; @@ -875,11 +875,11 @@ pub const Memory = struct { } pub fn fromLog2(log2: u2) Scale { - return @enumFromInt(log2); + return @fromBackingInt(@intCast(log2)); } pub fn toLog2(scale: Scale) u2 { - return @intFromEnum(scale); + return @backingInt(scale); } }; }; @@ -903,10 +903,10 @@ pub const Immediate = union(enum) { pub fn format(imm: Immediate, writer: *std.Io.Writer) std.Io.Writer.Error!void { switch (imm) { inline else => |int| try writer.print("{d}", .{int}), - .nav => |nav_off| try writer.print("Nav({d}) + {d}", .{ @intFromEnum(nav_off.nav), nav_off.off }), - .uav => |uav| try writer.print("Uav({d})", .{@intFromEnum(uav.val)}), - .lazy_sym => |lazy_sym| try writer.print("LazySym({s}, {d})", .{ @tagName(lazy_sym.kind), @intFromEnum(lazy_sym.ty) }), - .extern_func => |extern_func| try writer.print("ExternFunc({d})", .{@intFromEnum(extern_func)}), + .nav => |nav_off| try writer.print("Nav({d}) + {d}", .{ @backingInt(nav_off.nav), nav_off.off }), + .uav => |uav| try writer.print("Uav({d})", .{@backingInt(uav.val)}), + .lazy_sym => |lazy_sym| try writer.print("LazySym({s}, {d})", .{ @tagName(lazy_sym.kind), @backingInt(lazy_sym.ty) }), + .extern_func => |extern_func| try writer.print("ExternFunc({d})", .{@backingInt(extern_func)}), } } }; diff --git a/src/codegen/x86_64/encoder.zig b/src/codegen/x86_64/encoder.zig index 8e83ad900482c52edd93fda75a3913fb78b303a1..d18497cf08b640064083c4322feaab825f0bb849 100644 --- a/src/codegen/x86_64/encoder.zig +++ b/src/codegen/x86_64/encoder.zig @@ -250,13 +250,13 @@ pub const Instruction = struct { .frame => |frame_index| try w.print("{f}", .{frame_index}), .table => try w.print("Table", .{}), .rip_inst => |inst_index| try w.print("RipInst({d})", .{inst_index}), - .nav => |nav| try w.print("Nav({d})", .{@intFromEnum(nav)}), - .uav => |uav| try w.print("Uav({d})", .{@intFromEnum(uav.val)}), + .nav => |nav| try w.print("Nav({d})", .{@backingInt(nav)}), + .uav => |uav| try w.print("Uav({d})", .{@backingInt(uav.val)}), .lazy_sym => |lazy_sym| try w.print("LazySym({s}, {d})", .{ @tagName(lazy_sym.kind), - @intFromEnum(lazy_sym.ty), + @backingInt(lazy_sym.ty), }), - .extern_func => |extern_func| try w.print("ExternFunc({d})", .{@intFromEnum(extern_func)}), + .extern_func => |extern_func| try w.print("ExternFunc({d})", .{@backingInt(extern_func)}), } if (mem.scaleIndex()) |si| { if (any) try w.writeAll(" + "); @@ -845,14 +845,14 @@ fn Encoder(comptime opts: Options) type { @as(u8, ~@intFromBool(fields.r)) << 7 | @as(u8, ~@intFromBool(fields.x)) << 6 | @as(u8, ~@intFromBool(fields.b)) << 5 | - @as(u8, @intFromEnum(fields.m)) << 0, + @as(u8, @backingInt(fields.m)) << 0, ); try self.w.writeByte( @as(u8, @intFromBool(fields.w)) << 7 | @as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3 | @as(u8, @intFromBool(fields.l)) << 2 | - @as(u8, @intFromEnum(fields.p)) << 0, + @as(u8, @backingInt(fields.p)) << 0, ); } else { try self.w.writeByte(0b1100_0101); @@ -860,7 +860,7 @@ fn Encoder(comptime opts: Options) type { @as(u8, ~@intFromBool(fields.r)) << 7 | @as(u8, ~@as(u4, @intCast(fields.v.enc()))) << 3 | @as(u8, @intFromBool(fields.l)) << 2 | - @as(u8, @intFromEnum(fields.p)) << 0, + @as(u8, @backingInt(fields.p)) << 0, ); } } diff --git a/src/libs/mingw/Preprocessor.zig b/src/libs/mingw/Preprocessor.zig index ee108e9644ce7a25c5fa1bb23d871337085f5464..dcf8e01d043dbc6790aeff839718fd65b5e621cd 100644 --- a/src/libs/mingw/Preprocessor.zig +++ b/src/libs/mingw/Preprocessor.zig @@ -63,11 +63,11 @@ const IfContext = struct { level: u8, fn get(self: *const IfContext) Nesting { - return @enumFromInt(std.mem.readPackedInt(Backing, &self.kind, @as(usize, self.level) * 2, .native)); + return @fromBackingInt(@intCast(std.mem.readPackedInt(Backing, &self.kind, @as(usize, self.level) * 2, .native))); } fn set(self: *IfContext, context: Nesting) void { - std.mem.writePackedInt(Backing, &self.kind, @as(usize, self.level) * 2, @intFromEnum(context), .native); + std.mem.writePackedInt(Backing, &self.kind, @as(usize, self.level) * 2, @backingInt(context), .native); } fn increment(self: *IfContext) void { diff --git a/src/libs/mingw/implib.zig b/src/libs/mingw/implib.zig index f3cf24b3b88cf41323fbe62d4890277ca8ca5f8b..f8ee4858e66d84de84c337c92f04e7c5363442e1 100644 --- a/src/libs/mingw/implib.zig +++ b/src/libs/mingw/implib.zig @@ -505,7 +505,7 @@ fn getImportDescriptor( writeSymbol(&writer, .{ .name = first_string_table_entry, .value = 0, - .section_number = @enumFromInt(1), + .section_number = @fromBackingInt(@intCast(1)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -517,7 +517,7 @@ fn getImportDescriptor( writeSymbol(&writer, .{ .name = ".idata$2".*, .value = 0, - .section_number = @enumFromInt(1), + .section_number = @fromBackingInt(@intCast(1)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -528,7 +528,7 @@ fn getImportDescriptor( writeSymbol(&writer, .{ .name = ".idata$6".*, .value = 0, - .section_number = @enumFromInt(2), + .section_number = @fromBackingInt(@intCast(2)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -668,7 +668,7 @@ fn getNullImportDescriptor( writeSymbol(&writer, .{ .name = first_string_table_entry, .value = 0, - .section_number = @enumFromInt(1), + .section_number = @fromBackingInt(@intCast(1)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -781,7 +781,7 @@ fn getNullThunk( writeSymbol(&writer, .{ .name = first_string_table_entry, .value = 0, - .section_number = @enumFromInt(1), + .section_number = @fromBackingInt(@intCast(1)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -903,7 +903,7 @@ fn getWeakExternal( writeSymbol(&writer, .{ .name = first_string_table_entry, .value = 0, - .section_number = @enumFromInt(0), + .section_number = @fromBackingInt(@intCast(0)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -915,7 +915,7 @@ fn getWeakExternal( writeSymbol(&writer, .{ .name = getNameBytesForStringTableOffset(@intCast(string_table_offset)), .value = 0, - .section_number = @enumFromInt(0), + .section_number = @fromBackingInt(@intCast(0)), .type = .{ .base_type = .NULL, .complex_type = .NULL, @@ -1012,16 +1012,16 @@ fn getShortImport( fn writeSymbol(writer: *std.Io.Writer, symbol: std.coff.Symbol) !void { try writer.writeAll(&symbol.name); try writer.writeInt(u32, symbol.value, .little); - try writer.writeInt(i16, @intFromEnum(symbol.section_number), .little); - try writer.writeInt(u8, @intFromEnum(symbol.type.base_type), .little); - try writer.writeInt(u8, @intFromEnum(symbol.type.complex_type), .little); - try writer.writeInt(u8, @intFromEnum(symbol.storage_class), .little); + try writer.writeInt(i16, @backingInt(symbol.section_number), .little); + try writer.writeInt(u8, @backingInt(symbol.type.base_type), .little); + try writer.writeInt(u8, @backingInt(symbol.type.complex_type), .little); + try writer.writeInt(u8, @backingInt(symbol.storage_class), .little); try writer.writeInt(u8, symbol.number_of_aux_symbols, .little); } fn writeWeakExternalDefinition(writer: *std.Io.Writer, weak_external: std.coff.WeakExternalDefinition) !void { try writer.writeInt(u32, weak_external.tag_index, .little); - try writer.writeInt(u32, @intFromEnum(weak_external.flag), .little); + try writer.writeInt(u32, @backingInt(weak_external.flag), .little); try writer.writeAll(&weak_external.unused); } @@ -1034,11 +1034,11 @@ fn writeRelocation(writer: *std.Io.Writer, relocation: std.coff.Relocation) !voi // https://learn.microsoft.com/en-us/windows/win32/debug/pe-format#type-indicators pub fn rvaRelocationTypeIndicator(target: std.coff.IMAGE.FILE.MACHINE) ?u16 { return switch (target) { - .AMD64 => @intFromEnum(std.coff.IMAGE.REL.AMD64.ADDR32NB), - .I386 => @intFromEnum(std.coff.IMAGE.REL.I386.DIR32NB), - .ARMNT => @intFromEnum(std.coff.IMAGE.REL.ARM.ADDR32NB), - .ARM64, .ARM64EC, .ARM64X => @intFromEnum(std.coff.IMAGE.REL.ARM64.ADDR32NB), - .IA64 => @intFromEnum(std.coff.IMAGE.REL.IA64.DIR32NB), + .AMD64 => @backingInt(std.coff.IMAGE.REL.AMD64.ADDR32NB), + .I386 => @backingInt(std.coff.IMAGE.REL.I386.DIR32NB), + .ARMNT => @backingInt(std.coff.IMAGE.REL.ARM.ADDR32NB), + .ARM64, .ARM64EC, .ARM64X => @backingInt(std.coff.IMAGE.REL.ARM64.ADDR32NB), + .IA64 => @backingInt(std.coff.IMAGE.REL.IA64.DIR32NB), else => null, }; } diff --git a/src/link.zig b/src/link.zig index bf2d6c21cc815950a56903325ccb85de68977f9e..075924712c1d71b2dc0eaa133591247b34a2de3c 100644 --- a/src/link.zig +++ b/src/link.zig @@ -386,7 +386,7 @@ pub const Diags = struct { }); const notes_start = try bundle.reserveNotes(@intCast(link_err.notes.len)); for (link_err.notes, 0..) |note, i| { - bundle.extra.items[notes_start + i] = @intFromEnum(try bundle.addErrorMessage(.{ + bundle.extra.items[notes_start + i] = @backingInt(try bundle.addErrorMessage(.{ .msg = try note.string(bundle, base), })); } @@ -860,7 +860,7 @@ pub const File = struct { { const ti = ti_id.resolveFull(&pt.zcu.intern_pool).?; const file = pt.zcu.fileByIndex(ti.file); - const inst = file.zir.?.instructions.get(@intFromEnum(ti.inst)); + const inst = file.zir.?.instructions.get(@backingInt(ti.inst)); assert(inst.tag == .declaration); } diff --git a/src/link/C.zig b/src/link/C.zig index a5862d87eeba5b8833abcc92021e6f1ee74318a1..ae8526aafefb5adbcff87d1a90f789653e9faa8a 100644 --- a/src/link/C.zig +++ b/src/link/C.zig @@ -211,7 +211,7 @@ pub fn addConst( const zcu = pt.zcu; const gpa = zcu.comp.gpa; assert(zcu.intern_pool.typeOf(val) == .type_type); - assert(@intFromEnum(pool_index) == c.types.items.len); + assert(@backingInt(pool_index) == c.types.items.len); const ty: Type = .fromInterned(val); @@ -262,7 +262,7 @@ pub fn addConst( _ = try codegen.CType.lower(ty, &deps, arena.allocator(), zcu); // This call may add more items to `c.types`. const type_deps = try c.addCTypeDependencies(pt, &deps); - c.types.items[@intFromEnum(pool_index)].deps = type_deps; + c.types.items[@backingInt(pool_index)].deps = type_deps; } } @@ -279,7 +279,7 @@ pub fn updateConstIncomplete( assert(zcu.intern_pool.typeOf(val) == .type_type); const ty: Type = .fromInterned(val); - const rendered: *RenderedType = &c.types.items[@intFromEnum(index)]; + const rendered: *RenderedType = &c.types.items[@backingInt(index)]; rendered.errunion_definition = .empty; rendered.definition_deps = .empty; @@ -315,7 +315,7 @@ pub fn updateConst( assert(zcu.intern_pool.typeOf(val) == .type_type); const ty: Type = .fromInterned(val); - const rendered: *RenderedType = &c.types.items[@intFromEnum(index)]; + const rendered: *RenderedType = &c.types.items[@backingInt(index)]; var arena: std.heap.ArenaAllocator = .init(gpa); defer arena.deinit(); @@ -371,7 +371,7 @@ pub fn updateConst( { // This call invalidates `rendered`. const definition_deps = try c.addCTypeDependencies(pt, &deps); - c.types.items[@intFromEnum(index)].definition_deps = definition_deps; + c.types.items[@backingInt(index)].definition_deps = definition_deps; } } @@ -858,7 +858,7 @@ pub fn flush(c: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Prog while (true) { if (index < need_types.count()) { const pool_index = need_types.keys()[index]; - const rendered = &c.types.items[@intFromEnum(pool_index)]; + const rendered = &c.types.items[@backingInt(pool_index)]; try mergeNeededCTypes( c, &need_types, @@ -872,7 +872,7 @@ pub fn flush(c: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Prog if (errunion_index < need_errunion_types.count()) { const payload_pool_index = need_errunion_types.keys()[errunion_index]; - const rendered = &c.types.items[@intFromEnum(payload_pool_index)]; + const rendered = &c.types.items[@backingInt(payload_pool_index)]; try mergeNeededCTypes( c, &need_types, @@ -886,7 +886,7 @@ pub fn flush(c: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Prog if (aligned_index < need_aligned_types.count()) { const pool_index = need_aligned_types.keys()[aligned_index]; - const rendered = &c.types.items[@intFromEnum(pool_index)]; + const rendered = &c.types.items[@backingInt(pool_index)]; try mergeNeededCTypes( c, &need_types, @@ -916,7 +916,7 @@ pub fn flush(c: *C, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Prog aligned_type_strings, ) |pool_index, align_mask, *str_out| { const ty: Type = .fromInterned(pool_index.val(&c.type_pool)); - const has_layout = c.types.items[@intFromEnum(pool_index)].errunion_definition.len > 0; + const has_layout = c.types.items[@backingInt(pool_index)].errunion_definition.len > 0; for (0..@bitSizeOf(@TypeOf(align_mask))) |bit_index| { switch (@as(u1, @truncate(align_mask >> @intCast(bit_index)))) { 0 => continue, @@ -1450,7 +1450,7 @@ const FlushTypes = struct { const c = ft.c; if (ft.aligned_status.contains(pool_index)) return; if (ft.aligned_types.getIndex(pool_index)) |i| { - const rendered = &c.types.items[@intFromEnum(pool_index)]; + const rendered = &c.types.items[@backingInt(pool_index)]; ft.processDepsAsFwd(&rendered.deps); ft.f.appendBufAssumeCapacity(ft.aligned_type_strings[i]); } @@ -1459,7 +1459,7 @@ const FlushTypes = struct { fn doTypeFwd(ft: *FlushTypes, pool_index: link.ConstPool.Index) void { const c = ft.c; if (ft.status.contains(pool_index)) return; - const rendered = &c.types.items[@intFromEnum(pool_index)]; + const rendered = &c.types.items[@backingInt(pool_index)]; if (rendered.fwd_decl.len > 0) { ft.f.appendBufAssumeCapacity(rendered.fwd_decl.get(c)); ft.status.putAssumeCapacityNoClobber(pool_index, false); @@ -1477,7 +1477,7 @@ const FlushTypes = struct { if (ft.status.get(pool_index)) |completed| { if (completed) return; } - const rendered = &c.types.items[@intFromEnum(pool_index)]; + const rendered = &c.types.items[@backingInt(pool_index)]; ft.processDeps(&rendered.definition_deps); if (rendered.fwd_decl.len == 0 and ft.status.contains(pool_index)) { // `doTypeFwd` already rendered the defintion, we just had to complete the type by @@ -1495,7 +1495,7 @@ const FlushTypes = struct { const c = ft.c; const gop = ft.errunion_status.getOrPutAssumeCapacity(pool_index); if (gop.found_existing) return; - const rendered = &c.types.items[@intFromEnum(pool_index)]; + const rendered = &c.types.items[@backingInt(pool_index)]; ft.f.appendBufAssumeCapacity(rendered.errunion_fwd_decl.get(c)); gop.value_ptr.* = false; } @@ -1504,7 +1504,7 @@ const FlushTypes = struct { if (ft.errunion_status.get(pool_index)) |completed| { if (completed) return; } - const rendered = &c.types.items[@intFromEnum(pool_index)]; + const rendered = &c.types.items[@backingInt(pool_index)]; ft.processDeps(&rendered.deps); if (rendered.errunion_definition.len > 0) { ft.f.appendBufAssumeCapacity(rendered.errunion_definition.get(c)); diff --git a/src/link/Coff.zig b/src/link/Coff.zig index 756c4c8892b29f54be05456d12277aa49bc3a444..136c1184f64554dfcee7d60c7e044d662a778d82 100644 --- a/src/link/Coff.zig +++ b/src/link/Coff.zig @@ -234,11 +234,11 @@ pub const Node = union(enum) { _, pub fn name(psmi: PseudoSectionMapIndex, coff: *const Coff) String { - return coff.pseudo_section_table.keys()[@intFromEnum(psmi)]; + return coff.pseudo_section_table.keys()[@backingInt(psmi)]; } pub fn symbol(psmi: PseudoSectionMapIndex, coff: *const Coff) Symbol.Index { - return coff.pseudo_section_table.values()[@intFromEnum(psmi)]; + return coff.pseudo_section_table.values()[@backingInt(psmi)]; } }; @@ -246,11 +246,11 @@ pub const Node = union(enum) { _, pub fn name(osmi: ObjectSectionMapIndex, coff: *const Coff) String { - return coff.object_section_table.keys()[@intFromEnum(osmi)]; + return coff.object_section_table.keys()[@backingInt(osmi)]; } pub fn symbol(osmi: ObjectSectionMapIndex, coff: *const Coff) Symbol.Index { - return coff.object_section_table.values()[@intFromEnum(osmi)]; + return coff.object_section_table.values()[@backingInt(osmi)]; } }; @@ -259,13 +259,13 @@ pub const Node = union(enum) { _, pub fn wrap(i: ?u32) GlobalMapIndex { - return @enumFromInt((i orelse return .none) + 1); + return @fromBackingInt(@intCast((i orelse return .none) + 1)); } pub fn unwrap(gmi: GlobalMapIndex) ?u32 { return switch (gmi) { .none => null, - _ => @intFromEnum(gmi) - 1, + _ => @backingInt(gmi) - 1, }; } @@ -286,11 +286,11 @@ pub const Node = union(enum) { _, pub fn navIndex(nmi: NavMapIndex, coff: *const Coff) InternPool.Nav.Index { - return coff.navs.keys()[@intFromEnum(nmi)]; + return coff.navs.keys()[@backingInt(nmi)]; } pub fn symbol(nmi: NavMapIndex, coff: *const Coff) Symbol.Index { - return coff.navs.values()[@intFromEnum(nmi)]; + return coff.navs.values()[@backingInt(nmi)]; } }; @@ -298,11 +298,11 @@ pub const Node = union(enum) { _, pub fn uavValue(umi: UavMapIndex, coff: *const Coff) InternPool.Index { - return coff.uavs.keys()[@intFromEnum(umi)]; + return coff.uavs.keys()[@backingInt(umi)]; } pub fn symbol(umi: UavMapIndex, coff: *const Coff) Symbol.Index { - return coff.uavs.values()[@intFromEnum(umi)]; + return coff.uavs.values()[@backingInt(umi)]; } }; @@ -318,23 +318,23 @@ pub const Node = union(enum) { _, pub fn inputSection(isi: Index, coff: *const Coff) *InputSection { - return &coff.input_sections.items[@intFromEnum(isi)]; + return &coff.input_sections.items[@backingInt(isi)]; } pub fn input(isi: Index, coff: *const Coff) InputObject.Index { - return coff.input_sections.items[@intFromEnum(isi)].ioi; + return coff.input_sections.items[@backingInt(isi)].ioi; } pub fn fileLocation(isi: Index, coff: *const Coff) MappedFile.Node.FileLocation { - return coff.input_sections.items[@intFromEnum(isi)].file_location; + return coff.input_sections.items[@backingInt(isi)].file_location; } pub fn symbol(isi: Index, coff: *const Coff) Symbol.Index { - return coff.input_sections.items[@intFromEnum(isi)].si; + return coff.input_sections.items[@backingInt(isi)].si; } pub fn firstSymbol(isi: Index, coff: *const Coff) LocalIndex { - return coff.input_sections.items[@intFromEnum(isi)].first_li; + return coff.input_sections.items[@backingInt(isi)].first_li; } }; @@ -342,7 +342,7 @@ pub const Node = union(enum) { _, pub fn name(isli: LocalIndex, coff: *const Coff) String { - return coff.input_symbols.items[@intFromEnum(isli)].name; + return coff.input_symbols.items[@backingInt(isli)].name; } }; }; @@ -356,7 +356,7 @@ pub const Node = union(enum) { _, pub fn ref(lmi: @This()) LazyMapRef { - return .{ .kind = kind, .index = @intFromEnum(lmi) }; + return .{ .kind = kind, .index = @backingInt(lmi) }; } pub fn lazySymbol(lmi: @This(), coff: *const Coff) link.File.LazySymbol { @@ -402,7 +402,7 @@ pub const Node = union(enum) { var mut_known: std.enums.EnumFieldStruct(Known, MappedFile.Node.Index, null) = undefined; const info = @typeInfo(Known).@"enum"; for (info.field_names, info.field_values) |field_name, field_value| - @field(mut_known, field_name) = @enumFromInt(field_value); + @field(mut_known, field_name) = @fromBackingInt(@intCast(field_value)); break :known mut_known; }; @@ -418,7 +418,7 @@ pub const InputArchive = struct { _, pub fn path(iai: InputArchive.Index, coff: *Coff) std.Build.Cache.Path { - return coff.input_archives.items[@intFromEnum(iai)].path; + return coff.input_archives.items[@backingInt(iai)].path; } }; @@ -446,7 +446,7 @@ pub const InputArchive = struct { _, pub fn member(iami: InputArchive.Member.Index, coff: *Coff) *InputArchive.Member { - return &coff.input_archive_members.items[@intFromEnum(iami)]; + return &coff.input_archive_members.items[@backingInt(iami)]; } }; @@ -476,11 +476,11 @@ pub const InputObject = struct { _, pub fn path(ioi: Index, coff: *const Coff) std.Build.Cache.Path { - return coff.input_objects.items[@intFromEnum(ioi)].path; + return coff.input_objects.items[@backingInt(ioi)].path; } pub fn memberName(ioi: Index, coff: *const Coff) ?[]const u8 { - return coff.input_objects.items[@intFromEnum(ioi)].member_name; + return coff.input_objects.items[@backingInt(ioi)].member_name; } }; }; @@ -503,7 +503,7 @@ pub const Member = struct { const known_count = @typeInfo(Index).@"enum".field_names.len; pub fn get(member_index: Member.Index, coff: *Coff) *Member { - return &coff.members.items[@intFromEnum(member_index)]; + return &coff.members.items[@backingInt(member_index)]; } }; @@ -657,7 +657,7 @@ pub const SymbolTable = struct { }, .long => |l| { @memset(field[0..4], 0); - std.mem.writePackedInt(u32, field[4..], 0, @intFromEnum(l), coff.targetEndian()); + std.mem.writePackedInt(u32, field[4..], 0, @backingInt(l), coff.targetEndian()); }, } } @@ -671,13 +671,13 @@ pub const SymbolTable = struct { _, pub fn wrap(i: u32) Index { - return @enumFromInt(i + 1); + return @fromBackingInt(@intCast(i + 1)); } pub fn unwrap(sti: Index) ?u32 { return switch (sti) { .none => null, - _ => @intFromEnum(sti) - 1, + _ => @backingInt(sti) - 1, }; } }; @@ -720,7 +720,7 @@ pub const ExportTable = struct { _, pub fn get(export_index: ExportTable.Ordinal, coff: *Coff) *Entry { - return &coff.export_table.entries.values()[@intFromEnum(export_index)]; + return &coff.export_table.entries.values()[@backingInt(export_index)]; } }; }; @@ -768,7 +768,7 @@ pub const ImportTable = struct { _, pub fn get(import_index: ImportTable.Index, coff: *Coff) *Entry { - return &coff.import_table.entries.values()[@intFromEnum(import_index)]; + return &coff.import_table.entries.values()[@backingInt(import_index)]; } }; }; @@ -791,26 +791,26 @@ pub const String = enum(u32) { _, pub const Optional = enum(u32) { - @".data" = @intFromEnum(String.@".data"), - @".idata" = @intFromEnum(String.@".idata"), - @".rdata" = @intFromEnum(String.@".rdata"), - @".text" = @intFromEnum(String.@".text"), - @".tls$" = @intFromEnum(String.@".tls$"), - @".edata" = @intFromEnum(String.@".edata"), - @".ctors" = @intFromEnum(String.@".ctors"), - @".ctors$ZZZ" = @intFromEnum(String.@".ctors$ZZZ"), - @".dtors" = @intFromEnum(String.@".dtors"), - @".dtors$ZZZ" = @intFromEnum(String.@".dtors$ZZZ"), - @".bss" = @intFromEnum(String.@".bss"), - @".fptable" = @intFromEnum(String.@".fptable"), - @".tls" = @intFromEnum(String.@".tls"), - @".thunks" = @intFromEnum(String.@".thunks"), + @".data" = @backingInt(String.@".data"), + @".idata" = @backingInt(String.@".idata"), + @".rdata" = @backingInt(String.@".rdata"), + @".text" = @backingInt(String.@".text"), + @".tls$" = @backingInt(String.@".tls$"), + @".edata" = @backingInt(String.@".edata"), + @".ctors" = @backingInt(String.@".ctors"), + @".ctors$ZZZ" = @backingInt(String.@".ctors$ZZZ"), + @".dtors" = @backingInt(String.@".dtors"), + @".dtors$ZZZ" = @backingInt(String.@".dtors$ZZZ"), + @".bss" = @backingInt(String.@".bss"), + @".fptable" = @backingInt(String.@".fptable"), + @".tls" = @backingInt(String.@".tls"), + @".thunks" = @backingInt(String.@".thunks"), none = std.math.maxInt(u32), _, pub fn unwrap(os: String.Optional) ?String { return switch (os) { - else => |s| @enumFromInt(@intFromEnum(s)), + else => |s| @fromBackingInt(@intCast(@backingInt(s))), .none => null, }; } @@ -821,12 +821,12 @@ pub const String = enum(u32) { }; pub fn toSlice(s: String, coff: *Coff) [:0]const u8 { - const slice = coff.string_bytes.items[@intFromEnum(s)..]; + const slice = coff.string_bytes.items[@backingInt(s)..]; return slice[0..std.mem.indexOfScalar(u8, slice, 0).? :0]; } pub fn toOptional(s: String) String.Optional { - return @enumFromInt(@intFromEnum(s)); + return @fromBackingInt(@intCast(@backingInt(s))); } }; @@ -839,13 +839,13 @@ pub const Section = struct { _, pub fn wrap(i: ?u16) RelocationIndex { - return @enumFromInt((i orelse return .none) + 1); + return @fromBackingInt(@intCast((i orelse return .none) + 1)); } pub fn unwrap(sri: RelocationIndex) ?u16 { return switch (sri) { .none => null, - _ => @intFromEnum(sri) - 1, + _ => @backingInt(sri) - 1, }; } @@ -1008,11 +1008,11 @@ pub const Symbol = struct { _, fn toIndex(sn: SectionNumber) u15 { - return @intCast(@intFromEnum(sn) - 1); + return @intCast(@backingInt(sn) - 1); } fn hasIndex(sn: SectionNumber) bool { - return @intFromEnum(sn) > 0; + return @backingInt(sn) > 0; } pub fn symbol(sn: SectionNumber, coff: *const Coff) Symbol.Index { @@ -1043,7 +1043,7 @@ pub const Symbol = struct { const known_count = @typeInfo(Index).@"enum".field_names.len; pub fn get(si: Symbol.Index, coff: *Coff) *Symbol { - return &coff.symbols.items[@intFromEnum(si)]; + return &coff.symbols.items[@backingInt(si)]; } pub fn unwrap(si: Symbol.Index) ?Symbol.Index { @@ -1063,7 +1063,7 @@ pub const Symbol = struct { } pub fn next(si: Symbol.Index) Symbol.Index { - return @enumFromInt(@intFromEnum(si) + 1); + return @fromBackingInt(@intCast(@backingInt(si) + 1)); } pub fn knownString(si: Symbol.Index) String.Optional { @@ -1107,7 +1107,7 @@ pub const Symbol = struct { switch (sym.loc_relocs) { .none => {}, else => |loc_relocs| { - for (coff.relocs.items[@intFromEnum(loc_relocs)..]) |*reloc| { + for (coff.relocs.items[@backingInt(loc_relocs)..]) |*reloc| { if (reloc.loc != si) break; if (reloc.sri.entry(coff, sym.section_number)) |entry| coff.targetStore( &entry.virtual_address, @@ -1136,7 +1136,7 @@ pub const Symbol = struct { switch (sym.loc_relocs) { .none => {}, else => |loc_relocs| { - for (coff.relocs.items[@intFromEnum(loc_relocs)..]) |*reloc| { + for (coff.relocs.items[@backingInt(loc_relocs)..]) |*reloc| { if (reloc.loc != si) break; reloc.delete(coff); } @@ -1189,11 +1189,11 @@ pub const Reloc = extern struct { _, pub fn wrap(i: ?u32) Reloc.Index { - return @enumFromInt((i orelse return .none) + 1); + return @fromBackingInt(@intCast((i orelse return .none) + 1)); } pub fn get(ri: Reloc.Index, coff: *Coff) *Reloc { - return &coff.relocs.items[@intFromEnum(ri)]; + return &coff.relocs.items[@backingInt(ri)]; } }; @@ -1574,13 +1574,13 @@ fn create( else => return error.UnsupportedCOFFArchitecture, }; const section_align: std.mem.Alignment = switch (machine) { - .AMD64, .I386 => @enumFromInt(12), - .SH3, .SH3DSP, .SH4, .SH5 => @enumFromInt(12), - .MIPS16, .MIPSFPU, .MIPSFPU16, .WCEMIPSV2 => @enumFromInt(12), - .POWERPC, .POWERPCFP => @enumFromInt(12), - .ALPHA, .ALPHA64 => @enumFromInt(13), - .IA64 => @enumFromInt(13), - .ARM => @enumFromInt(12), + .AMD64, .I386 => @fromBackingInt(@intCast(12)), + .SH3, .SH3DSP, .SH4, .SH5 => @fromBackingInt(@intCast(12)), + .MIPS16, .MIPSFPU, .MIPSFPU16, .WCEMIPSV2 => @fromBackingInt(@intCast(12)), + .POWERPC, .POWERPCFP => @fromBackingInt(@intCast(12)), + .ALPHA, .ALPHA64 => @fromBackingInt(@intCast(13)), + .IA64 => @fromBackingInt(@intCast(13)), + .ARM => @fromBackingInt(@intCast(12)), else => return error.UnsupportedCOFFArchitecture, }; @@ -2193,7 +2193,7 @@ fn initHeaders( const export_address_table_sym = coff.export_table.export_address_table_si.get(coff); export_address_table_sym.ni = export_address_table_ni; assert(export_address_table_sym.loc_relocs == .none); - export_address_table_sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + export_address_table_sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); export_address_table_sym.section_number = coff.getNode(coff.export_table.ni).pseudo_section.symbol(coff).get(coff).section_number; @@ -2383,7 +2383,7 @@ pub fn endProgress(coff: *Coff) void { } fn getNode(coff: *const Coff, ni: MappedFile.Node.Index) Node { - return coff.nodes.get(@intFromEnum(ni)); + return coff.nodes.get(@backingInt(ni)); } fn computeNodeRva(coff: *Coff, ni: MappedFile.Node.Index) u32 { const parent_rva = parent_rva: { @@ -2499,7 +2499,7 @@ fn targetLoad(coff: *const Coff, ptr: anytype) @typeInfo(@TypeOf(ptr)).pointer.c return switch (@typeInfo(Child)) { else => @compileError(@typeName(Child)), .int => std.mem.toNative(Child, ptr.*, coff.targetEndian()), - .@"enum" => |@"enum"| @enumFromInt(coff.targetLoad(@as(*@"enum".tag_type, @ptrCast(ptr)))), + .@"enum" => |@"enum"| @fromBackingInt(@intCast(coff.targetLoad(@as(*@"enum".tag_type, @ptrCast(ptr))))), .@"struct" => |@"struct"| @bitCast( coff.targetLoad(@as(*@"struct".backing_integer.?, @ptrCast(ptr))), ), @@ -2512,7 +2512,7 @@ fn targetStore(coff: *const Coff, ptr: anytype, val: @typeInfo(@TypeOf(ptr)).poi .int => ptr.* = std.mem.nativeTo(Child, val, coff.targetEndian()), .@"enum" => |@"enum"| coff.targetStore( @as(*@"enum".tag_type, @ptrCast(ptr)), - @intFromEnum(val), + @backingInt(val), ), .@"struct" => |@"struct"| coff.targetStore( @as(*@"struct".backing_integer.?, @ptrCast(ptr)), @@ -2613,7 +2613,7 @@ pub fn dataDirectoryPtr( coff: *Coff, entry: std.coff.IMAGE.DIRECTORY_ENTRY, ) *std.coff.ImageDataDirectory { - return &coff.dataDirectorySlice()[@intFromEnum(entry)]; + return &coff.dataDirectorySlice()[@backingInt(entry)]; } pub fn sectionTableSlice(coff: *Coff) []std.coff.SectionHeader { @@ -2665,7 +2665,7 @@ pub fn importDirectoryEntryPtr( coff: *Coff, import_index: ImportTable.Index, ) *std.coff.ImportDirectoryEntry { - return &coff.importDirectoryTableSlice()[@intFromEnum(import_index)]; + return &coff.importDirectoryTableSlice()[@backingInt(import_index)]; } pub fn exportDirectoryTable(coff: *Coff) *std.coff.ExportDirectoryTable { @@ -2701,7 +2701,7 @@ fn addSymbolAssumeCapacity(coff: *Coff) Symbol.Index { .section_number = .UNDEFINED, .gmi = .none, }; - return @enumFromInt(coff.symbols.items.len); + return @fromBackingInt(@intCast(coff.symbols.items.len)); } fn initSymbolAssumeCapacity(coff: *Coff) !Symbol.Index { @@ -2721,7 +2721,7 @@ fn getString(coff: *Coff, string: []const u8) String.Optional { string, std.hash_map.StringIndexAdapter{ .bytes = &coff.string_bytes }, )) |key| - return @as(String, @enumFromInt(key)).toOptional() + return @as(String, @fromBackingInt(@intCast(key))).toOptional() else return .none; } @@ -2739,7 +2739,7 @@ fn getOrPutSymbolName(coff: *Coff, name: []const u8, opt_string: ?String) !Symbo const string_gop = try coff.symbol_table.strings.getOrPut(gpa, string); if (!string_gop.found_existing) { const string_index = coff.symbol_table.strings_ni.location(&coff.mf).resolve(&coff.mf)[1]; - string_gop.value_ptr.* = @enumFromInt(string_index); + string_gop.value_ptr.* = @fromBackingInt(@intCast(string_index)); try coff.symbol_table.strings_ni.resize(&coff.mf, gpa, string_index + name.len + 1); const slice = coff.symbol_table.strings_ni.slice(&coff.mf); @@ -2776,7 +2776,7 @@ fn getOrPutStringAssumeCapacity(coff: *Coff, string: []const u8) String { coff.string_bytes.appendSliceAssumeCapacity(string); coff.string_bytes.appendAssumeCapacity(0); } - return @enumFromInt(gop.key_ptr.*); + return @fromBackingInt(@intCast(gop.key_ptr.*)); } const GlobalOptions = struct { @@ -2887,7 +2887,7 @@ fn navMapIndex(coff: *Coff, zcu: *Zcu, nav_index: InternPool.Nav.Index) !Node.Na try coff.symbols.ensureUnusedCapacity(gpa, 1); const sym_gop = try coff.navs.getOrPut(gpa, nav_index); if (!sym_gop.found_existing) sym_gop.value_ptr.* = coff.addSymbolAssumeCapacity(); - return @enumFromInt(sym_gop.index); + return @fromBackingInt(@intCast(sym_gop.index)); } pub fn navSymbol(coff: *Coff, zcu: *Zcu, nav_index: InternPool.Nav.Index) !Symbol.Index { const ip = &zcu.intern_pool; @@ -2908,7 +2908,7 @@ fn uavMapIndex(coff: *Coff, uav_val: InternPool.Index) !Node.UavMapIndex { try coff.symbols.ensureUnusedCapacity(gpa, 1); const sym_gop = try coff.uavs.getOrPut(gpa, uav_val); if (!sym_gop.found_existing) sym_gop.value_ptr.* = coff.addSymbolAssumeCapacity(); - return @enumFromInt(sym_gop.index); + return @fromBackingInt(@intCast(sym_gop.index)); } pub fn uavSymbol(coff: *Coff, uav_val: InternPool.Index) !Symbol.Index { const umi = try coff.uavMapIndex(uav_val); @@ -2945,7 +2945,7 @@ pub fn getUavVAddr( pub fn getVAddr(coff: *Coff, reloc_info: link.File.RelocInfo, target_si: Symbol.Index) link.Error!u64 { try coff.addReloc( - @enumFromInt(@intFromEnum(reloc_info.parent.atom_index)), + @fromBackingInt(@intCast(@backingInt(reloc_info.parent.atom_index))), reloc_info.offset, target_si, .{ .known = reloc_info.addend }, @@ -2986,7 +2986,7 @@ fn addMemberAssumeCapacity(coff: *Coff, kind: std.coff.ArchiveMemberHeader.Kind, .fixed = true, }); - const mi: Member.Index = @enumFromInt(coff.members.items.len); + const mi: Member.Index = @fromBackingInt(@intCast(coff.members.items.len)); coff.members.appendAssumeCapacity(.{ .kind = kind, .header_ni = header_ni, @@ -3065,7 +3065,7 @@ fn ensureMemberSymbol(coff: *Coff, mi: Member.Index, name: String) !void { const num_symbols_ptr = coff.firstLinkerMemberNumSymbolsPtr(); const num_symbols = std.mem.toNative(u32, num_symbols_ptr.*, .big); num_symbols_ptr.* = std.mem.nativeTo(u32, num_symbols + 1, .big); - break :blk @enumFromInt(num_symbols); + break :blk @fromBackingInt(@intCast(num_symbols)); }; gop.value_ptr.* = mfli; @@ -3078,7 +3078,7 @@ fn ensureMemberSymbol(coff: *Coff, mi: Member.Index, name: String) !void { defer coff.lib_string_len = new_string_table_size; { - const old_header_size: usize = @intCast(@sizeOf(u32) + @intFromEnum(mfli) * @sizeOf(u32)); + const old_header_size: usize = @intCast(@sizeOf(u32) + @backingInt(mfli) * @sizeOf(u32)); const new_header_size: usize = @intCast(old_header_size + @sizeOf(u32)); try Node.known.first_linker_member.resize(&coff.mf, gpa, new_header_size + new_string_table_size); @@ -3092,7 +3092,7 @@ fn ensureMemberSymbol(coff: *Coff, mi: Member.Index, name: String) !void { { const num_members = coff.targetLoad(coff.secondLinkerMemberNumMembersPtr()); - const old_header_size = 2 * @sizeOf(u32) + num_members * @sizeOf(u32) + @intFromEnum(mfli) * @sizeOf(u16); + const old_header_size = 2 * @sizeOf(u32) + num_members * @sizeOf(u32) + @backingInt(mfli) * @sizeOf(u16); const new_header_size = old_header_size + @sizeOf(u16); try Node.known.second_linker_member.resize(&coff.mf, gpa, new_header_size + new_string_table_size); @@ -3109,7 +3109,7 @@ fn ensureMemberSymbol(coff: *Coff, mi: Member.Index, name: String) !void { try coff.lib_string_table.append(gpa, name); const slice = Node.known.second_linker_member.slice(&coff.mf); - coff.targetStore(coff.secondLinkerMemberNumSymbolsPtr(), @intFromEnum(mfli) + 1); + coff.targetStore(coff.secondLinkerMemberNumSymbolsPtr(), @backingInt(mfli) + 1); if (!needs_sort) { @memmove(slice[new_header_size..][0..coff.lib_string_len], slice[old_header_size..][0..coff.lib_string_len]); @memcpy(slice[new_header_size + coff.lib_string_len ..][0..name_slice.len], name_slice[0..name_slice.len]); @@ -3121,7 +3121,7 @@ fn ensureMemberSymbol(coff: *Coff, mi: Member.Index, name: String) !void { // Indices in this table are 1-based const index_ptr: *u16 = @ptrCast(@alignCast(slice[old_header_size..])); - coff.targetStore(index_ptr, @intCast(@intFromEnum(mi) - Member.Index.known_count + 1)); + coff.targetStore(index_ptr, @intCast(@backingInt(mi) - Member.Index.known_count + 1)); } coff.pending_members.putAssumeCapacity(mi, {}); @@ -3209,7 +3209,7 @@ fn flushSymbolTableEntry(coff: *Coff, index: u32, pt: Zcu.PerThread) !void { const entry = coff.symbolTableEntryPtr(sti.*).?; symbol_name.store(coff, &entry.name); - entry.section_number = @enumFromInt(@intFromEnum(sym.section_number)); + entry.section_number = @fromBackingInt(@intCast(@backingInt(sym.section_number))); entry.type = .{ .complex_type = complex_type, .base_type = .NULL, @@ -3399,7 +3399,7 @@ fn addSection(coff: *Coff, name: String, flags: std.coff.SectionHeader.Flags) !S const sym = si.get(coff); sym.ni = ni; sym.rva = rva; - sym.section_number = @enumFromInt(section_table_len); + sym.section_number = @fromBackingInt(@intCast(section_table_len)); } const section = §ion_table[section_index]; section.* = .{ @@ -3486,7 +3486,7 @@ fn pseudoSectionMapIndex( ) !Node.PseudoSectionMapIndex { const gpa = coff.base.comp.gpa; const pseudo_section_gop = try coff.pseudo_section_table.getOrPut(gpa, name); - const psmi: Node.PseudoSectionMapIndex = @enumFromInt(pseudo_section_gop.index); + const psmi: Node.PseudoSectionMapIndex = @fromBackingInt(@intCast(pseudo_section_gop.index)); const parent_sn = if (!pseudo_section_gop.found_existing) sn: { const effective_name = coff.section_merges.get(name) orelse name; const parent = if (coff.section_table.get(effective_name)) |existing_sec| @@ -3514,7 +3514,7 @@ fn pseudoSectionMapIndex( sym.rva = coff.computeNodeRva(ni); sym.section_number = parent.get(coff).section_number; assert(sym.loc_relocs == .none); - sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); coff.nodes.appendAssumeCapacity(.{ .pseudo_section = psmi }); break :sn sym.section_number; } else pseudo_section_gop.value_ptr.get(coff).section_number; @@ -3557,7 +3557,7 @@ fn objectSectionMapIndex( } else attributes; const object_section_gop = try coff.object_section_table.getOrPut(gpa, name); - const osmi: Node.ObjectSectionMapIndex = @enumFromInt(object_section_gop.index); + const osmi: Node.ObjectSectionMapIndex = @fromBackingInt(@intCast(object_section_gop.index)); const sym = if (!object_section_gop.found_existing) sym: { try coff.ensureUnusedStringCapacity(name_slice.len); const parent_name = coff.getOrPutStringAssumeCapacity(coff.objectSectionParentName(name_slice)); @@ -3593,7 +3593,7 @@ fn objectSectionMapIndex( sym.rva = coff.computeNodeRva(ni); sym.section_number = parent.get(coff).section_number; assert(sym.loc_relocs == .none); - sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); coff.nodes.appendAssumeCapacity(.{ .object_section = osmi }); break :sym sym; } else object_section_gop.value_ptr.get(coff); @@ -3723,7 +3723,7 @@ fn addRelocAssumeCapacity( const gpa = coff.base.comp.gpa; const target = target_si.get(coff); - const ri: Reloc.Index = @enumFromInt(coff.relocs.items.len); + const ri: Reloc.Index = @fromBackingInt(@intCast(coff.relocs.items.len)); log.debug("addReloc({d}@{d}+0x{x} -> {d}@{d}+0x{x}{s}) = {d}", .{ loc_si, loc_si.get(coff).section_number, @@ -3984,7 +3984,7 @@ fn loadObject( symbol_table_end + string_table_len > fl.size) return diags.failParse(path, "bad string table length: 0x{x}", .{string_table_len}); - const ioi: InputObject.Index = @enumFromInt(coff.input_objects.items.len); + const ioi: InputObject.Index = @fromBackingInt(@intCast(coff.input_objects.items.len)); try coff.input_objects.ensureUnusedCapacity(gpa, 1); const input = coff.input_objects.addOneAssumeCapacity(); input.* = .{ @@ -4013,13 +4013,13 @@ fn loadObject( _, pub fn wrap(i: ?u32) @This() { - return @enumFromInt((i orelse return .none) + 1); + return @fromBackingInt(@intCast((i orelse return .none) + 1)); } pub fn unwrap(i: @This()) ?u32 { return switch (i) { .none => null, - _ => @intFromEnum(i) - 1, + _ => @backingInt(i) - 1, }; } }; @@ -4208,12 +4208,12 @@ fn loadObject( switch (symbol.section_number) { .UNDEFINED, .DEBUG, .ABSOLUTE => {}, - else => |sn| if (@intFromEnum(sn) > sections.len) + else => |sn| if (@backingInt(sn) > sections.len) return diags.failParse(path, "out-of-bounds section number {d} in symbol 0x{x}", .{ sn, symbol_i }), } const psi: PendingSymbolIndex = .wrap(@intCast(pending_symbols.count())); - const section_number: Symbol.SectionNumber = @enumFromInt(@intFromEnum(symbol.section_number)); + const section_number: Symbol.SectionNumber = @fromBackingInt(@intCast(@backingInt(symbol.section_number))); const values: []const @FieldType(PendingSymbol, "value") = pending_symbols: switch (symbol.storage_class) { .STATIC, .LABEL => |storage_class| switch (section_number) { @@ -4270,7 +4270,7 @@ fn loadObject( .{ symbol_i + 1, name, section_def.number }, ); - section.comdat_association = @enumFromInt(section_def.number); + section.comdat_association = @fromBackingInt(@intCast(section_def.number)); } section.comdat = section_def.selection; @@ -4684,7 +4684,7 @@ fn loadObject( .alignment = section.header.flags.ALIGN.alignment() orelse .@"1", .moved = true, }); - coff.nodes.appendAssumeCapacity(.{ .input_section = @enumFromInt(coff.input_sections.items.len) }); + coff.nodes.appendAssumeCapacity(.{ .input_section = @fromBackingInt(@intCast(coff.input_sections.items.len)) }); section.si = coff.addSymbolAssumeCapacity(); if (section.psi.unwrap()) |psi| @@ -4701,7 +4701,7 @@ fn loadObject( .offset = fl.offset + section.header.pointer_to_raw_data, .size = section.header.size_of_raw_data, }, - .first_li = @enumFromInt(coff.input_symbols.items.len), + .first_li = @fromBackingInt(@intCast(coff.input_symbols.items.len)), .crc = section.comdat_crc, .comdat_si = if (section.comdat_psi.unwrap()) |psi| pending_symbols.values()[psi].si @@ -4888,7 +4888,7 @@ fn loadObject( const loc_sym = section.si.get(coff); assert(loc_sym.loc_relocs == .none); - loc_sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + loc_sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); if (section.header.number_of_relocations == 0) continue; @@ -4947,8 +4947,8 @@ fn loadObject( const lhs = &ctx.v[a_index]; const rhs = &ctx.v[b_index]; if (lhs.section_number == rhs.section_number) - return @intFromEnum(lhs.si) < @intFromEnum(rhs.si); - return @intFromEnum(lhs.section_number) < @intFromEnum(rhs.section_number); + return @backingInt(lhs.si) < @backingInt(rhs.si); + return @backingInt(lhs.section_number) < @backingInt(rhs.section_number); } }; @@ -4968,14 +4968,14 @@ fn loadObject( include_section = section.comdat_result == .include; if (include_section) { const isi = coff.getNode(section.si.get(coff).ni).input_section; - isi.inputSection(coff).first_li = @enumFromInt(coff.input_symbols.items.len); + isi.inputSection(coff).first_li = @fromBackingInt(@intCast(coff.input_symbols.items.len)); } } } if (include_section) { assert(coff.getNode(symbol.si.get(coff).ni) == .input_section); - symbol.si.get(coff).setExtra(.{ .isli = @enumFromInt(coff.input_symbols.items.len) }); + symbol.si.get(coff).setExtra(.{ .isli = @fromBackingInt(@intCast(coff.input_symbols.items.len)) }); coff.input_symbols.addOneAssumeCapacity().* = .{ .si = symbol.si, .name = symbol.name, @@ -5092,7 +5092,7 @@ fn loadArchive(coff: *Coff, path: std.Build.Cache.Path, fr: *Io.File.Reader) Loa }) = .empty; var symbol_member_indices: std.ArrayList(u32) = .empty; - const iai: InputArchive.Index = @enumFromInt(coff.input_archives.items.len); + const iai: InputArchive.Index = @fromBackingInt(@intCast(coff.input_archives.items.len)); (try coff.input_archives.addOne(gpa)).* = .{ .path = path, }; @@ -5103,13 +5103,13 @@ fn loadArchive(coff: *Coff, path: std.Build.Cache.Path, fr: *Io.File.Reader) Loa errdefer { for (coff.input_archive_symbol_indices.values()) |*v| { - if (@intFromEnum(v.last) < first_iamsi) continue; - if (@intFromEnum(v.first) >= first_iamsi) continue; + if (@backingInt(v.last) < first_iamsi) continue; + if (@backingInt(v.first) >= first_iamsi) continue; var iter = v.first; v.last = while (iter != v.last) { - const sym = &coff.input_archive_symbols.items[@intFromEnum(iter)]; - if (@intFromEnum(sym.next) >= first_iamsi) { + const sym = &coff.input_archive_symbols.items[@backingInt(iter)]; + if (@backingInt(sym.next) >= first_iamsi) { sym.next = iter; break iter; } @@ -5189,7 +5189,7 @@ fn loadArchive(coff: *Coff, path: std.Build.Cache.Path, fr: *Io.File.Reader) Loa }) |n| n else return diags.failParse(path, "unterminated string found in second linker member", .{}); const string = coff.getOrPutStringAssumeCapacity(name); - const iamsi: InputArchive.Member.Symbol.Index = @enumFromInt(coff.input_archive_symbols.items.len); + const iamsi: InputArchive.Member.Symbol.Index = @fromBackingInt(@intCast(coff.input_archive_symbols.items.len)); const symbol_gop = coff.input_archive_symbol_indices.getOrPutAssumeCapacity(string); if (!symbol_gop.found_existing) { symbol_gop.value_ptr.* = .{ @@ -5197,12 +5197,12 @@ fn loadArchive(coff: *Coff, path: std.Build.Cache.Path, fr: *Io.File.Reader) Loa .last = iamsi, }; } else { - coff.input_archive_symbols.items[@intFromEnum(symbol_gop.value_ptr.last)].next = iamsi; + coff.input_archive_symbols.items[@backingInt(symbol_gop.value_ptr.last)].next = iamsi; symbol_gop.value_ptr.last = iamsi; } const iami = members.items[symbol_member_indices.items[symbol_i]].iami orelse iami: { - const iami: InputArchive.Member.Index = @enumFromInt(coff.input_archive_members.items.len); + const iami: InputArchive.Member.Index = @fromBackingInt(@intCast(coff.input_archive_members.items.len)); const member_offset = members.items[symbol_member_indices.items[symbol_i]].offset; coff.input_archive_members.addOneAssumeCapacity().* = .{ .iai = iai, @@ -5271,7 +5271,7 @@ fn loadArchive(coff: *Coff, path: std.Build.Cache.Path, fr: *Io.File.Reader) Loa const member_sig = try r.peek(4); const machine: std.coff.IMAGE.FILE.MACHINE = - @enumFromInt(std.mem.readInt(u16, member_sig[0..2], target_endian)); + @fromBackingInt(@intCast(std.mem.readInt(u16, member_sig[0..2], target_endian))); const sig = std.mem.readInt(u16, member_sig[2..4], target_endian); log.debug("verifyArchiveMember({s}) = 0x{x}+{x}", .{ @@ -5484,7 +5484,7 @@ fn updateNavInner(coff: *Coff, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde } const sym = si.get(coff); assert(sym.loc_relocs == .none); - sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); if (!isImage(coff) and sym.target_relocs != .none) try coff.pendingSymbolTableEntry(si); @@ -5500,7 +5500,7 @@ fn updateNavInner(coff: *Coff, pt: Zcu.PerThread, nav_index: InternPool.Nav.Inde pt, .fromInterned(nav.resolved.?.value), &nw.interface, - .{ .atom_index = @enumFromInt(@intFromEnum(si)) }, + .{ .atom_index = @fromBackingInt(@intCast(@backingInt(si))) }, ) catch |err| switch (err) { error.WriteFailed => return nw.err.?, else => |e| return e, @@ -5554,7 +5554,7 @@ pub fn lowerUav( coff.const_prog_node.increaseEstimatedTotalItems(1); } } - return @enumFromInt(@intFromEnum(si)); + return @fromBackingInt(@intCast(@backingInt(si))); } pub fn updateFunc( @@ -5617,7 +5617,7 @@ fn updateFuncInner( } const sym = si.get(coff); assert(sym.loc_relocs == .none); - sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); if (!isImage(coff) and sym.target_relocs != .none) try coff.pendingSymbolTableEntry(si); break :ni sym.ni; @@ -5630,7 +5630,7 @@ fn updateFuncInner( &coff.base, pt, func_index, - @enumFromInt(@intFromEnum(si)), + @fromBackingInt(@intCast(@backingInt(si))), mir, &nw.interface, .none, @@ -5756,9 +5756,9 @@ fn reportUndefs(coff: *Coff, tid: Zcu.PerThread.Id) !void { const reloc_l = &ctx.relocs.items[lhs]; const reloc_r = &ctx.relocs.items[rhs]; if (reloc_l.target == reloc_r.target) - return @intFromEnum(reloc_l.loc) < @intFromEnum(reloc_r.loc) + return @backingInt(reloc_l.loc) < @backingInt(reloc_r.loc) else - return @intFromEnum(reloc_l.target) < @intFromEnum(reloc_r.target); + return @backingInt(reloc_l.target) < @backingInt(reloc_r.target); } }.lessThan; @@ -5798,7 +5798,7 @@ fn reportUndefs(coff: *Coff, tid: Zcu.PerThread.Id) !void { switch (coff.getNode(loc_sym.ni)) { .data_directories => { const dir: std.coff.IMAGE.DIRECTORY_ENTRY = - @enumFromInt(reloc.offset / @sizeOf(std.coff.ImageDataDirectory)); + @fromBackingInt(@intCast(reloc.offset / @sizeOf(std.coff.ImageDataDirectory))); err.addNote("referenced by data directory entry: {t}", .{dir}); }, .optional_header => err.addNote("referenced by optional header field", .{}), @@ -6095,7 +6095,7 @@ pub fn idle(coff: *Coff, tid: Zcu.PerThread.Id) !bool { task: { // TODO: Idle task for flushing obj into lib if (coff.input_section_pending_index < coff.input_sections.items.len) { - const isi: Node.InputSection.Index = @enumFromInt(coff.input_section_pending_index); + const isi: Node.InputSection.Index = @fromBackingInt(@intCast(coff.input_section_pending_index)); coff.input_section_pending_index += 1; const sub_prog_node = coff.idleProgNode(tid, coff.input_prog_node, coff.getNode(isi.symbol(coff).node(coff))); defer sub_prog_node.end(); @@ -6229,7 +6229,7 @@ fn flushUav( } const sym = si.get(coff); assert(sym.loc_relocs == .none); - sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); if (!isImage(coff) and sym.target_relocs != .none) try coff.pendingSymbolTableEntry(si); @@ -6244,7 +6244,7 @@ fn flushUav( pt, .fromInterned(uav_val), &nw.interface, - .{ .atom_index = @enumFromInt(@intFromEnum(si)) }, + .{ .atom_index = @fromBackingInt(@intCast(@backingInt(si))) }, ) catch |err| switch (err) { error.WriteFailed => return nw.err.?, else => |e| return e, @@ -6375,8 +6375,8 @@ fn flushGlobal(coff: *Coff, gmi: Node.GlobalMapIndex) !bool { const indices_list = opt_indices_list orelse continue; var iter: InputArchive.Member.Symbol.Index = indices_list.first; while (true) { - const archive_sym = &coff.input_archive_symbols.items[@intFromEnum(iter)]; - const member = &coff.input_archive_members.items[@intFromEnum(archive_sym.iami)]; + const archive_sym = &coff.input_archive_symbols.items[@backingInt(iter)]; + const member = &coff.input_archive_members.items[@backingInt(archive_sym.iami)]; member: switch (member.content) { .object => if (!member.flags.is_loaded) { if (gmi.libName(coff).unwrap()) |lib_name| @@ -6523,7 +6523,7 @@ fn flushGlobal(coff: *Coff, gmi: Node.GlobalMapIndex) !bool { const import_address_table_sym = import_address_table_si.get(coff); import_address_table_sym.ni = import_address_table_ni; assert(import_address_table_sym.loc_relocs == .none); - import_address_table_sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + import_address_table_sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); import_address_table_sym.section_number = coff.getNode(idata_section_ni).object_section.symbol(coff).get(coff).section_number; } @@ -6544,9 +6544,9 @@ fn flushGlobal(coff: *Coff, gmi: Node.GlobalMapIndex) !bool { @memcpy(import_hint_name_slice[0..lib_name.len], lib_name); @memcpy(import_hint_name_slice[lib_name.len..][0..".dll".len], ".dll"); @memset(import_hint_name_slice[lib_name.len + ".dll".len ..], 0); - coff.nodes.appendAssumeCapacity(.{ .import_lookup_table = @enumFromInt(gop.index) }); - coff.nodes.appendAssumeCapacity(.{ .import_address_table = @enumFromInt(gop.index) }); - coff.nodes.appendAssumeCapacity(.{ .import_hint_name_table = @enumFromInt(gop.index) }); + coff.nodes.appendAssumeCapacity(.{ .import_lookup_table = @fromBackingInt(@intCast(gop.index)) }); + coff.nodes.appendAssumeCapacity(.{ .import_address_table = @fromBackingInt(@intCast(gop.index)) }); + coff.nodes.appendAssumeCapacity(.{ .import_hint_name_table = @fromBackingInt(@intCast(gop.index)) }); const import_directory_entries = coff.importDirectoryTableSlice()[gop.index..][0..2]; import_directory_entries.* = .{ .{ @@ -6572,7 +6572,7 @@ fn flushGlobal(coff: *Coff, gmi: Node.GlobalMapIndex) !bool { ); const iat_symbol_gop = try coff.import_table.iat_symbol_indices.getOrPut(gpa, .{ - .iti = @enumFromInt(gop.index), + .iti = @fromBackingInt(@intCast(gop.index)), .name = import.name, .ordinal_hint = import.ordinal_hint, }); @@ -6645,7 +6645,7 @@ fn flushGlobal(coff: *Coff, gmi: Node.GlobalMapIndex) !bool { (try gop.value_ptr.import_address_table_symbols.addOne(gpa)).* = si; }, .thunk => { - sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); const target = &comp.root_mod.resolved_target.result; const alignment = switch (comp.root_mod.optimize_mode) { @@ -6738,7 +6738,7 @@ fn flushSpecialSymbol(coff: *Coff, pending: SpecialSymbol) !SpecialSymbol { const optional_hdr_sym = optional_hdr_si.get(coff); optional_hdr_sym.ni = Node.known.optional_header; assert(optional_hdr_sym.loc_relocs == .none); - optional_hdr_sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + optional_hdr_sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); const optional_hdr = coff.optionalHeaderStandardPtr(); optional_hdr.address_of_entry_point = std.mem.nativeTo( @@ -6785,7 +6785,7 @@ fn flushSpecialSymbol(coff: *Coff, pending: SpecialSymbol) !SpecialSymbol { const data_dir_sym = data_dir_si.get(coff); data_dir_sym.ni = Node.known.data_directories; assert(data_dir_sym.loc_relocs == .none); - data_dir_sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + data_dir_sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); try coff.addReloc( data_dir_si, @@ -6823,8 +6823,8 @@ fn flushLazy(coff: *Coff, pt: Zcu.PerThread, lmr: Node.LazyMapRef) !void { }; const ni = try coff.mf.addLastChildNode(gpa, sec_si.node(coff), .{ .moved = true }); coff.nodes.appendAssumeCapacity(switch (lazy.kind) { - .code => .{ .lazy_code = @enumFromInt(lmr.index) }, - .const_data => .{ .lazy_const_data = @enumFromInt(lmr.index) }, + .code => .{ .lazy_code = @fromBackingInt(@intCast(lmr.index)) }, + .const_data => .{ .lazy_const_data = @fromBackingInt(@intCast(lmr.index)) }, }); sym.ni = ni; sym.section_number = sec_si.get(coff).section_number; @@ -6832,7 +6832,7 @@ fn flushLazy(coff: *Coff, pt: Zcu.PerThread, lmr: Node.LazyMapRef) !void { else => si.deleteLocationRelocs(coff), } assert(sym.loc_relocs == .none); - sym.loc_relocs = @enumFromInt(coff.relocs.items.len); + sym.loc_relocs = @fromBackingInt(@intCast(coff.relocs.items.len)); if (!isImage(coff) and sym.target_relocs != .none) try coff.pendingSymbolTableEntry(si); @@ -6850,7 +6850,7 @@ fn flushLazy(coff: *Coff, pt: Zcu.PerThread, lmr: Node.LazyMapRef) !void { &required_alignment, &nw.interface, .none, - .{ .atom_index = @enumFromInt(@intFromEnum(si)) }, + .{ .atom_index = @fromBackingInt(@intCast(@backingInt(si))) }, ) catch |err| switch (err) { error.WriteFailed => return nw.err.?, else => |e| return e, @@ -6899,7 +6899,7 @@ fn flushMoved(coff: *Coff, ni: MappedFile.Node.Index) !void { switch (member.kind) { .first_linker, .second_linker, .longnames => {}, else => coff.targetStore( - &coff.secondLinkerMemberOffsetsSlice()[@intFromEnum(mi) - Member.Index.known_count], + &coff.secondLinkerMemberOffsetsSlice()[@backingInt(mi) - Member.Index.known_count], @intCast(ni.fileLocation(&coff.mf, false).offset), ), } @@ -6926,7 +6926,7 @@ fn flushMoved(coff: *Coff, ni: MappedFile.Node.Index) !void { }, .input_section => |isi| { try isi.symbol(coff).flushMoved(coff); - for (coff.input_symbols.items[@intFromEnum(isi.firstSymbol(coff))..]) |input_symbol| { + for (coff.input_symbols.items[@backingInt(isi.firstSymbol(coff))..]) |input_symbol| { if (input_symbol.si.get(coff).ni != ni) break; try input_symbol.si.flushMoved(coff); } @@ -7032,7 +7032,7 @@ fn flushMoved(coff: *Coff, ni: MappedFile.Node.Index) !void { coff.exportNamePointerTableSlice(), coff.exportOrdinalTableSlice(), ) |*np, target_ord| { - const ord: ExportTable.Ordinal = @enumFromInt(coff.targetLoad(&target_ord.unbiased_ordinal)); + const ord: ExportTable.Ordinal = @fromBackingInt(@intCast(coff.targetLoad(&target_ord.unbiased_ordinal))); const entry = ord.get(coff); coff.targetStore( &np.name_rva, @@ -7243,7 +7243,7 @@ fn flushMember(coff: *Coff, mi: Member.Index) !void { const file_offset: u32 = @intCast(member.header_ni.fileLocation(&coff.mf, false).offset); const first_linker_offsets = coff.firstLinkerMemberOffsetsSlice(); for (member.first_linker_indices.values()) |mfli| - first_linker_offsets[@intFromEnum(mfli)] = std.mem.nativeTo(u32, file_offset, .big); + first_linker_offsets[@backingInt(mfli)] = std.mem.nativeTo(u32, file_offset, .big); }, } } @@ -7323,7 +7323,7 @@ fn flushSectionMerge(coff: *Coff, index: u32) !void { @memcpy(from_name[0..to_slice.len], to_slice); @memset(from_name[to_slice.len..], 0); } else if (coff.pseudo_section_table.getIndex(from)) |from_index| { - const from_psmi: Node.PseudoSectionMapIndex = @enumFromInt(from_index); + const from_psmi: Node.PseudoSectionMapIndex = @fromBackingInt(@intCast(from_index)); const from_sym = from_psmi.symbol(coff).get(coff); if (opt_to_sec) |to_sec| { const to_sym = to_sec.si.get(coff); @@ -7395,11 +7395,11 @@ fn updateExportsInner( try coff.symbols.ensureUnusedCapacity(gpa, export_indices.len); const exported_si: Symbol.Index = switch (exported) { .nav => |nav| try coff.navSymbol(zcu, nav), - .uav => |uav| @enumFromInt(@intFromEnum(try coff.lowerUav( + .uav => |uav| @fromBackingInt(@intCast(@backingInt(try coff.lowerUav( pt, uav, Type.fromInterned(ip.typeOf(uav)).abiAlignment(zcu), - ))), + )))), }; switch (exported) { .nav => |nav| log.debug("updateExports({f}) = {d}", .{ ip.getNav(nav).fqn.fmt(ip), exported_si }), @@ -7479,7 +7479,7 @@ fn updateExportsInner( const ordinal_table_slice = coff.exportOrdinalTableSlice(); if (ordinal_table_slice.len > 0 and !coff.export_table.pending_sort) { const tail_index: ExportTable.Ordinal = - @enumFromInt(ordinal_table_slice[ordinal_table_slice.len - 1].unbiased_ordinal); + @fromBackingInt(@intCast(ordinal_table_slice[ordinal_table_slice.len - 1].unbiased_ordinal)); const tail_entry = tail_index.get(coff); const tail_name = name_table_slice[tail_entry.name_index..][0..tail_entry.name_len]; coff.export_table.pending_sort = std.mem.lessThan(u8, name, tail_name); @@ -7523,7 +7523,7 @@ fn updateExportsInner( .si = export_si, .name_index = @intCast(name_index), .name_len = @intCast(name.len), - .export_address_table_ri = @enumFromInt(coff.relocs.items.len), + .export_address_table_ri = @fromBackingInt(@intCast(coff.relocs.items.len)), }; try coff.addReloc( @@ -7583,7 +7583,7 @@ pub fn dump(coff: *Coff, w: *Io.Writer, tid: Zcu.PerThread.Id) !link.File.DumpRe try coff.printSection(w, name, sec.si); try w.writeAll("Symbol table:\n"); for (1..coff.symbols.items.len) |si| - try coff.printSymbol(w, tid, @enumFromInt(si)); + try coff.printSymbol(w, tid, @fromBackingInt(@intCast(si))); return .enabled; } @@ -7688,7 +7688,7 @@ fn printNodeName( const comdat_name = if (comdat_sym.gmi != .none) comdat_sym.gmi.name(coff).toSlice(coff) else - coff.input_symbols.items[@intFromEnum(comdat_sym.extra.isli)].name.toSlice(coff); + coff.input_symbols.items[@backingInt(comdat_sym.extra.isli)].name.toSlice(coff); try w.print("={s}", .{comdat_name}); } @@ -7755,10 +7755,10 @@ pub fn printNode( try w.writeAll(@tagName(node)); try coff.printNodeName(w, tid, node); { - const mf_node = &coff.mf.nodes.items[@intFromEnum(ni)]; + const mf_node = &coff.mf.nodes.items[@backingInt(ni)]; const off, const size = mf_node.location().resolve(&coff.mf); try w.print(" index={d} offset=0x{x} size=0x{x} align=0x{x}{s}{s}{s}{s}\n", .{ - @intFromEnum(ni), + @backingInt(ni), off, size, mf_node.flags.alignment.toByteUnits(), diff --git a/src/link/ConstPool.zig b/src/link/ConstPool.zig index 3ff2d9a540e1d47d2da7e5e3d9b441ff70effa6b..9cf25cd1cb690fe58acbc592e5bfe86a7f3ebd32 100644 --- a/src/link/ConstPool.zig +++ b/src/link/ConstPool.zig @@ -40,7 +40,7 @@ pub fn deinit(pool: *ConstPool, gpa: Allocator) void { pub const Index = enum(u32) { _, pub fn val(i: Index, pool: *const ConstPool) InternPool.Index { - return pool.values.keys()[@intFromEnum(i)]; + return pool.values.keys()[@backingInt(i)]; } }; @@ -107,15 +107,15 @@ const ContainerDepEntry = extern struct { fn unwrap(o: Optional) ?ContainerDepEntry.Index { return switch (o) { .none => null, - else => @enumFromInt(@intFromEnum(o)), + else => @fromBackingInt(@intCast(@backingInt(o))), }; } }; fn toOptional(i: ContainerDepEntry.Index) Optional { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } fn ptr(i: ContainerDepEntry.Index, pool: *ConstPool) *ContainerDepEntry { - return &pool.container_dep_entries.items[@intFromEnum(i)]; + return &pool.container_dep_entries.items[@backingInt(i)]; } }; }; @@ -148,7 +148,7 @@ pub fn get(pool: *ConstPool, pt: Zcu.PerThread, user: User, val: InternPool.Inde const ip = &zcu.intern_pool; const gpa = zcu.comp.gpa; const gop = try pool.values.getOrPut(gpa, val); - const index: ConstPool.Index = @enumFromInt(gop.index); + const index: ConstPool.Index = @fromBackingInt(@intCast(gop.index)); if (!gop.found_existing) { const ty: Type = switch (ip.typeOf(val)) { .type_type => if (ip.isUndef(val)) .type else .fromInterned(val), @@ -272,7 +272,7 @@ fn registerTypeDeps(pool: *ConstPool, root: Index, ty: Type, zcu: *const Zcu) Al errdefer comptime unreachable; const gop = pool.container_deps.getOrPutAssumeCapacity(ty.toIntern()); - const entry: ContainerDepEntry.Index = @enumFromInt(pool.container_dep_entries.items.len); + const entry: ContainerDepEntry.Index = @fromBackingInt(@intCast(pool.container_dep_entries.items.len)); pool.container_dep_entries.appendAssumeCapacity(.{ .next = if (gop.found_existing) gop.value_ptr.toOptional() else .none, .depender = root, diff --git a/src/link/Dwarf.zig b/src/link/Dwarf.zig index baa5be93e937a72c22193b3e159bd4df3b960ac1..1b2aa830d23ee24903085a36db49ce1a42c91c72 100644 --- a/src/link/Dwarf.zig +++ b/src/link/Dwarf.zig @@ -81,11 +81,11 @@ const ModInfo = struct { const DebugAbbrev = struct { section: Section, - const unit: Unit.Index = @enumFromInt(0); + const unit: Unit.Index = @fromBackingInt(@intCast(0)); const header_bytes = 0; - const trailer_bytes = uleb128Bytes(@intFromEnum(AbbrevCode.null)); + const trailer_bytes = uleb128Bytes(@backingInt(AbbrevCode.null)); }; const DebugAranges = struct { @@ -96,7 +96,7 @@ const DebugAranges = struct { } fn trailerBytes(dwarf: *Dwarf) u32 { - return @intFromEnum(dwarf.address_size) * 2; + return @backingInt(dwarf.address_size) * 2; } }; @@ -146,8 +146,8 @@ const DebugInfo = struct { fn headerBytes(dwarf: *Dwarf) u32 { return dwarf.unitLengthBytes() + 2 + 1 + 1 + dwarf.sectionOffsetBytes() + - uleb128Bytes(@intFromEnum(AbbrevCode.compile_unit)) + 1 + dwarf.sectionOffsetBytes() * 6 + uleb128Bytes(0) + - uleb128Bytes(@intFromEnum(AbbrevCode.module)) + dwarf.sectionOffsetBytes() + uleb128Bytes(0); + uleb128Bytes(@backingInt(AbbrevCode.compile_unit)) + 1 + dwarf.sectionOffsetBytes() * 6 + uleb128Bytes(0) + + uleb128Bytes(@backingInt(AbbrevCode.module)) + dwarf.sectionOffsetBytes() + uleb128Bytes(0); } fn declEntryLineOff(dwarf: *Dwarf) u32 { @@ -168,9 +168,9 @@ const DebugInfo = struct { debug_info.section.off(dwarf) + unit_ptr.off + unit_ptr.header_len + entry_ptr.off, ) != abbrev_code_buf.len) return error.InputOutput; var abbrev_code_reader: std.Io.Reader = .fixed(&abbrev_code_buf); - return @enumFromInt( + return @fromBackingInt(@intCast( abbrev_code_reader.takeLeb128(@typeInfo(AbbrevCode).@"enum".tag_type) catch unreachable, - ); + )); } const trailer_bytes = 1 + 1; @@ -202,7 +202,7 @@ const DebugLine = struct { const dir_index_info = dirIndexInfo(dir_count); return dwarf.unitLengthBytes() + 2 + 1 + 1 + dwarf.sectionOffsetBytes() + 1 + 1 + 1 + 1 + 1 + 1 + 1 * (dwarf.debug_line.header.opcode_base - 1) + 1 + uleb128Bytes(DW.LNCT.path) + uleb128Bytes(DW.FORM.line_strp) + uleb128Bytes(dir_count) + (dwarf.sectionOffsetBytes()) * dir_count + - 1 + uleb128Bytes(DW.LNCT.path) + uleb128Bytes(DW.FORM.line_strp) + uleb128Bytes(DW.LNCT.directory_index) + uleb128Bytes(@intFromEnum(dir_index_info.form)) + uleb128Bytes(DW.LNCT.LLVM_source) + uleb128Bytes(DW.FORM.line_strp) + uleb128Bytes(file_count) + (dwarf.sectionOffsetBytes() + dir_index_info.bytes + dwarf.sectionOffsetBytes()) * file_count; + 1 + uleb128Bytes(DW.LNCT.path) + uleb128Bytes(DW.FORM.line_strp) + uleb128Bytes(DW.LNCT.directory_index) + uleb128Bytes(@backingInt(dir_index_info.form)) + uleb128Bytes(DW.LNCT.LLVM_source) + uleb128Bytes(DW.FORM.line_strp) + uleb128Bytes(file_count) + (dwarf.sectionOffsetBytes() + dir_index_info.bytes + dwarf.sectionOffsetBytes()) * file_count; } const trailer_bytes = 1 + uleb128Bytes(1) + 1; @@ -239,7 +239,7 @@ const StringSection = struct { map: std.array_hash_map.Auto(void, void), section: Section, - const unit: Unit.Index = @enumFromInt(0); + const unit: Unit.Index = @fromBackingInt(@intCast(0)); const init: StringSection = .{ .contents = .empty, @@ -255,7 +255,7 @@ const StringSection = struct { fn addString(str_sec: *StringSection, dwarf: *Dwarf, str: []const u8) UpdateError!Entry.Index { const gop = try str_sec.map.getOrPutAdapted(dwarf.gpa, str, Adapter{ .str_sec = str_sec }); - const entry: Entry.Index = @enumFromInt(gop.index); + const entry: Entry.Index = @fromBackingInt(@intCast(gop.index)); if (!gop.found_existing) { errdefer _ = str_sec.map.pop(); const unit_ptr = str_sec.section.getUnit(unit); @@ -284,7 +284,7 @@ const StringSection = struct { } pub fn eql(adapter: Adapter, key: []const u8, _: void, rhs_index: usize) bool { - const entry = adapter.str_sec.section.getUnit(unit).getEntry(@enumFromInt(rhs_index)); + const entry = adapter.str_sec.section.getUnit(unit).getEntry(@fromBackingInt(@intCast(rhs_index))); return std.mem.eql(u8, key, adapter.str_sec.contents.items[entry.off..][0 .. entry.len - 1 :0]); } }; @@ -345,7 +345,7 @@ pub const Section = struct { } fn addUnit(sec: *Section, header_len: u32, trailer_len: u32, dwarf: *Dwarf) UpdateError!Unit.Index { - const unit: Unit.Index = @enumFromInt(sec.units.items.len); + const unit: Unit.Index = @fromBackingInt(@intCast(sec.units.items.len)); const unit_ptr = try sec.units.addOne(dwarf.gpa); errdefer sec.popUnit(dwarf.gpa); const aligned_header_len: u32 = @intCast(sec.alignment.forward(header_len)); @@ -385,14 +385,14 @@ pub const Section = struct { } fn popUnit(sec: *Section, gpa: Allocator) void { - const unit_index: Unit.Index = @enumFromInt(sec.units.items.len - 1); + const unit_index: Unit.Index = @fromBackingInt(@intCast(sec.units.items.len - 1)); sec.unlinkUnit(unit_index); var unit = sec.units.pop().?; unit.deinit(gpa); } pub fn getUnit(sec: *Section, unit: Unit.Index) *Unit { - return &sec.units.items[@intFromEnum(unit)]; + return &sec.units.items[@backingInt(unit)]; } fn resizeEntry( @@ -548,12 +548,12 @@ const Unit = struct { _, pub fn unwrap(uio: Optional) ?Index { - return if (uio != .none) @enumFromInt(@intFromEnum(uio)) else null; + return if (uio != .none) @fromBackingInt(@intCast(@backingInt(uio))) else null; } }; fn toOptional(ui: Index) Optional { - return @enumFromInt(@intFromEnum(ui)); + return @fromBackingInt(@intCast(@backingInt(ui))); } }; @@ -577,7 +577,7 @@ const Unit = struct { entry_ptr.next = .none; return entry; } - const entry: Entry.Index = @enumFromInt(unit.entries.items.len); + const entry: Entry.Index = @fromBackingInt(@intCast(unit.entries.items.len)); const entry_ptr = try unit.entries.addOne(gpa); entry_ptr.* = .{ .prev = .none, @@ -593,7 +593,7 @@ const Unit = struct { } pub fn getEntry(unit: *Unit, entry: Entry.Index) *Entry { - return &unit.entries.items[@intFromEnum(entry)]; + return &unit.entries.items[@backingInt(entry)]; } fn resize(unit_ptr: *Unit, sec: *Section, dwarf: *Dwarf, extra_header_len: u32, len: u32) UpdateError!void { @@ -719,11 +719,11 @@ const Unit = struct { defer trailer_aw.deinit(); const tw = &trailer_aw.writer; const fill_byte: u8 = if (sec == &dwarf.debug_abbrev.section) fill: { - tw.writeUleb128(@intFromEnum(AbbrevCode.null)) catch unreachable; - assert(uleb128Bytes(@intFromEnum(AbbrevCode.null)) == 1); - break :fill @intFromEnum(AbbrevCode.null); + tw.writeUleb128(@backingInt(AbbrevCode.null)) catch unreachable; + assert(uleb128Bytes(@backingInt(AbbrevCode.null)) == 1); + break :fill @backingInt(AbbrevCode.null); } else if (sec == &dwarf.debug_aranges.section) fill: { - tw.splatByteAll(0, @intFromEnum(dwarf.address_size) * 2) catch unreachable; + tw.splatByteAll(0, @backingInt(dwarf.address_size) * 2) catch unreachable; break :fill 0; } else if (sec == &dwarf.debug_frame.section) fill: { switch (dwarf.debug_frame.header.format) { @@ -746,7 +746,7 @@ const Unit = struct { } tw.writeByte(4) catch unreachable; tw.writeAll("\x00") catch unreachable; - tw.writeByte(@intFromEnum(dwarf.address_size)) catch unreachable; + tw.writeByte(@backingInt(dwarf.address_size)) catch unreachable; tw.writeByte(0) catch unreachable; }, .eh_frame => { @@ -763,9 +763,9 @@ const Unit = struct { tw.splatByteAll(DW.CFA.nop, unit.trailer_len - tw.end) catch unreachable; break :fill DW.CFA.nop; } else if (sec == &dwarf.debug_info.section) fill: { - for (0..2) |_| tw.writeUleb128(@intFromEnum(AbbrevCode.null)) catch unreachable; - assert(uleb128Bytes(@intFromEnum(AbbrevCode.null)) == 1); - break :fill @intFromEnum(AbbrevCode.null); + for (0..2) |_| tw.writeUleb128(@backingInt(AbbrevCode.null)) catch unreachable; + assert(uleb128Bytes(@backingInt(AbbrevCode.null)) == 1); + break :fill @backingInt(AbbrevCode.null); } else if (sec == &dwarf.debug_rnglists.section) fill: { tw.writeByte(DW.RLE.end_of_list) catch unreachable; break :fill DW.RLE.end_of_list; @@ -843,12 +843,12 @@ const Entry = struct { _, pub fn unwrap(eio: Optional) ?Index { - return if (eio != .none) @enumFromInt(@intFromEnum(eio)) else null; + return if (eio != .none) @fromBackingInt(@intCast(@backingInt(eio))) else null; } }; fn toOptional(ei: Index) Optional { - return @enumFromInt(@intFromEnum(ei)); + return @fromBackingInt(@intCast(@backingInt(ei))); } }; @@ -880,8 +880,8 @@ const Entry = struct { const len = unit.getEntry(entry.next.unwrap() orelse return).off - start; var buf: [ @max( - uleb128Bytes(@intFromEnum(AbbrevCode.pad_1)), - uleb128Bytes(@intFromEnum(AbbrevCode.pad_n)) + uleb128Bytes(std.math.maxInt(u32)), + uleb128Bytes(@backingInt(AbbrevCode.pad_1)), + uleb128Bytes(@backingInt(AbbrevCode.pad_n)) + uleb128Bytes(std.math.maxInt(u32)), 1 + uleb128Bytes(std.math.maxInt(u32)) + 1, ) ]u8 = undefined; @@ -984,17 +984,17 @@ const Entry = struct { defer dwarf.gpa.free(buf); _ = try dwarf.getFile().?.readPositionalAll(io, buf, sec.off(dwarf)); log.info("Section{{ .first = {}, .last = {}, .off = 0x{x}, .len = 0x{x} }}", .{ - @intFromEnum(sec.first), - @intFromEnum(sec.last), + @backingInt(sec.first), + @backingInt(sec.last), sec.off(dwarf), sec.len, }); for (sec.units.items) |*unit_ptr| { log.info(" Unit{{ .prev = {}, .next = {}, .first = {}, .last = {}, .off = 0x{x}, .header_len = 0x{x}, .trailer_len = 0x{x}, .len = 0x{x} }}", .{ - @intFromEnum(unit_ptr.prev), - @intFromEnum(unit_ptr.next), - @intFromEnum(unit_ptr.first), - @intFromEnum(unit_ptr.last), + @backingInt(unit_ptr.prev), + @backingInt(unit_ptr.next), + @backingInt(unit_ptr.first), + @backingInt(unit_ptr.last), unit_ptr.off, unit_ptr.header_len, unit_ptr.trailer_len, @@ -1002,8 +1002,8 @@ const Entry = struct { }); for (unit_ptr.entries.items) |*entry| { log.info(" Entry{{ .prev = {}, .next = {}, .off = 0x{x}, .len = 0x{x} }}", .{ - @intFromEnum(entry.prev), - @intFromEnum(entry.next), + @backingInt(entry.prev), + @backingInt(entry.next), entry.off, entry.len, }); @@ -1017,7 +1017,7 @@ const Entry = struct { if (entry.len > 0) return entry; if (std.debug.runtime_safety) { log.err("missing {} from {s}", .{ - @as(Entry.Index, @enumFromInt(entry - unit.entries.items.ptr)), + @as(Entry.Index, @fromBackingInt(@intCast(entry - unit.entries.items.ptr))), std.mem.sliceTo(if (dwarf.bin_file.cast(.elf)) |elf_file| elf_file.zigObjectPtr().?.symbol(sec.index).name(elf_file) else if (dwarf.bin_file.cast(.macho)) |macho_file| @@ -1031,19 +1031,19 @@ const Entry = struct { const zcu = dwarf.bin_file.comp.zcu.?; const ip = &zcu.intern_pool; for (0.., dwarf.values.items) |raw_index, unit_and_entry| { - const index: link.ConstPool.Index = @enumFromInt(raw_index); + const index: link.ConstPool.Index = @fromBackingInt(@intCast(raw_index)); const val = index.val(&dwarf.const_pool); const val_unit, const val_entry = unit_and_entry; if (sec.getUnit(val_unit) == unit and unit.getEntry(val_entry) == entry) log.err("missing Value({f}({d}))", .{ Value.fromInterned(val).fmtValue(.{ .tid = .main, .zcu = zcu }), - @intFromEnum(val), + @backingInt(val), }); } for (dwarf.navs.keys(), dwarf.navs.values()) |nav, other_entry| { const nav_unit = dwarf.getUnit(zcu.fileByIndex(ip.getNav(nav).srcInst(ip).resolveFile(ip)).mod.?) catch unreachable; if (sec.getUnit(nav_unit) == unit and unit.getEntry(other_entry) == entry) - log.err("missing Nav({f}({d}))", .{ ip.getNav(nav).fqn.fmt(ip), @intFromEnum(nav) }); + log.err("missing Nav({f}({d}))", .{ ip.getNav(nav).fqn.fmt(ip), @backingInt(nav) }); } } @panic("missing dwarf relocation target"); @@ -1108,7 +1108,7 @@ const Entry = struct { entry_off + reloc.source_off, @bitCast(symbol.address(.{}, elf_file) + @as(i64, @intCast(reloc.target_off)) - if (symbol.flags.is_tls) elf_file.dtpAddress() else 0), - @intFromEnum(dwarf.address_size), + @backingInt(dwarf.address_size), ); } } else if (dwarf.bin_file.cast(.macho)) |macho_file| { @@ -1118,7 +1118,7 @@ const Entry = struct { try dwarf.resolveReloc( entry_off + reloc.source_off, ref.getSymbol(macho_file).?.getAddress(.{}, macho_file) + @as(i64, @intCast(reloc.target_off)), - @intFromEnum(dwarf.address_size), + @backingInt(dwarf.address_size), ); } } @@ -1735,10 +1735,10 @@ pub const WipNav = struct { }; } fn leaveBlockWriterError(wip_nav: *WipNav, code_off: u64) (UpdateError || Writer.Error)!void { - const block_bytes = comptime uleb128Bytes(@intFromEnum(AbbrevCode.block)); + const block_bytes = comptime uleb128Bytes(@backingInt(AbbrevCode.block)); const block = wip_nav.blocks.pop().?; if (wip_nav.any_children) - try wip_nav.debug_info.writer.writeUleb128(@intFromEnum(AbbrevCode.null)) + try wip_nav.debug_info.writer.writeUleb128(@backingInt(AbbrevCode.null)) else std.leb.writeUnsignedFixed( block_bytes, @@ -1797,10 +1797,10 @@ pub const WipNav = struct { func: InternPool.Index, code_off: u64, ) (UpdateError || Writer.Error)!void { - const inlined_func_bytes = comptime uleb128Bytes(@intFromEnum(AbbrevCode.inlined_func)); + const inlined_func_bytes = comptime uleb128Bytes(@backingInt(AbbrevCode.inlined_func)); const block = wip_nav.blocks.pop().?; if (wip_nav.any_children) - try wip_nav.debug_info.writer.writeUleb128(@intFromEnum(AbbrevCode.null)) + try wip_nav.debug_info.writer.writeUleb128(@backingInt(AbbrevCode.null)) else std.leb.writeUnsignedFixed( inlined_func_bytes, @@ -1959,7 +1959,7 @@ pub const WipNav = struct { return @import("builtin").cpu.arch.endian(); } fn addrSym(counter: *ExprLocCounter, _: link.File.SymbolId) Writer.Error!void { - try counter.dw.writer.splatByteAll(undefined, @intFromEnum(counter.address_size)); + try counter.dw.writer.splatByteAll(undefined, @backingInt(counter.address_size)); } fn infoEntry(counter: *ExprLocCounter, _: Unit.Index, _: Entry.Index) Writer.Error!void { try counter.dw.writer.splatByteAll(undefined, counter.section_offset_bytes); @@ -2005,7 +2005,7 @@ pub const WipNav = struct { .target_sym = sym_index, .target_off = sym_off, }); - try diw.splatByteAll(0, @intFromEnum(wip_nav.dwarf.address_size)); + try diw.splatByteAll(0, @backingInt(wip_nav.dwarf.address_size)); } fn frameExprLoc(wip_nav: *WipNav, loc: Loc) (UpdateError || Writer.Error)!void { @@ -2047,7 +2047,7 @@ pub const WipNav = struct { .target_sym = sym_index, .target_off = sym_off, }); - try dfw.splatByteAll(0, @intFromEnum(wip_nav.dwarf.address_size)); + try dfw.splatByteAll(0, @backingInt(wip_nav.dwarf.address_size)); } fn refNav( @@ -2073,7 +2073,7 @@ pub const WipNav = struct { } const dwarf = wip_nav.dwarf; const index = try dwarf.const_pool.get(wip_nav.pt, .{ .dwarf = dwarf }, value.toIntern()); - return dwarf.values.items[@intFromEnum(index)]; + return dwarf.values.items[@backingInt(index)]; } fn refForward(wip_nav: *WipNav) (Allocator.Error || Writer.Error)!u32 { @@ -2438,14 +2438,14 @@ pub fn initMetadata(dwarf: *Dwarf) UpdateError!void { assert(try dwarf.debug_abbrev.section.addUnit(DebugAbbrev.header_bytes, DebugAbbrev.trailer_bytes, dwarf) == DebugAbbrev.unit); errdefer dwarf.debug_abbrev.section.popUnit(dwarf.gpa); for (std.enums.values(AbbrevCode)) |abbrev_code| - assert(@intFromEnum(try dwarf.debug_abbrev.section.getUnit(DebugAbbrev.unit).addEntry(dwarf.gpa)) == @intFromEnum(abbrev_code)); + assert(@backingInt(try dwarf.debug_abbrev.section.getUnit(DebugAbbrev.unit).addEntry(dwarf.gpa)) == @backingInt(abbrev_code)); dwarf.debug_aranges.section.pad_entries_to_ideal = false; - dwarf.debug_aranges.section.alignment = InternPool.Alignment.fromNonzeroByteUnits(@intFromEnum(dwarf.address_size) * 2); + dwarf.debug_aranges.section.alignment = InternPool.Alignment.fromNonzeroByteUnits(@backingInt(dwarf.address_size) * 2); dwarf.debug_frame.section.alignment = switch (dwarf.debug_frame.header.format) { .none => .@"1", - .debug_frame => InternPool.Alignment.fromNonzeroByteUnits(@intFromEnum(dwarf.address_size)), + .debug_frame => InternPool.Alignment.fromNonzeroByteUnits(@backingInt(dwarf.address_size)), .eh_frame => .@"4", }; @@ -2499,7 +2499,7 @@ fn getNavEntry( fn getUnit(dwarf: *Dwarf, mod: *Module) !Unit.Index { const mod_gop = try dwarf.mods.getOrPut(dwarf.gpa, mod); - const unit: Unit.Index = @enumFromInt(mod_gop.index); + const unit: Unit.Index = @fromBackingInt(@intCast(mod_gop.index)); if (!mod_gop.found_existing) { errdefer _ = dwarf.mods.pop(); mod_gop.value_ptr.* = .{ @@ -2550,15 +2550,15 @@ fn getUnit(dwarf: *Dwarf, mod: *Module) !Unit.Index { } fn getUnitIfExists(dwarf: *const Dwarf, mod: *Module) ?Unit.Index { - return @enumFromInt(dwarf.mods.getIndex(mod) orelse return null); + return @fromBackingInt(@intCast(dwarf.mods.getIndex(mod) orelse return null)); } fn getModInfo(dwarf: *Dwarf, unit: Unit.Index) *ModInfo { - return &dwarf.mods.values()[@intFromEnum(unit)]; + return &dwarf.mods.values()[@backingInt(unit)]; } fn getUnitModule(dwarf: *Dwarf, unit: Unit.Index) *Module { - return dwarf.mods.keys()[@intFromEnum(unit)]; + return dwarf.mods.keys()[@backingInt(unit)]; } pub fn initWipNav( @@ -2590,7 +2590,7 @@ fn initWipNavInner( file.sub_file_path, decl.src_line + 1, decl.src_column + 1, - @intFromEnum(inst_info.inst), + @backingInt(inst_info.inst), nav.fqn.fmt(ip), }); @@ -2650,7 +2650,7 @@ fn initWipNavInner( try wip_nav.refType(.fromInterned(param_type)); } if (func_type.is_var_args) try wip_nav.abbrevCode(.is_var_args); - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } } else try wip_nav.infoExprLoc(.{ .addr_reloc = sym_index }); }, @@ -2678,7 +2678,7 @@ fn initWipNavInner( try wip_nav.refType(.fromInterned(param_type)); } if (func_type.is_var_args) try wip_nav.abbrevCode(.is_var_args); - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } }, }, @@ -2720,7 +2720,7 @@ fn initWipNavInner( }); try dfw.splatByteAll(0, dwarf.sectionOffsetBytes()); try wip_nav.frameAddrSym(sym_index, 0); - try dfw.splatByteAll(undefined, @intFromEnum(dwarf.address_size)); + try dfw.splatByteAll(undefined, @backingInt(dwarf.address_size)); }, .eh_frame => { try dfw.writeInt(u32, undefined, dwarf.endian); @@ -2776,13 +2776,13 @@ fn initWipNavInner( try wip_nav.advancePCAndLine(func.lbrace_line, 0); } else { - try dlw.writeUleb128(1 + @intFromEnum(dwarf.address_size)); + try dlw.writeUleb128(1 + @backingInt(dwarf.address_size)); try dlw.writeByte(DW.LNE.set_address); try dwarf.debug_line.section.getUnit(wip_nav.unit).getEntry(wip_nav.entry).external_relocs.append(dwarf.gpa, .{ .source_off = @intCast(dlw.end), .target_sym = sym_index, }); - try dlw.splatByteAll(0, @intFromEnum(dwarf.address_size)); + try dlw.splatByteAll(0, @backingInt(dwarf.address_size)); const file_gop = try dwarf.getModInfo(unit).files.getOrPut(dwarf.gpa, inst_info.file); try dlw.writeByte(DW.LNS.set_file); @@ -2872,13 +2872,13 @@ fn finishWipNavFuncWriterError( const external_relocs = &dwarf.debug_aranges.section.getUnit(wip_nav.unit).getEntry(wip_nav.entry).external_relocs; try external_relocs.append(dwarf.gpa, .{ .target_sym = wip_nav.func_sym_index }); var entry: [8 + 8]u8 = undefined; - @memset(entry[0..@intFromEnum(dwarf.address_size)], 0); - dwarf.writeInt(entry[@intFromEnum(dwarf.address_size)..][0..@intFromEnum(dwarf.address_size)], code_size); + @memset(entry[0..@backingInt(dwarf.address_size)], 0); + dwarf.writeInt(entry[@backingInt(dwarf.address_size)..][0..@backingInt(dwarf.address_size)], code_size); try dwarf.debug_aranges.section.replaceEntry( wip_nav.unit, wip_nav.entry, dwarf, - entry[0 .. @intFromEnum(dwarf.address_size) * 2], + entry[0 .. @backingInt(dwarf.address_size) * 2], ); } switch (dwarf.debug_frame.header.format) { @@ -2901,7 +2901,7 @@ fn finishWipNavFuncWriterError( switch (format) { .none => unreachable, .debug_frame => dwarf.writeInt(contents[dwarf.unitLengthBytes() + dwarf.sectionOffsetBytes() + - @intFromEnum(dwarf.address_size) ..][0..@intFromEnum(dwarf.address_size)], code_size), + @backingInt(dwarf.address_size) ..][0..@backingInt(dwarf.address_size)], code_size), .eh_frame => { std.mem.writeInt( u32, @@ -2919,13 +2919,13 @@ fn finishWipNavFuncWriterError( std.mem.writeInt(u32, wip_nav.debug_info.written()[wip_nav.func_high_pc..][0..4], @intCast(code_size), dwarf.endian); if (wip_nav.any_children) { const diw = &wip_nav.debug_info.writer; - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } else { const abbrev_code_buf = wip_nav.debug_info.written()[0..AbbrevCode.decl_bytes]; var abbrev_code_fr: std.Io.Reader = .fixed(abbrev_code_buf); - const abbrev_code: AbbrevCode = @enumFromInt( + const abbrev_code: AbbrevCode = @fromBackingInt(@intCast( abbrev_code_fr.takeLeb128(@typeInfo(AbbrevCode).@"enum".tag_type) catch unreachable, - ); + )); std.leb.writeUnsignedFixed( AbbrevCode.decl_bytes, abbrev_code_buf, @@ -2944,7 +2944,7 @@ fn finishWipNavFuncWriterError( .target_sym = wip_nav.func_sym_index, }, .{ - .source_off = 1 + @intFromEnum(dwarf.address_size), + .source_off = 1 + @backingInt(dwarf.address_size), .target_sym = wip_nav.func_sym_index, .target_off = code_size, }, @@ -2953,7 +2953,7 @@ fn finishWipNavFuncWriterError( wip_nav.unit, wip_nav.entry, dwarf, - ([1]u8{DW.RLE.start_end} ++ @as([8 + 8]u8, @splat(0)))[0 .. 1 + @intFromEnum(dwarf.address_size) + @intFromEnum(dwarf.address_size)], + ([1]u8{DW.RLE.start_end} ++ @as([8 + 8]u8, @splat(0)))[0 .. 1 + @backingInt(dwarf.address_size) + @backingInt(dwarf.address_size)], ); } @@ -3015,7 +3015,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo file.sub_file_path, decl.src_line + 1, decl.src_column + 1, - @intFromEnum(inst_info.inst), + @backingInt(inst_info.inst), nav.fqn.fmt(ip), }); @@ -3248,7 +3248,7 @@ fn updateComptimeNavInner(dwarf: *Dwarf, pt: Zcu.PerThread, nav_index: InternPoo try wip_nav.refType(.fromInterned(func_type.param_types.get(ip)[param_index])); } if (func_type.is_var_args) try wip_nav.abbrevCode(.is_var_args); - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } }, .func_alias => |owner_nav| { @@ -3305,7 +3305,7 @@ fn addConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, index: link.ConstPool.Index, }, }; - assert(@intFromEnum(index) == dwarf.values.items.len); + assert(@backingInt(index) == dwarf.values.items.len); try dwarf.values.append(dwarf.gpa, .{ unit, entry }); } /// Should only be called by the `link.ConstPool` implementation. @@ -3332,7 +3332,7 @@ fn updateConstIncompleteInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_inde }), } - const unit, const entry = dwarf.values.items[@intFromEnum(debug_const_index)]; + const unit, const entry = dwarf.values.items[@backingInt(debug_const_index)]; for ([_]*Section{ &dwarf.debug_aranges.section, @@ -3501,7 +3501,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co }), } - const unit, const entry = dwarf.values.items[@intFromEnum(debug_const_index)]; + const unit, const entry = dwarf.values.items[@backingInt(debug_const_index)]; for ([_]*Section{ &dwarf.debug_aranges.section, @@ -3556,7 +3556,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.strpFmt("{f}", .{val.toType().fmt(pt)}); if (ptr_type.sentinel != .none) try wip_nav.blockValue(.fromInterned(ptr_type.sentinel)); if (ptr_type.flags.alignment.toByteUnits()) |a| try diw.writeUleb128(a); - try diw.writeByte(@intFromEnum(ptr_type.flags.address_space)); + try diw.writeByte(@backingInt(ptr_type.flags.address_space)); if (ptr_type.flags.is_const or ptr_type.flags.is_volatile) try wip_nav.infoSectionOffset( .debug_info, wip_nav.unit, @@ -3592,7 +3592,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co const len_field_type: Type = .usize; try wip_nav.refType(len_field_type); try diw.writeUleb128(len_field_type.abiAlignment(zcu).forward(ptr_field_type.abiSize(zcu))); - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, }, .array_type => |array_type| { @@ -3604,7 +3604,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.abbrevCode(.array_len); try wip_nav.refType(.usize); try diw.writeUleb128(array_type.len); - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .vector_type => |vector_type| { try wip_nav.abbrevCode(.vector_type); @@ -3613,7 +3613,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.abbrevCode(.array_len); try wip_nav.refType(.usize); try diw.writeUleb128(vector_type.len); - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .opt_type => |opt_child_type_index| { const opt_child_type: Type = .fromInterned(opt_child_type_index); @@ -3671,7 +3671,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.refType(.null); try diw.writeUleb128(0); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); try wip_nav.abbrevCode(.tagged_union_default_field); { @@ -3680,12 +3680,12 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.refType(opt_child_type); try diw.writeUleb128(0); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .anyframe_type => unreachable, .error_union_type => |error_union_type| { @@ -3736,7 +3736,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.refType(error_union_payload_type); try diw.writeUleb128(error_union_payload_offset); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); try wip_nav.abbrevCode(.tagged_union_default_field); { @@ -3745,11 +3745,11 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.refType(error_union_error_set_type); try diw.writeUleb128(error_union_error_set_offset); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .simple_type => |simple_type| switch (simple_type) { .f16, @@ -3850,7 +3850,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co else if (has_runtime_bits) try wip_nav.blockValue(.fromInterned(comptime_value)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .struct_type => { const loaded_struct = ip.loadStructType(value_index); @@ -3937,7 +3937,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co else if (has_runtime_bits) try wip_nav.blockValue(.fromInterned(field_init)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } }, .@"packed" => { @@ -3968,7 +3968,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try diw.writeUleb128(field_bit_offset); field_bit_offset += @intCast(field_type.bitSize(zcu)); } - if (need_terminator) try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + if (need_terminator) try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, } }, @@ -4024,10 +4024,10 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } else for (0..loaded_union.field_types.len) |field_index| { try wip_nav.abbrevCode(.field); try wip_nav.strp(loaded_tag.field_names.get(ip)[field_index].toSlice(ip)); @@ -4037,7 +4037,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try diw.writeUleb128(loaded_union.field_aligns.getOrNone(ip, field_index).toByteUnits() orelse if (field_type.isNoReturn(zcu)) 1 else field_type.abiAlignment(zcu).toByteUnits().?); } - if (need_terminator) try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + if (need_terminator) try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .@"packed" => { const need_terminator: bool = if (loaded_union.name_nav.unwrap()) |nav_index| t: { @@ -4064,7 +4064,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.refType(.fromInterned(loaded_union.field_types.get(ip)[field_index])); try diw.writeUleb128(0); } - if (need_terminator) try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + if (need_terminator) try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, } }, @@ -4098,7 +4098,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.enumConstValue(loaded_enum, field_index); try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip)); } - if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null)); } else { assert(loaded_enum.owner_union != .none); try wip_nav.abbrevCode(if (loaded_enum.field_names.len == 0) .generated_empty_enum_type else .generated_enum_type); @@ -4109,7 +4109,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.enumConstValue(loaded_enum, field_index); try wip_nav.strp(loaded_enum.field_names.get(ip)[field_index].toSlice(ip)); } - if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + if (loaded_enum.field_names.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null)); } }, .opaque_type => { @@ -4204,7 +4204,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co else => .nocall, }; }; - try diw.writeByte(@intFromEnum(cc)); + try diw.writeByte(@backingInt(cc)); try wip_nav.refType(.fromInterned(func_type.return_type)); if (!is_nullary) { for (0..func_type.param_types.len) |param_index| { @@ -4212,7 +4212,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.refType(.fromInterned(func_type.param_types.get(ip)[param_index])); } if (func_type.is_var_args) try wip_nav.abbrevCode(.is_var_args); - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } }, .error_set_type => |error_set_type| { @@ -4229,7 +4229,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try diw.writeUleb128(ip.getErrorValueIfExists(field_name).?); try wip_nav.strp(field_name.toSlice(ip)); } - if (error_set_type.names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + if (error_set_type.names.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .inferred_error_set_type => |func| { try wip_nav.abbrevCode(.inferred_error_set_type); @@ -4311,7 +4311,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try diw.writeUleb128(err_bytes.len); try diw.writeAll(err_bytes); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .enum_literal => |enum_literal| { try wip_nav.abbrevCode(.comptime_value); @@ -4459,7 +4459,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.strp(field_name); }, }; - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); } }, .slice => |slice| { @@ -4475,7 +4475,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co try wip_nav.strp("len"); try wip_nav.blockValue(.fromInterned(slice.len)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .opt => |opt| { const opt_child_type: Type = .fromInterned(ip.indexToKey(opt.ty).opt_type); @@ -4505,7 +4505,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co else try wip_nav.blockValue(.fromInterned(opt.val)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .aggregate => |aggregate| { try wip_nav.abbrevCode(.aggregate_undefined_comptime_value); @@ -4586,7 +4586,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co }, else => unreachable, } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .un => |un| { try wip_nav.abbrevCode(.aggregate_undefined_comptime_value); @@ -4611,7 +4611,7 @@ fn updateConstInner(dwarf: *Dwarf, pt: Zcu.PerThread, debug_const_index: link.Co else if (has_runtime_bits) try wip_nav.blockValue(.fromInterned(un.val)); } - try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + try diw.writeUleb128(@backingInt(AbbrevCode.null)); }, .memoized_call => unreachable, // not a value } @@ -4644,7 +4644,7 @@ pub fn updateLineNumber(dwarf: *Dwarf, zcu: *Zcu, zir_index: InternPool.TrackedI file.sub_file_path, decl.src_line + 1, decl.src_column + 1, - @intFromEnum(inst_info.inst), + @backingInt(inst_info.inst), file.zir.?.nullTerminatedString(decl.name), }); @@ -4666,19 +4666,19 @@ fn refAbbrevCode( abbrev_code: AbbrevCode, ) (UpdateError || Writer.Error)!@typeInfo(AbbrevCode).@"enum".tag_type { assert(abbrev_code != .null); - const entry: Entry.Index = @enumFromInt(@intFromEnum(abbrev_code)); - if (dwarf.debug_abbrev.section.getUnit(DebugAbbrev.unit).getEntry(entry).len > 0) return @intFromEnum(abbrev_code); + const entry: Entry.Index = @fromBackingInt(@intCast(@backingInt(abbrev_code))); + if (dwarf.debug_abbrev.section.getUnit(DebugAbbrev.unit).getEntry(entry).len > 0) return @backingInt(abbrev_code); var debug_abbrev_aw: Writer.Allocating = .init(dwarf.gpa); defer debug_abbrev_aw.deinit(); const daw = &debug_abbrev_aw.writer; const abbrev = AbbrevCode.abbrevs.get(abbrev_code); - try daw.writeUleb128(@intFromEnum(abbrev_code)); - try daw.writeUleb128(@intFromEnum(abbrev.tag)); + try daw.writeUleb128(@backingInt(abbrev_code)); + try daw.writeUleb128(@backingInt(abbrev.tag)); try daw.writeByte(if (abbrev.children) DW.CHILDREN.yes else DW.CHILDREN.no); - for (abbrev.attrs) |*attr| inline for (attr) |info| try daw.writeUleb128(@intFromEnum(info)); + for (abbrev.attrs) |*attr| inline for (attr) |info| try daw.writeUleb128(@backingInt(info)); for (0..2) |_| try daw.writeUleb128(0); try dwarf.debug_abbrev.section.replaceEntry(DebugAbbrev.unit, entry, dwarf, debug_abbrev_aw.written()); - return @intFromEnum(abbrev_code); + return @backingInt(abbrev_code); } pub fn flush(dwarf: *Dwarf, pt: Zcu.PerThread) UpdateError!void { @@ -4696,7 +4696,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err // Update `anyerror` based on the finished global error set. { const index = try dwarf.const_pool.get(pt, .{ .dwarf = dwarf }, .anyerror_type); - const unit, const entry = dwarf.values.items[@intFromEnum(index)]; + const unit, const entry = dwarf.values.items[@backingInt(index)]; var wip_nav: WipNav = .{ .dwarf = dwarf, .pt = pt, @@ -4728,7 +4728,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err try diw.writeUleb128(value); try wip_nav.strp(name.toSlice(ip)); } - if (global_error_set_names.len > 0) try diw.writeUleb128(@intFromEnum(AbbrevCode.null)); + if (global_error_set_names.len > 0) try diw.writeUleb128(@backingInt(AbbrevCode.null)); try dwarf.debug_info.section.replaceEntry(wip_nav.unit, wip_nav.entry, dwarf, wip_nav.debug_info.written()); try dwarf.const_pool.flushPending(pt, .{ .dwarf = dwarf }); } @@ -4744,7 +4744,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err const hw = &header_aw.writer; if (dwarf.debug_aranges.section.dirty) { for (dwarf.debug_aranges.section.units.items, 0..) |*unit_ptr, unit_index| { - const unit: Unit.Index = @enumFromInt(unit_index); + const unit: Unit.Index = @fromBackingInt(@intCast(unit_index)); unit_ptr.clear(); try unit_ptr.cross_section_relocs.ensureTotalCapacity(dwarf.gpa, 1); header_aw.clearRetainingCapacity(); @@ -4767,7 +4767,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err .target_unit = unit, }); hw.splatByteAll(0, dwarf.sectionOffsetBytes()) catch unreachable; - hw.writeByte(@intFromEnum(dwarf.address_size)) catch unreachable; + hw.writeByte(@backingInt(dwarf.address_size)) catch unreachable; hw.writeByte(0) catch unreachable; hw.splatByteAll(0, unit_ptr.header_len - hw.end) catch unreachable; try unit_ptr.replaceHeader(&dwarf.debug_aranges.section, dwarf, header_aw.written()); @@ -4820,7 +4820,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err } if (dwarf.debug_info.section.dirty) { for (dwarf.mods.keys(), dwarf.mods.values(), dwarf.debug_info.section.units.items, 0..) |mod, mod_info, *unit_ptr, unit_index| { - const unit: Unit.Index = @enumFromInt(unit_index); + const unit: Unit.Index = @fromBackingInt(@intCast(unit_index)); unit_ptr.clear(); try unit_ptr.cross_unit_relocs.ensureTotalCapacity(dwarf.gpa, 1); try unit_ptr.cross_section_relocs.ensureTotalCapacity(dwarf.gpa, 7); @@ -4839,7 +4839,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err } hw.writeInt(u16, 5, dwarf.endian) catch unreachable; hw.writeByte(DW.UT.compile) catch unreachable; - hw.writeByte(@intFromEnum(dwarf.address_size)) catch unreachable; + hw.writeByte(@backingInt(dwarf.address_size)) catch unreachable; unit_ptr.cross_section_relocs.appendAssumeCapacity(.{ .source_off = @intCast(hw.end), .target_sec = .debug_abbrev, @@ -4938,7 +4938,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err }, } hw.writeInt(u16, 5, dwarf.endian) catch unreachable; - hw.writeByte(@intFromEnum(dwarf.address_size)) catch unreachable; + hw.writeByte(@backingInt(dwarf.address_size)) catch unreachable; hw.writeByte(0) catch unreachable; switch (dwarf.format) { .@"32" => hw.writeInt(u32, @intCast(unit.header_len - hw.end - 4), dwarf.endian) catch unreachable, @@ -4986,7 +4986,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err hw.writeUleb128(DW.LNCT.path) catch unreachable; hw.writeUleb128(DW.FORM.line_strp) catch unreachable; hw.writeUleb128(DW.LNCT.directory_index) catch unreachable; - hw.writeUleb128(@intFromEnum(dir_index_info.form)) catch unreachable; + hw.writeUleb128(@backingInt(dir_index_info.form)) catch unreachable; hw.writeUleb128(DW.LNCT.LLVM_source) catch unreachable; hw.writeUleb128(DW.FORM.line_strp) catch unreachable; hw.writeUleb128(mod_info.files.count()) catch unreachable; @@ -5046,7 +5046,7 @@ fn flushWriterError(dwarf: *Dwarf, pt: Zcu.PerThread) (UpdateError || Writer.Err }, } hw.writeInt(u16, 5, dwarf.endian) catch unreachable; - hw.writeByte(@intFromEnum(dwarf.address_size)) catch unreachable; + hw.writeByte(@backingInt(dwarf.address_size)) catch unreachable; hw.writeByte(0) catch unreachable; hw.writeInt(u32, 1, dwarf.endian) catch unreachable; switch (dwarf.format) { @@ -5238,11 +5238,11 @@ const AbbrevCode = enum { comptime_value_elem_runtime_bits, comptime_value_elem_comptime_state, - const decl_bytes = uleb128Bytes(@intFromEnum(AbbrevCode.decl_instance_extern_func)); + const decl_bytes = uleb128Bytes(@backingInt(AbbrevCode.decl_instance_extern_func)); comptime { - assert(uleb128Bytes(@intFromEnum(AbbrevCode.pad_1)) == 1); - assert(uleb128Bytes(@intFromEnum(AbbrevCode.pad_n)) == 1); - assert(uleb128Bytes(@intFromEnum(AbbrevCode.decl_alias)) == decl_bytes); + assert(uleb128Bytes(@backingInt(AbbrevCode.pad_1)) == 1); + assert(uleb128Bytes(@backingInt(AbbrevCode.pad_n)) == 1); + assert(uleb128Bytes(@backingInt(AbbrevCode.decl_alias)) == decl_bytes); } const Attr = struct { diff --git a/src/link/Elf.zig b/src/link/Elf.zig index d64d429bb0bc7d03f3e152615cbf81434e67515e..d0448f575793e6af830d9ae3b37cf3ca827a89bb 100644 --- a/src/link/Elf.zig +++ b/src/link/Elf.zig @@ -135,12 +135,12 @@ const OptionalProgramHeaderIndex = enum(u16) { fn unwrap(i: OptionalProgramHeaderIndex) ?ProgramHeaderIndex { if (i == .none) return null; - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } fn int(i: OptionalProgramHeaderIndex) ?u16 { if (i == .none) return null; - return @intFromEnum(i); + return @backingInt(i); } }; @@ -148,13 +148,13 @@ const ProgramHeaderIndex = enum(u16) { _, fn toOptional(i: ProgramHeaderIndex) OptionalProgramHeaderIndex { - const result: OptionalProgramHeaderIndex = @enumFromInt(@intFromEnum(i)); + const result: OptionalProgramHeaderIndex = @fromBackingInt(@intCast(@backingInt(i))); assert(result != .none); return result; } fn int(i: ProgramHeaderIndex) u16 { - return @intFromEnum(i); + return @backingInt(i); } }; @@ -1531,7 +1531,7 @@ pub fn writeElfHeader(self: *Elf) !void { hdr_buf[index] = 1; // ELF version index += 1; - hdr_buf[index] = @intFromEnum(@as(elf.OSABI, switch (target.cpu.arch) { + hdr_buf[index] = @backingInt(@as(elf.OSABI, switch (target.cpu.arch) { .amdgcn => switch (target.os.tag) { .amdhsa => .AMDGPU_HSA, .amdpal => .AMDGPU_PAL, @@ -1566,11 +1566,11 @@ pub fn writeElfHeader(self: *Elf) !void { .dynamic => .DYN, }, }; - mem.writeInt(u16, hdr_buf[index..][0..2], @intFromEnum(elf_type), endian); + mem.writeInt(u16, hdr_buf[index..][0..2], @backingInt(elf_type), endian); index += 2; const machine = target.toElfMachine(); - mem.writeInt(u16, hdr_buf[index..][0..2], @intFromEnum(machine), endian); + mem.writeInt(u16, hdr_buf[index..][0..2], @backingInt(machine), endian); index += 2; // ELF Version, again @@ -2314,13 +2314,13 @@ fn sortPhdrs( inline for (@typeInfo(ProgramHeaderIndexes).@"struct".field_names) |field_name| { if (@field(special_indexes, field_name).int()) |special_index| { - @field(special_indexes, field_name) = @enumFromInt(backlinks[special_index]); + @field(special_indexes, field_name) = @fromBackingInt(@intCast(backlinks[special_index])); } } for (section_indexes) |*opt_phndx| { if (opt_phndx.int()) |index| { - opt_phndx.* = @enumFromInt(backlinks[index]); + opt_phndx.* = @fromBackingInt(@intCast(backlinks[index])); } } } @@ -3398,7 +3398,7 @@ fn getPhdr(self: *Elf, opts: struct { if (phndx == index) continue; } if (phdr.p_type == opts.type and phdr.p_flags == opts.flags) - return @enumFromInt(phndx); + return @fromBackingInt(@intCast(phndx)); } return .none; } @@ -3413,7 +3413,7 @@ fn addPhdr(self: *Elf, opts: struct { memsz: u64 = 0, }) error{OutOfMemory}!ProgramHeaderIndex { const gpa = self.base.comp.gpa; - const index: ProgramHeaderIndex = @enumFromInt(self.phdrs.items.len); + const index: ProgramHeaderIndex = @fromBackingInt(@intCast(self.phdrs.items.len)); try self.phdrs.append(gpa, .{ .p_type = opts.type, .p_flags = opts.flags, @@ -4345,7 +4345,7 @@ fn createThunks(elf_file: *Elf, atom_list: *AtomList) !void { for (atom_ptr.relocs(elf_file)) |rel| { const is_reachable = switch (cpu_arch) { .aarch64, .aarch64_be => r: { - const r_type: elf.R_AARCH64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_AARCH64 = @fromBackingInt(@intCast(rel.r_type())); if (r_type != .CALL26 and r_type != .JUMP26) break :r true; const target_ref = file_ptr.resolveSymbol(rel.r_sym(), elf_file); const target = elf_file.symbol(target_ref).?; diff --git a/src/link/Elf/Atom.zig b/src/link/Elf/Atom.zig index 269959c9eefc15814c063b53edc0aad90e3032df..075d4aced771cef907276dba8196b981c063369e 100644 --- a/src/link/Elf/Atom.zig +++ b/src/link/Elf/Atom.zig @@ -288,7 +288,7 @@ pub fn scanRelocsRequiresCode(self: Atom, elf_file: *Elf) bool { for (self.relocs(elf_file)) |rel| { switch (cpu_arch) { .x86_64 => { - const r_type: elf.R_X86_64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_X86_64 = @fromBackingInt(@intCast(rel.r_type())); if (r_type == .GOTTPOFF) return true; }, else => {}, @@ -950,7 +950,7 @@ const x86_64 = struct { const is_static = elf_file.base.isStatic(); const is_dyn_lib = elf_file.isEffectivelyDynLib(); - const r_type: elf.R_X86_64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_X86_64 = @fromBackingInt(@intCast(rel.r_type())); const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow; switch (r_type) { @@ -1062,7 +1062,7 @@ const x86_64 = struct { dev.check(.x86_64_backend); const t = &elf_file.base.comp.root_mod.resolved_target.result; const diags = &elf_file.base.comp.link_diags; - const r_type: elf.R_X86_64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_X86_64 = @fromBackingInt(@intCast(rel.r_type())); const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow; const P, const A, const S, const GOT, const G, const TP, const DTP = args; @@ -1201,7 +1201,7 @@ const x86_64 = struct { code: []u8, ) !void { dev.check(.x86_64_backend); - const r_type: elf.R_X86_64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_X86_64 = @fromBackingInt(@intCast(rel.r_type())); _, const A, const S, const GOT, _, _, const DTP = args; @@ -1282,7 +1282,7 @@ const x86_64 = struct { dev.check(.x86_64_backend); assert(rels.len == 2); const diags = &elf_file.base.comp.link_diags; - const rel: elf.R_X86_64 = @enumFromInt(rels[1].r_type()); + const rel: elf.R_X86_64 = @fromBackingInt(@intCast(rels[1].r_type())); switch (rel) { .PC32, .PLT32, @@ -1322,7 +1322,7 @@ const x86_64 = struct { dev.check(.x86_64_backend); assert(rels.len == 2); const diags = &elf_file.base.comp.link_diags; - const rel: elf.R_X86_64 = @enumFromInt(rels[1].r_type()); + const rel: elf.R_X86_64 = @fromBackingInt(@intCast(rels[1].r_type())); switch (rel) { .PC32, .PLT32, @@ -1428,7 +1428,7 @@ const x86_64 = struct { dev.check(.x86_64_backend); assert(rels.len == 2); const diags = &elf_file.base.comp.link_diags; - const rel: elf.R_X86_64 = @enumFromInt(rels[1].r_type()); + const rel: elf.R_X86_64 = @fromBackingInt(@intCast(rels[1].r_type())); switch (rel) { .PC32, .PLT32, @@ -1493,7 +1493,7 @@ const aarch64 = struct { _ = code; _ = it; - const r_type: elf.R_AARCH64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_AARCH64 = @fromBackingInt(@intCast(rel.r_type())); const is_dyn_lib = elf_file.isEffectivelyDynLib(); switch (r_type) { @@ -1571,7 +1571,7 @@ const aarch64 = struct { _ = it; const diags = &elf_file.base.comp.link_diags; - const r_type: elf.R_AARCH64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_AARCH64 = @fromBackingInt(@intCast(rel.r_type())); const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow; const code = code_buffer[r_offset..][0..4]; const file_ptr = atom.file(elf_file).?; @@ -1742,7 +1742,7 @@ const aarch64 = struct { args: ResolveArgs, code: []u8, ) !void { - const r_type: elf.R_AARCH64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_AARCH64 = @fromBackingInt(@intCast(rel.r_type())); _, const A, const S, _, _, _, _ = args; @@ -1773,7 +1773,7 @@ const riscv = struct { _ = code; _ = it; - const r_type: elf.R_RISCV = @enumFromInt(rel.r_type()); + const r_type: elf.R_RISCV = @fromBackingInt(@intCast(rel.r_type())); switch (r_type) { .@"32" => try atom.scanReloc(symbol, rel, absRelocAction(symbol, elf_file), elf_file), @@ -1816,7 +1816,7 @@ const riscv = struct { code: []u8, ) !void { const diags = &elf_file.base.comp.link_diags; - const r_type: elf.R_RISCV = @enumFromInt(rel.r_type()); + const r_type: elf.R_RISCV = @fromBackingInt(@intCast(rel.r_type())); const r_offset = std.math.cast(usize, rel.r_offset) orelse return error.Overflow; const P, const A, const S, const GOT, const G, const TP, const DTP = args; @@ -1893,7 +1893,7 @@ const riscv = struct { const A_ = pair.r_addend; const P_ = atom_addr + @as(i64, @intCast(pair.r_offset)); const G_ = target_.gotAddress(elf_file) - GOT; - const disp = switch (@as(elf.R_RISCV, @enumFromInt(pair.r_type()))) { + const disp = switch (@as(elf.R_RISCV, @fromBackingInt(@intCast(pair.r_type())))) { .PCREL_HI20 => math.cast(i32, S_ + A_ - P_) orelse return error.Overflow, .GOT_HI20 => math.cast(i32, G_ + GOT + A_ - P_) orelse return error.Overflow, else => unreachable, @@ -1951,7 +1951,7 @@ const riscv = struct { args: ResolveArgs, code: []u8, ) !void { - const r_type: elf.R_RISCV = @enumFromInt(rel.r_type()); + const r_type: elf.R_RISCV = @fromBackingInt(@intCast(rel.r_type())); _, const A, const S, const GOT, _, _, const DTP = args; _ = GOT; diff --git a/src/link/Elf/LinkerDefined.zig b/src/link/Elf/LinkerDefined.zig index 658e2aeea5a888967492b1fe4b3772435465f230..04f5a83602321141b4bf43741e94a2019318f51a 100644 --- a/src/link/Elf/LinkerDefined.zig +++ b/src/link/Elf/LinkerDefined.zig @@ -48,7 +48,7 @@ fn newSymbolAssumeCapacity(self: *LinkerDefined, name_off: u32, elf_file: *Elf) esym.* = .{ .st_name = name_off, .st_info = @as(u8, elf.STB_WEAK) << 4, - .st_other = @intFromEnum(elf.STV.HIDDEN), + .st_other = @backingInt(elf.STV.HIDDEN), .st_shndx = elf.SHN_ABS, .st_value = 0, .st_size = 0, diff --git a/src/link/Elf/Object.zig b/src/link/Elf/Object.zig index 64080389b7b331747ecdf7699f2aa3b4f850138f..960df2a52ec5ea63820a5b64e6c0bbd490152ec5 100644 --- a/src/link/Elf/Object.zig +++ b/src/link/Elf/Object.zig @@ -665,7 +665,7 @@ pub fn claimUnresolved(self: *Object, elf_file: *Elf) void { const is_import = blk: { if (!elf_file.isEffectivelyDynLib()) break :blk false; - const vis: elf.STV = @enumFromInt(@as(u3, @truncate(esym.st_other))); + const vis: elf.STV = @fromBackingInt(@intCast(@as(u3, @truncate(esym.st_other)))); if (vis == .HIDDEN) break :blk false; break :blk true; }; @@ -737,7 +737,7 @@ pub fn markImportsExports(self: *Object, elf_file: *Elf) void { const sym = elf_file.symbol(ref) orelse continue; const file = sym.file(elf_file).?; if (sym.version_index == elf.Versym.LOCAL) continue; - const vis: elf.STV = @enumFromInt(@as(u3, @truncate(sym.elfSym(elf_file).st_other))); + const vis: elf.STV = @fromBackingInt(@intCast(@as(u3, @truncate(sym.elfSym(elf_file).st_other)))); if (vis == .HIDDEN) continue; if (file == .shared_object and !sym.isAbs(elf_file)) { sym.flags.import = true; diff --git a/src/link/Elf/SharedObject.zig b/src/link/Elf/SharedObject.zig index c7070ab0b4b3f8ea0c7de74d54ec591ccf35efb0..052093dce3acdf01c893ec6af73368f55523d234 100644 --- a/src/link/Elf/SharedObject.zig +++ b/src/link/Elf/SharedObject.zig @@ -238,11 +238,11 @@ pub fn parse( const verdef = mem.bytesAsValue(elf.Verdef, verdefs[offset..][0..@sizeOf(elf.Verdef)]); if (verdef.ndx == .UNSPECIFIED) return error.VerDefSymbolTooLarge; - if (verstrings.items.len <= @intFromEnum(verdef.ndx)) - try verstrings.appendNTimes(gpa, 0, @intFromEnum(verdef.ndx) + 1 - verstrings.items.len); + if (verstrings.items.len <= @backingInt(verdef.ndx)) + try verstrings.appendNTimes(gpa, 0, @backingInt(verdef.ndx) + 1 - verstrings.items.len); const aux = mem.bytesAsValue(elf.Verdaux, verdefs[offset + verdef.aux ..][0..@sizeOf(elf.Verdaux)]); - verstrings.items[@intFromEnum(verdef.ndx)] = aux.name; + verstrings.items[@backingInt(verdef.ndx)] = aux.name; if (verdef.next == 0) break; offset += verdef.next; @@ -380,7 +380,7 @@ pub fn markImportExports(self: *SharedObject, elf_file: *Elf) void { const ref = self.resolveSymbol(@intCast(i), elf_file); const ref_sym = elf_file.symbol(ref) orelse continue; const ref_file = ref_sym.file(elf_file).?; - const vis: elf.STV = @enumFromInt(@as(u3, @truncate(ref_sym.elfSym(elf_file).st_other))); + const vis: elf.STV = @fromBackingInt(@intCast(@as(u3, @truncate(ref_sym.elfSym(elf_file).st_other)))); if (ref_file != .shared_object and vis != .HIDDEN) ref_sym.flags.@"export" = true; } } diff --git a/src/link/Elf/Symbol.zig b/src/link/Elf/Symbol.zig index 3ab86943048b816d27557850b32e52caa08b93aa..62a5f0dd8b7d8c3e8d137022bcda026a2b0e2b14 100644 --- a/src/link/Elf/Symbol.zig +++ b/src/link/Elf/Symbol.zig @@ -310,7 +310,7 @@ pub fn setOutputSym(symbol: Symbol, elf_file: *Elf, out: *elf.Elf64_Sym) void { break :blk symbol.address(.{ .plt = false, .trampoline = false }, elf_file); }; const st_other = blk: { - const vis = @as(elf.STV, @enumFromInt(@as(u3, @truncate(esym.st_other)))); + const vis = @as(elf.STV, @fromBackingInt(@intCast(@as(u3, @truncate(esym.st_other))))); if (file_ptr != .shared_object or vis != elf.STV.PROTECTED) break :blk esym.st_other; // Reset protected visibility to default for symbols originating in shared objects break :blk esym.st_other & 0b11111000; @@ -332,7 +332,7 @@ const Format = struct { const symbol = f.symbol; try writer.writeAll(symbol.name(elf_file)); switch (symbol.version_index.VERSION) { - @intFromEnum(elf.VER_NDX.LOCAL), @intFromEnum(elf.VER_NDX.GLOBAL) => {}, + @backingInt(elf.VER_NDX.LOCAL), @backingInt(elf.VER_NDX.GLOBAL) => {}, else => { const file_ptr = symbol.file(elf_file).?; assert(file_ptr == .shared_object); diff --git a/src/link/Elf/ZigObject.zig b/src/link/Elf/ZigObject.zig index 3f4a85ece7a40dbed094b587df82cc0e1293cbd6..9c0d1202776faa558015eec68b86fe3d3bbbe407 100644 --- a/src/link/Elf/ZigObject.zig +++ b/src/link/Elf/ZigObject.zig @@ -458,14 +458,14 @@ pub fn flush(self: *ZigObject, elf_file: *Elf, tid: Zcu.PerThread.Id) !void { }, self); } for (entry.external_relocs.items) |reloc| { - const target_sym = self.symbol(@intFromEnum(reloc.target_sym)); + const target_sym = self.symbol(@backingInt(reloc.target_sym)); const r_offset = entry_off + reloc.source_off; const r_addend: i64 = @intCast(reloc.target_off); const r_type = relocation.dwarf.externalRelocType(target_sym.*, sect_index, dwarf.address_size, cpu_arch); atom_ptr.addRelocAssumeCapacity(.{ .r_offset = r_offset, .r_addend = r_addend, - .r_info = (@as(u64, @intCast(@intFromEnum(reloc.target_sym))) << 32) | r_type, + .r_info = (@as(u64, @intCast(@backingInt(reloc.target_sym))) << 32) | r_type, }, self); } } @@ -614,7 +614,7 @@ pub fn claimUnresolved(self: *ZigObject, elf_file: *Elf) void { const is_import = blk: { if (!elf_file.isEffectivelyDynLib()) break :blk false; - const vis: elf.STV = @enumFromInt(@as(u3, @truncate(esym.st_other))); + const vis: elf.STV = @fromBackingInt(@intCast(@as(u3, @truncate(esym.st_other)))); if (vis == .HIDDEN) break :blk false; break :blk true; }; @@ -691,7 +691,7 @@ pub fn markImportsExports(self: *ZigObject, elf_file: *Elf) void { const sym = elf_file.symbol(ref) orelse continue; const file = sym.file(elf_file).?; if (sym.version_index == elf.Versym.LOCAL) continue; - const vis: elf.STV = @enumFromInt(@as(u3, @truncate(sym.elfSym(elf_file).st_other))); + const vis: elf.STV = @fromBackingInt(@intCast(@as(u3, @truncate(sym.elfSym(elf_file).st_other)))); if (vis == .HIDDEN) continue; if (file == .shared_object and !sym.isAbs(elf_file)) { sym.flags.import = true; @@ -938,7 +938,7 @@ pub fn getNavVAddr( switch (reloc_info.parent) { .none => unreachable, .atom_index => |atom_index| { - const parent_atom = self.symbol(@intFromEnum(atom_index)).atom(elf_file).?; + const parent_atom = self.symbol(@backingInt(atom_index)).atom(elf_file).?; const r_type = relocation.encode(.abs, elf_file.getTarget().cpu.arch); try parent_atom.addReloc(elf_file.base.comp.gpa, .{ .r_offset = reloc_info.offset, @@ -949,7 +949,7 @@ pub fn getNavVAddr( .debug_output => |debug_output| switch (debug_output) { .dwarf => |wip_nav| try wip_nav.infoExternalReloc(.{ .source_off = @intCast(reloc_info.offset), - .target_sym = @enumFromInt(this_sym_index), + .target_sym = @fromBackingInt(@intCast(this_sym_index)), .target_off = reloc_info.addend, }), .none => unreachable, @@ -970,7 +970,7 @@ pub fn getUavVAddr( switch (reloc_info.parent) { .none => unreachable, .atom_index => |atom_index| { - const parent_atom = self.symbol(@intFromEnum(atom_index)).atom(elf_file).?; + const parent_atom = self.symbol(@backingInt(atom_index)).atom(elf_file).?; const r_type = relocation.encode(.abs, elf_file.getTarget().cpu.arch); try parent_atom.addReloc(elf_file.base.comp.gpa, .{ .r_offset = reloc_info.offset, @@ -981,7 +981,7 @@ pub fn getUavVAddr( .debug_output => |debug_output| switch (debug_output) { .dwarf => |wip_nav| try wip_nav.infoExternalReloc(.{ .source_off = @intCast(reloc_info.offset), - .target_sym = @enumFromInt(sym_index), + .target_sym = @fromBackingInt(@intCast(sym_index)), .target_off = reloc_info.addend, }), .none => unreachable, @@ -1009,7 +1009,7 @@ pub fn lowerUav( const sym = self.symbol(metadata.symbol_index); const existing_alignment = sym.atom(elf_file).?.alignment; if (uav_alignment.order(existing_alignment).compare(.lte)) - return @enumFromInt(metadata.symbol_index); + return @fromBackingInt(@intCast(metadata.symbol_index)); } const osec = if (self.data_relro_index) |sym_index| @@ -1027,7 +1027,7 @@ pub fn lowerUav( var name_buf: [32]u8 = undefined; const name = std.fmt.bufPrint(&name_buf, "__anon_{d}", .{ - @intFromEnum(uav), + @backingInt(uav), }) catch unreachable; const sym_index = self.lowerConst( elf_file, @@ -1044,7 +1044,7 @@ pub fn lowerUav( ), }; try self.uavs.put(gpa, uav, .{ - .symbol_index = @intFromEnum(sym_index), + .symbol_index = @backingInt(sym_index), .allocated = true, }); return sym_index; @@ -1541,7 +1541,7 @@ pub fn updateFunc( var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav( pt, func.owner_nav, - @enumFromInt(sym_index), + @fromBackingInt(@intCast(sym_index)), ) else null; defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit(); @@ -1549,7 +1549,7 @@ pub fn updateFunc( &elf_file.base, pt, func_index, - @enumFromInt(sym_index), + @fromBackingInt(@intCast(sym_index)), mir, &aw.writer, if (debug_wip_nav) |*dn| .{ .dwarf = dn } else .none, @@ -1656,7 +1656,7 @@ pub fn updateNav( self.symbol(sym_index).flags.is_tls = true; } if (self.dwarf) |*dwarf| { - var debug_wip_nav = try dwarf.initWipNav(pt, nav_index, @enumFromInt(sym_index)); + var debug_wip_nav = try dwarf.initWipNav(pt, nav_index, @fromBackingInt(@intCast(sym_index))); defer debug_wip_nav.deinit(); dwarf.finishWipNav(pt, nav_index, &debug_wip_nav) catch |err| switch (err) { error.OutOfMemory, error.Canceled, error.AlreadyReported => |e| return e, @@ -1674,7 +1674,7 @@ pub fn updateNav( var aw: std.Io.Writer.Allocating = .init(zcu.gpa); defer aw.deinit(); - var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, nav_index, @enumFromInt(sym_index)) else null; + var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, nav_index, @fromBackingInt(@intCast(sym_index))) else null; defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit(); codegen.generateSymbol( @@ -1682,7 +1682,7 @@ pub fn updateNav( pt, .fromInterned(nav.resolved.?.value), &aw.writer, - .{ .atom_index = @enumFromInt(sym_index) }, + .{ .atom_index = @fromBackingInt(@intCast(sym_index)) }, ) catch |err| switch (err) { error.WriteFailed => return error.OutOfMemory, else => |e| return e, @@ -1751,7 +1751,7 @@ fn updateLazySymbol( &required_alignment, &aw.writer, .none, - .{ .atom_index = @enumFromInt(symbol_index) }, + .{ .atom_index = @fromBackingInt(@intCast(symbol_index)) }, ) catch |err| switch (err) { error.WriteFailed => return error.OutOfMemory, else => |e| return e, @@ -1828,7 +1828,7 @@ fn lowerConst( pt, val, &aw.writer, - .{ .atom_index = @enumFromInt(sym_index) }, + .{ .atom_index = @fromBackingInt(@intCast(sym_index)) }, ) catch |err| switch (err) { error.WriteFailed => return error.OutOfMemory, else => |e| return e, @@ -1850,7 +1850,7 @@ fn lowerConst( try elf_file.pwriteAll(code, atom_ptr.offset(elf_file)); - return @enumFromInt(sym_index); + return @fromBackingInt(@intCast(sym_index)); } pub fn updateExports( diff --git a/src/link/Elf/eh_frame.zig b/src/link/Elf/eh_frame.zig index 0b1c92d09899d38ba2e380e08eadda229de808b8..b4ac44cc9e7338519fc1f1110845a38bbe82e7ae 100644 --- a/src/link/Elf/eh_frame.zig +++ b/src/link/Elf/eh_frame.zig @@ -535,7 +535,7 @@ pub fn writeEhFrameHdr(elf_file: *Elf, writer: anytype) !void { const x86_64 = struct { fn resolveReloc(rec: anytype, elf_file: *Elf, rel: elf.Elf64_Rela, source: i64, target: i64, data: []u8) !void { - const r_type: elf.R_X86_64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_X86_64 = @fromBackingInt(@intCast(rel.r_type())); switch (r_type) { .NONE => {}, .@"32" => std.mem.writeInt(i32, data[0..4], @as(i32, @truncate(target)), .little), @@ -549,7 +549,7 @@ const x86_64 = struct { const aarch64 = struct { fn resolveReloc(rec: anytype, elf_file: *Elf, rel: elf.Elf64_Rela, source: i64, target: i64, data: []u8) !void { - const r_type: elf.R_AARCH64 = @enumFromInt(rel.r_type()); + const r_type: elf.R_AARCH64 = @fromBackingInt(@intCast(rel.r_type())); switch (r_type) { .NONE => {}, .ABS64 => std.mem.writeInt(i64, data[0..8], target, .little), @@ -562,7 +562,7 @@ const aarch64 = struct { const riscv = struct { fn resolveReloc(rec: anytype, elf_file: *Elf, rel: elf.Elf64_Rela, source: i64, target: i64, data: []u8) !void { - const r_type: elf.R_RISCV = @enumFromInt(rel.r_type()); + const r_type: elf.R_RISCV = @fromBackingInt(@intCast(rel.r_type())); switch (r_type) { .NONE => {}, .@"32_PCREL" => std.mem.writeInt(i32, data[0..4], @as(i32, @intCast(target - source)), .little), diff --git a/src/link/Elf/relocation.zig b/src/link/Elf/relocation.zig index 021bfee2090d1b7d0070167cccceb7c42d74a68e..0bac24733e84be0dbb022a33ecc41acf8f32bb27 100644 --- a/src/link/Elf/relocation.zig +++ b/src/link/Elf/relocation.zig @@ -17,14 +17,14 @@ fn Table(comptime len: comptime_int, comptime RelType: type, comptime mapping: [ return struct { fn decode(r_type: u32) Kind { inline for (mapping) |entry| { - if (@intFromEnum(entry[1]) == r_type) return entry[0]; + if (@backingInt(entry[1]) == r_type) return entry[0]; } return .other; } fn encode(comptime kind: Kind) u32 { inline for (mapping) |entry| { - if (entry[0] == kind) return @intFromEnum(entry[1]); + if (entry[0] == kind) return @backingInt(entry[1]); } @panic("encoding .other is ambiguous"); } @@ -94,15 +94,15 @@ pub fn encode(comptime kind: Kind, cpu_arch: std.Target.Cpu.Arch) u32 { pub const dwarf = struct { pub fn crossSectionRelocType(format: DW.Format, cpu_arch: std.Target.Cpu.Arch) u32 { return switch (cpu_arch) { - .x86_64 => @intFromEnum(@as(elf.R_X86_64, switch (format) { + .x86_64 => @backingInt(@as(elf.R_X86_64, switch (format) { .@"32" => .@"32", .@"64" => .@"64", })), - .aarch64, .aarch64_be => @intFromEnum(@as(elf.R_AARCH64, switch (format) { + .aarch64, .aarch64_be => @backingInt(@as(elf.R_AARCH64, switch (format) { .@"32" => .ABS32, .@"64" => .ABS64, })), - .riscv64, .riscv64be => @intFromEnum(@as(elf.R_RISCV, switch (format) { + .riscv64, .riscv64be => @backingInt(@as(elf.R_RISCV, switch (format) { .@"32" => .@"32", .@"64" => .@"64", })), @@ -117,7 +117,7 @@ pub const dwarf = struct { cpu_arch: std.Target.Cpu.Arch, ) u32 { return switch (cpu_arch) { - .x86_64 => @intFromEnum(@as(elf.R_X86_64, switch (source_section) { + .x86_64 => @backingInt(@as(elf.R_X86_64, switch (source_section) { else => switch (address_size) { .@"32" => if (target.flags.is_tls) .DTPOFF32 else .@"32", .@"64" => if (target.flags.is_tls) .DTPOFF64 else .@"64", @@ -125,7 +125,7 @@ pub const dwarf = struct { }, .debug_frame => .PC32, })), - .aarch64, .aarch64_be => @intFromEnum(@as(elf.R_AARCH64, switch (source_section) { + .aarch64, .aarch64_be => @backingInt(@as(elf.R_AARCH64, switch (source_section) { else => switch (address_size) { .@"32" => .ABS32, .@"64" => .ABS64, @@ -133,7 +133,7 @@ pub const dwarf = struct { }, .debug_frame => .PREL32, })), - .riscv64, .riscv64be => @intFromEnum(@as(elf.R_RISCV, switch (source_section) { + .riscv64, .riscv64be => @backingInt(@as(elf.R_RISCV, switch (source_section) { else => switch (address_size) { .@"32" => .@"32", .@"64" => .@"64", @@ -163,9 +163,9 @@ pub fn fmtRelocType(r_type: u32, cpu_arch: std.Target.Cpu.Arch) std.fmt.Alt(Form fn formatRelocType(ctx: FormatRelocTypeCtx, writer: *std.Io.Writer) std.Io.Writer.Error!void { const r_type = ctx.r_type; switch (ctx.cpu_arch) { - .x86_64 => try writer.print("R_X86_64_{s}", .{@tagName(@as(elf.R_X86_64, @enumFromInt(r_type)))}), - .aarch64, .aarch64_be => try writer.print("R_AARCH64_{s}", .{@tagName(@as(elf.R_AARCH64, @enumFromInt(r_type)))}), - .riscv64, .riscv64be => try writer.print("R_RISCV_{s}", .{@tagName(@as(elf.R_RISCV, @enumFromInt(r_type)))}), + .x86_64 => try writer.print("R_X86_64_{s}", .{@tagName(@as(elf.R_X86_64, @fromBackingInt(@intCast(r_type))))}), + .aarch64, .aarch64_be => try writer.print("R_AARCH64_{s}", .{@tagName(@as(elf.R_AARCH64, @fromBackingInt(@intCast(r_type))))}), + .riscv64, .riscv64be => try writer.print("R_RISCV_{s}", .{@tagName(@as(elf.R_RISCV, @fromBackingInt(@intCast(r_type))))}), else => unreachable, } } diff --git a/src/link/Elf2.zig b/src/link/Elf2.zig index 33ae7d8821206be8aa34207bc3563910cd6f6789..a3ef197aba481bfb355d2d913efffbede87c55ae 100644 --- a/src/link/Elf2.zig +++ b/src/link/Elf2.zig @@ -212,26 +212,26 @@ const Node = union(enum) { _, pub fn path(ii: InputIndex, elf: *const Elf) std.Build.Cache.Path { - return elf.inputs.items[@intFromEnum(ii)].path; + return elf.inputs.items[@backingInt(ii)].path; } pub fn member(ii: InputIndex, elf: *const Elf) ?[]const u8 { - return elf.inputs.items[@intFromEnum(ii)].member; + return elf.inputs.items[@backingInt(ii)].member; } pub fn fileSymbol(ii: InputIndex, elf: *const Elf) Symbol.LocalIndex { - return elf.inputs.items[@intFromEnum(ii)].file_symbol; + return elf.inputs.items[@backingInt(ii)].file_symbol; } pub fn localSymbolRange(ii: InputIndex, elf: *Elf) [2]Symbol.LocalIndex { - if (@intFromEnum(ii) + 1 < elf.inputs.items.len) { - const next_ii: InputIndex = @enumFromInt(@intFromEnum(ii) + 1); + if (@backingInt(ii) + 1 < elf.inputs.items.len) { + const next_ii: InputIndex = @fromBackingInt(@intCast(@backingInt(ii) + 1)); return .{ ii.fileSymbol(elf), next_ii.fileSymbol(elf) }; } else { const local_symbols_len = switch (elf.shdrPtr(.symtab)) { inline else => |shdr| elf.targetLoad(&shdr.info), }; - return .{ ii.fileSymbol(elf), @enumFromInt(local_symbols_len) }; + return .{ ii.fileSymbol(elf), @fromBackingInt(@intCast(local_symbols_len)) }; } } }; @@ -240,18 +240,18 @@ const Node = union(enum) { _, pub fn navIndex(nmi: NavMapIndex, elf: *const Elf) InternPool.Nav.Index { - return elf.navs.keys()[@intFromEnum(nmi)]; + return elf.navs.keys()[@backingInt(nmi)]; } pub fn symbol(nmi: NavMapIndex, elf: *const Elf) Symbol.LocalIndex { - return elf.navs.values()[@intFromEnum(nmi)].lsi; + return elf.navs.values()[@backingInt(nmi)].lsi; } fn firstSymbolReloc(nmi: NavMapIndex, elf: *const Elf) SymbolReloc.Index { - return elf.navs.values()[@intFromEnum(nmi)].first_symbol_reloc; + return elf.navs.values()[@backingInt(nmi)].first_symbol_reloc; } fn firstGotReloc(nmi: NavMapIndex, elf: *const Elf) GotReloc.Index { - return elf.navs.values()[@intFromEnum(nmi)].first_got_reloc; + return elf.navs.values()[@backingInt(nmi)].first_got_reloc; } }; @@ -259,15 +259,15 @@ const Node = union(enum) { _, pub fn uavValue(umi: UavMapIndex, elf: *const Elf) InternPool.Index { - return elf.uavs.keys()[@intFromEnum(umi)]; + return elf.uavs.keys()[@backingInt(umi)]; } pub fn symbol(umi: UavMapIndex, elf: *const Elf) Symbol.LocalIndex { - return elf.uavs.values()[@intFromEnum(umi)].lsi; + return elf.uavs.values()[@backingInt(umi)].lsi; } fn firstSymbolReloc(umi: UavMapIndex, elf: *const Elf) SymbolReloc.Index { - return elf.uavs.values()[@intFromEnum(umi)].first_symbol_reloc; + return elf.uavs.values()[@backingInt(umi)].first_symbol_reloc; } fn firstGotReloc(umi: UavMapIndex, elf: *const Elf) GotReloc.Index { _ = umi; @@ -285,7 +285,7 @@ const Node = union(enum) { _, pub fn ref(lmi: @This()) LazyMapRef { - return .{ .kind = kind, .index = @intFromEnum(lmi) }; + return .{ .kind = kind, .index = @backingInt(lmi) }; } pub fn lazySymbol(lmi: @This(), elf: *const Elf) link.File.LazySymbol { @@ -297,10 +297,10 @@ const Node = union(enum) { } fn firstSymbolReloc(lmi: @This(), elf: *const Elf) SymbolReloc.Index { - return elf.lazy.getPtrConst(kind).map.values()[@intFromEnum(lmi)].first_symbol_reloc; + return elf.lazy.getPtrConst(kind).map.values()[@backingInt(lmi)].first_symbol_reloc; } fn firstGotReloc(lmi: @This(), elf: *const Elf) GotReloc.Index { - return elf.lazy.getPtrConst(kind).map.values()[@intFromEnum(lmi)].first_got_reloc; + return elf.lazy.getPtrConst(kind).map.values()[@backingInt(lmi)].first_got_reloc; } }; } @@ -316,13 +316,13 @@ const Node = union(enum) { pub const Known = struct { comptime file: MappedFile.Node.Index = .root, - comptime ehdr: MappedFile.Node.Index = @enumFromInt(1), - comptime shdr: MappedFile.Node.Index = @enumFromInt(2), - comptime rodata: MappedFile.Node.Index = @enumFromInt(3), - comptime phdr: MappedFile.Node.Index = @enumFromInt(4), - comptime text: MappedFile.Node.Index = @enumFromInt(5), - comptime data: MappedFile.Node.Index = @enumFromInt(6), - comptime data_rel_ro: MappedFile.Node.Index = @enumFromInt(7), + comptime ehdr: MappedFile.Node.Index = @fromBackingInt(@intCast(1)), + comptime shdr: MappedFile.Node.Index = @fromBackingInt(@intCast(2)), + comptime rodata: MappedFile.Node.Index = @fromBackingInt(@intCast(3)), + comptime phdr: MappedFile.Node.Index = @fromBackingInt(@intCast(4)), + comptime text: MappedFile.Node.Index = @fromBackingInt(@intCast(5)), + comptime data: MappedFile.Node.Index = @fromBackingInt(@intCast(6)), + comptime data_rel_ro: MappedFile.Node.Index = @fromBackingInt(@intCast(7)), tls: MappedFile.Node.Index, }; @@ -333,11 +333,11 @@ const Node = union(enum) { /// In this linker implementation, `link.File.AtomId` is a type-erased `MappedFile.Node.Index`. fn toAtom(ni: MappedFile.Node.Index) link.File.AtomId { - return @enumFromInt(@intFromEnum(ni)); + return @fromBackingInt(@intCast(@backingInt(ni))); } /// In this linker implementation, `link.File.AtomId` is a type-erased `MappedFile.Node.Index`. fn fromAtom(atom: link.File.AtomId) MappedFile.Node.Index { - return @enumFromInt(@intFromEnum(atom)); + return @fromBackingInt(@intCast(@backingInt(atom))); } }; @@ -356,11 +356,11 @@ const InputSection = struct { _, fn ptr(isi: InputSection.Index, elf: *Elf) *InputSection { - return &elf.input_sections.items[@intFromEnum(isi)]; + return &elf.input_sections.items[@backingInt(isi)]; } fn ptrConst(isi: InputSection.Index, elf: *const Elf) *const InputSection { - return &elf.input_sections.items[@intFromEnum(isi)]; + return &elf.input_sections.items[@backingInt(isi)]; } fn input(isi: InputSection.Index, elf: *const Elf) Node.InputIndex { @@ -424,13 +424,13 @@ const Section = struct { fn unwrap(opt: RelaIndex.Optional) ?RelaIndex { return switch (opt) { .none => null, - _ => @enumFromInt(@intFromEnum(opt)), + _ => @fromBackingInt(@intCast(@backingInt(opt))), }; } }; fn toOptional(i: RelaIndex) RelaIndex.Optional { - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } }; @@ -455,7 +455,7 @@ const Section = struct { pub const LORESERVE: Index = .fromSection(std.elf.SHN_LORESERVE); pub const HIRESERVE: Index = .fromSection(std.elf.SHN_HIRESERVE); comptime { - assert(@intFromEnum(HIRESERVE) == std.math.maxInt(Tag)); + assert(@backingInt(HIRESERVE) == std.math.maxInt(Tag)); } fn reserve(sec: std.elf.Section) Tag { @@ -465,12 +465,12 @@ const Section = struct { pub fn fromSection(sec: std.elf.Section) Index { return switch (sec) { - std.elf.SHN_UNDEF...std.elf.SHN_LORESERVE - 1 => @enumFromInt(sec), - std.elf.SHN_LORESERVE...std.elf.SHN_HIRESERVE => @enumFromInt(reserve(sec)), + std.elf.SHN_UNDEF...std.elf.SHN_LORESERVE - 1 => @fromBackingInt(@intCast(sec)), + std.elf.SHN_LORESERVE...std.elf.SHN_HIRESERVE => @fromBackingInt(@intCast(reserve(sec))), }; } pub fn toSection(s: Index) ?std.elf.Section { - return switch (@intFromEnum(s)) { + return switch (@backingInt(s)) { std.elf.SHN_UNDEF...std.elf.SHN_LORESERVE - 1 => |sec| @intCast(sec), std.elf.SHN_LORESERVE...reserve(std.elf.SHN_LORESERVE) - 1 => null, reserve(std.elf.SHN_LORESERVE)...reserve(std.elf.SHN_HIRESERVE) => |sec| @intCast( @@ -480,12 +480,12 @@ const Section = struct { } fn get(s: Index, elf: *Elf) *Section { - return &elf.shdrs.items[@intFromEnum(s)]; + return &elf.shdrs.items[@backingInt(s)]; } fn name(s: Index, elf: *Elf) String(.shstrtab) { return switch (elf.shdrPtr(s)) { - inline else => |shdr| @enumFromInt(elf.targetLoad(&shdr.name)), + inline else => |shdr| @fromBackingInt(@intCast(elf.targetLoad(&shdr.name))), }; } @@ -510,7 +510,7 @@ const Section = struct { fn rename(shndx: Index, elf: *Elf, new_name: []const u8) Error!void { const shstrtab_entry = try elf.string(.shstrtab, new_name); switch (elf.shdrPtr(shndx)) { - inline else => |shdr| elf.targetStore(&shdr.name, @intFromEnum(shstrtab_entry)), + inline else => |shdr| elf.targetStore(&shdr.name, @backingInt(shstrtab_entry)), } } @@ -530,7 +530,7 @@ const Section = struct { const relas: []const class.ElfN().Rela = @ptrCast(@alignCast( node.slice(&elf.mf)[0..@intCast(cur_size)], )); - const free_len = elf.targetLoad(&relas[@intFromEnum(free_head)].addend); + const free_len = elf.targetLoad(&relas[@backingInt(free_head)].addend); assert(free_len > 0); break :free_len @intCast(free_len); }; @@ -555,17 +555,17 @@ const Section = struct { const opt_free_head = rela_shndx.get(elf).rela.free_head; const old_free_len: u32 = free_len: { const free_head = opt_free_head.unwrap() orelse break :free_len 0; - const free_len = elf.targetLoad(&relas[@intFromEnum(free_head)].addend); + const free_len = elf.targetLoad(&relas[@backingInt(free_head)].addend); assert(free_len > 0); break :free_len @intCast(free_len); }; const none_reloc_type = MachineRelocType.none(elf).unwrap(elf); { - const old_type = elf.targetLoad(&relas[@intFromEnum(index)].info).type; + const old_type = elf.targetLoad(&relas[@backingInt(index)].info).type; assert(old_type != none_reloc_type); // bug: `index` is already in the free-list } - relas[@intFromEnum(index)] = .{ - .offset = @intFromEnum(opt_free_head), // next + relas[@backingInt(index)] = .{ + .offset = @backingInt(opt_free_head), // next .info = .{ .type = @intCast(none_reloc_type), .sym = 0, @@ -573,7 +573,7 @@ const Section = struct { .addend = @intCast(old_free_len + 1), // list length }; if (elf.targetEndian() != native_endian) { - std.mem.byteSwapAllFields(class.ElfN().Rela, &relas[@intFromEnum(index)]); + std.mem.byteSwapAllFields(class.ElfN().Rela, &relas[@backingInt(index)]); } }, } @@ -600,16 +600,16 @@ const Section = struct { const relas: []class.ElfN().Rela = @ptrCast(@alignCast( rela_shndx.get(elf).ni.slice(&elf.mf)[0..@intCast(elf.targetLoad(&shdr.size))], )); - const next: RelaIndex.Optional = @enumFromInt(elf.targetLoad( - &relas[@intFromEnum(free_head)].offset, - )); + const next: RelaIndex.Optional = @fromBackingInt(@intCast(elf.targetLoad( + &relas[@backingInt(free_head)].offset, + ))); rela_shndx.get(elf).rela.free_head = next; const old_free_len: u32 = @intCast( - elf.targetLoad(&relas[@intFromEnum(free_head)].addend), + elf.targetLoad(&relas[@backingInt(free_head)].addend), ); const new_free_len: u32 = if (next.unwrap()) |i| @intCast( - elf.targetLoad(&relas[@intFromEnum(i)].addend), + elf.targetLoad(&relas[@backingInt(i)].addend), ) else 0; assert(new_free_len == old_free_len - 1); @@ -623,12 +623,12 @@ const Section = struct { } else if (rela_shndx == elf.shndx.rela_plt) { elf.updateDynamicEntry(std.elf.DT_PLTRELSZ, new_size); } - break :new_index @enumFromInt(@divExact(old_size, ent_size)); + break :new_index @fromBackingInt(@intCast(@divExact(old_size, ent_size))); }; const relas: []class.ElfN().Rela = @ptrCast(@alignCast( rela_shndx.get(elf).ni.slice(&elf.mf)[0..@intCast(elf.targetLoad(&shdr.size))], )); - relas[@intFromEnum(new_index)] = .{ + relas[@backingInt(new_index)] = .{ .offset = @intCast(opts.offset), .info = .{ .type = @intCast(opts.type.unwrap(elf)), @@ -637,7 +637,7 @@ const Section = struct { .addend = @intCast(opts.addend), }; if (elf.targetEndian() != native_endian) { - std.mem.byteSwapAllFields(class.ElfN().Rela, &relas[@intFromEnum(new_index)]); + std.mem.byteSwapAllFields(class.ElfN().Rela, &relas[@backingInt(new_index)]); } return new_index; }, @@ -656,12 +656,12 @@ const Section = struct { const relas: []class.ElfN().Rela = @ptrCast(@alignCast( rela_shndx.get(elf).ni.slice(&elf.mf)[0..@intCast(elf.targetLoad(&shdr.size))], )); - const rela_info = elf.targetLoad(&relas[@intFromEnum(index)].info); + const rela_info = elf.targetLoad(&relas[@backingInt(index)].info); { const none_reloc_type = MachineRelocType.none(elf).unwrap(elf); assert(rela_info.type != none_reloc_type); // bug: `index` is in the free-list } - elf.targetStore(&relas[@intFromEnum(index)].info, .{ + elf.targetStore(&relas[@backingInt(index)].info, .{ .type = rela_info.type, .sym = @intCast(raw_sym_index), }); @@ -681,11 +681,11 @@ const Section = struct { rela_shndx.get(elf).ni.slice(&elf.mf)[0..@intCast(elf.targetLoad(&shdr.size))], )); { - const rela_info = elf.targetLoad(&relas[@intFromEnum(index)].info); + const rela_info = elf.targetLoad(&relas[@backingInt(index)].info); const none_reloc_type = MachineRelocType.none(elf).unwrap(elf); assert(rela_info.type != none_reloc_type); // bug: `index` is in the free-list } - elf.targetStore(&relas[@intFromEnum(index)].offset, @intCast(new_offset)); + elf.targetStore(&relas[@backingInt(index)].offset, @intCast(new_offset)); }, } } @@ -702,12 +702,12 @@ const Section = struct { rela_shndx.get(elf).ni.slice(&elf.mf)[0..@intCast(elf.targetLoad(&shdr.size))], )); { - const rela_info = elf.targetLoad(&relas[@intFromEnum(index)].info); + const rela_info = elf.targetLoad(&relas[@backingInt(index)].info); const none_reloc_type = MachineRelocType.none(elf).unwrap(elf); assert(rela_info.type != none_reloc_type); // bug: `index` is in the free-list } - const old_offset = elf.targetLoad(&relas[@intFromEnum(index)].offset); - elf.targetStore(&relas[@intFromEnum(index)].offset, @intCast( + const old_offset = elf.targetLoad(&relas[@backingInt(index)].offset); + elf.targetStore(&relas[@backingInt(index)].offset, @intCast( old_offset - old_base + new_base, )); }, @@ -726,12 +726,12 @@ const Section = struct { rela_shndx.get(elf).ni.slice(&elf.mf)[0..@intCast(elf.targetLoad(&shdr.size))], )); { - const rela_info = elf.targetLoad(&relas[@intFromEnum(index)].info); + const rela_info = elf.targetLoad(&relas[@backingInt(index)].info); const none_reloc_type = MachineRelocType.none(elf).unwrap(elf); assert(rela_info.type != none_reloc_type); // bug: `index` is in the free-list } const unsigned: class.ElfN().Addr = @intCast(new_addend); - elf.targetStore(&relas[@intFromEnum(index)].addend, @bitCast(unsigned)); + elf.targetStore(&relas[@backingInt(index)].addend, @bitCast(unsigned)); }, } } @@ -896,7 +896,7 @@ const GotReloc = struct { _, fn get(index: GotReloc.Index, elf: *Elf) *GotReloc { - return &elf.got_relocs.items[@intFromEnum(index)]; + return &elf.got_relocs.items[@backingInt(index)]; } }; @@ -1131,22 +1131,22 @@ pub const MachineRelocType = union { pub fn wrap(int: u32, elf: *const Elf) MachineRelocType { return switch (elf.ehdrMachine()) { - .AARCH64 => .{ .AARCH64 = @enumFromInt(int) }, - .LOONGARCH => .{ .LARCH = @enumFromInt(int) }, - .PPC64 => .{ .PPC64 = @enumFromInt(int) }, - .RISCV => .{ .RISCV = @enumFromInt(int) }, - .SPARCV9 => .{ .SPARC = @enumFromInt(int) }, - .X86_64 => .{ .X86_64 = @enumFromInt(int) }, + .AARCH64 => .{ .AARCH64 = @fromBackingInt(@intCast(int)) }, + .LOONGARCH => .{ .LARCH = @fromBackingInt(@intCast(int)) }, + .PPC64 => .{ .PPC64 = @fromBackingInt(@intCast(int)) }, + .RISCV => .{ .RISCV = @fromBackingInt(@intCast(int)) }, + .SPARCV9 => .{ .SPARC = @fromBackingInt(@intCast(int)) }, + .X86_64 => .{ .X86_64 = @fromBackingInt(@intCast(int)) }, }; } pub fn unwrap(rt: MachineRelocType, elf: *const Elf) u32 { return switch (elf.ehdrMachine()) { - .AARCH64 => @intFromEnum(rt.AARCH64), - .LOONGARCH => @intFromEnum(rt.LARCH), - .PPC64 => @intFromEnum(rt.PPC64), - .RISCV => @intFromEnum(rt.RISCV), - .SPARCV9 => @intFromEnum(rt.SPARC), - .X86_64 => @intFromEnum(rt.X86_64), + .AARCH64 => @backingInt(rt.AARCH64), + .LOONGARCH => @backingInt(rt.LARCH), + .PPC64 => @backingInt(rt.PPC64), + .RISCV => @backingInt(rt.RISCV), + .SPARCV9 => @backingInt(rt.SPARC), + .X86_64 => @backingInt(rt.X86_64), }; } }; @@ -1209,7 +1209,7 @@ const SymbolReloc = struct { _, fn get(index: SymbolReloc.Index, elf: *Elf) *SymbolReloc { - return &elf.symbol_relocs.items[@intFromEnum(index)]; + return &elf.symbol_relocs.items[@backingInt(index)]; } }; @@ -1875,17 +1875,17 @@ fn addLocalSymbolAssumeCapacity(elf: *Elf, opts: AddLocalSymbolOptions) Symbol.L // `shdr.info` stores the index of the first global symbol. We will replace it with our // new local symbol, and move the global symbol to a new index at the end of the symtab. - const target_index: Symbol.Index = @enumFromInt(elf.targetLoad(&shdr.info)); + const target_index: Symbol.Index = @fromBackingInt(@intCast(elf.targetLoad(&shdr.info))); const old_size = elf.targetLoad(&shdr.size); const new_size = old_size + ent_size; assert(elf.symtab.items.len == @divExact(old_size, ent_size)); - elf.targetStore(&shdr.info, @intFromEnum(target_index) + 1); + elf.targetStore(&shdr.info, @backingInt(target_index) + 1); elf.targetStore(&shdr.size, new_size); - const new_index: Symbol.Index = @enumFromInt(elf.symtab.items.len); + const new_index: Symbol.Index = @fromBackingInt(@intCast(elf.symtab.items.len)); elf.symtab.appendAssumeCapacity(undefined); const target_sym = @field(elf.symPtr(target_index), @tagName(class)); @@ -1897,7 +1897,7 @@ fn addLocalSymbolAssumeCapacity(elf: *Elf, opts: AddLocalSymbolOptions) Symbol.L // ...then the `elf.symtab` metadata... new_index.ptr(elf).* = target_index.ptr(elf).*; // ...then update the `elf.globals` tracking. - const global_name: String(.strtab) = @enumFromInt(elf.targetLoad(&new_sym.name)); + const global_name: String(.strtab) = @fromBackingInt(@intCast(elf.targetLoad(&new_sym.name))); elf.globalByName(global_name).?.symtab_index = new_index; if (elf.ehdrType() == .REL and target_index.ptr(elf).first_target_reloc != .none) { @@ -1912,7 +1912,7 @@ fn addLocalSymbolAssumeCapacity(elf: *Elf, opts: AddLocalSymbolOptions) Symbol.L }; target_sym.* = .{ - .name = @intFromEnum(opts.name), + .name = @backingInt(opts.name), .value = @intCast(opts.value), .size = @intCast(opts.size), .info = .{ .type = opts.type, .bind = .LOCAL }, @@ -1923,7 +1923,7 @@ fn addLocalSymbolAssumeCapacity(elf: *Elf, opts: AddLocalSymbolOptions) Symbol.L std.mem.byteSwapAllFields(class.ElfN().Sym, target_sym); } - return @enumFromInt(@intFromEnum(target_index)); + return @fromBackingInt(@intCast(@backingInt(target_index))); }, } } @@ -2082,7 +2082,7 @@ fn addGlobalSymbolAssumeCapacity(elf: *Elf, opts: AddGlobalSymbolOptions) error{ else => |t| t, }; - const sym_index: Symbol.Index = @enumFromInt(elf.symtab.items.len); + const sym_index: Symbol.Index = @fromBackingInt(@intCast(elf.symtab.items.len)); elf.symtab.appendAssumeCapacity(.{ .node = opts.node, .first_target_reloc = .none, @@ -2092,12 +2092,12 @@ fn addGlobalSymbolAssumeCapacity(elf: *Elf, opts: AddGlobalSymbolOptions) error{ const Sym = class.ElfN().Sym; // Increase the symtab size... const old_size = elf.targetLoad(&shdr.size); - assert(old_size == @intFromEnum(sym_index) * @sizeOf(Sym)); + assert(old_size == @backingInt(sym_index) * @sizeOf(Sym)); elf.targetStore(&shdr.size, old_size + @sizeOf(Sym)); // ...then populate the newly-valid symbol pointer const sym = @field(elf.symPtr(sym_index), @tagName(class)); sym.* = .{ - .name = @intFromEnum(opts.name.strtab), + .name = @backingInt(opts.name.strtab), .value = @intCast(opts.value), .size = @intCast(opts.size), .info = .{ .type = @"type", .bind = bind }, @@ -2133,7 +2133,7 @@ fn addGlobalSymbolAssumeCapacity(elf: *Elf, opts: AddGlobalSymbolOptions) error{ // ...then populate the newly-valid symbol pointer const sym = @field(elf.dynsymPtr(dynsym_index), @tagName(class)); sym.* = .{ - .name = @intFromEnum(opts.name.dynstr), + .name = @backingInt(opts.name.dynstr), .value = @intCast(opts.value), .size = @intCast(opts.size), .info = .{ .type = @"type", .bind = bind }, @@ -2285,7 +2285,7 @@ fn setGlobalSymbolValue( if (!elf.pltEntryIsDead(plt_index) and elf.classifySymbolValue(.global(global_name)) != .dynamic) { - elf.shndx.rela_plt.relaDeleteOne(elf, @enumFromInt(plt_index)); + elf.shndx.rela_plt.relaDeleteOne(elf, @fromBackingInt(@intCast(plt_index))); assert(elf.pltEntryIsDead(plt_index)); } } @@ -2371,14 +2371,14 @@ fn moveDemotedGlobal(elf: *Elf, global_ptr: *Symbol.Global) void { inline else => |shdr, class| { // `shdr.info` stores the index of the first global symbol. We are going to swap the // demoted symbol with that first global symbol, then increment that start index. - const dest_index: Symbol.Index = @enumFromInt(elf.targetLoad(&shdr.info)); + const dest_index: Symbol.Index = @fromBackingInt(@intCast(elf.targetLoad(&shdr.info))); const src_index = global_ptr.symtab_index; // This global should currently be in the "global symbols" part of the symtab, since our // job is to move it *out* of that part: - assert(@intFromEnum(src_index) >= @intFromEnum(dest_index)); + assert(@backingInt(src_index) >= @backingInt(dest_index)); - elf.targetStore(&shdr.info, @intFromEnum(dest_index) + 1); + elf.targetStore(&shdr.info, @backingInt(dest_index) + 1); if (src_index != dest_index) { // The demoted global was not the first global in the symtab, so we need to swap it @@ -2387,10 +2387,10 @@ fn moveDemotedGlobal(elf: *Elf, global_ptr: *Symbol.Global) void { const src_sym_ptr = @field(elf.symPtr(src_index), @tagName(class)); const dest_sym_ptr = @field(elf.symPtr(dest_index), @tagName(class)); - const this_name: String(.strtab) = @enumFromInt(elf.targetLoad(&src_sym_ptr.name)); + const this_name: String(.strtab) = @fromBackingInt(@intCast(elf.targetLoad(&src_sym_ptr.name))); assert(elf.globalByName(this_name).? == global_ptr); - const other_name: String(.strtab) = @enumFromInt(elf.targetLoad(&dest_sym_ptr.name)); + const other_name: String(.strtab) = @fromBackingInt(@intCast(elf.targetLoad(&dest_sym_ptr.name))); const other_global_ptr = elf.globalByName(other_name).?; assert(other_global_ptr.symtab_index == dest_index); @@ -2426,7 +2426,7 @@ fn moveDemotedGlobal(elf: *Elf, global_ptr: *Symbol.Global) void { const src_dynsym_ptr = @field(elf.dynsymPtr(remove_dynsym_index), @tagName(class)); const dest_dynsym_ptr = @field(elf.dynsymPtr(free_dynsym_index), @tagName(class)); - const moved_name_dynstr: String(.dynstr) = @enumFromInt(elf.targetLoad(&src_dynsym_ptr.name)); + const moved_name_dynstr: String(.dynstr) = @fromBackingInt(@intCast(elf.targetLoad(&src_dynsym_ptr.name))); const moved_name = elf.stringExisting(.strtab, moved_name_dynstr.slice(elf)); const moved_global_ptr = elf.globalByName(moved_name).?; @@ -2486,7 +2486,7 @@ const Symbol = struct { _, fn ptr(si: Symbol.Index, elf: *Elf) *Symbol { - return &elf.symtab.items[@intFromEnum(si)]; + return &elf.symtab.items[@backingInt(si)]; } }; @@ -2505,7 +2505,7 @@ const Symbol = struct { _, fn index(li: LocalIndex) Index { - return @enumFromInt(@intFromEnum(li)); + return @fromBackingInt(@intCast(@backingInt(li))); } }; @@ -2517,26 +2517,26 @@ const Symbol = struct { const @"null": Symbol.Id = .local(.null); fn local(lsi: Symbol.LocalIndex) Symbol.Id { - return .{ .kind = .local, .raw = @intCast(@intFromEnum(lsi)) }; + return .{ .kind = .local, .raw = @intCast(@backingInt(lsi)) }; } fn global(name: String(.strtab)) Symbol.Id { - return .{ .kind = .global, .raw = @intCast(@intFromEnum(name)) }; + return .{ .kind = .global, .raw = @intCast(@backingInt(name)) }; } fn unwrap(s: Symbol.Id) union(enum) { local: Symbol.LocalIndex, global: String(.strtab), } { return switch (s.kind) { - .local => .{ .local = @enumFromInt(s.raw) }, - .global => .{ .global = @enumFromInt(s.raw) }, + .local => .{ .local = @fromBackingInt(@intCast(s.raw)) }, + .global => .{ .global = @fromBackingInt(@intCast(s.raw)) }, }; } fn toTypeErased(s: Symbol.Id) link.File.SymbolId { - return @enumFromInt(@as(u32, @bitCast(s))); + return @fromBackingInt(@intCast(@as(u32, @bitCast(s)))); } fn fromTypeErased(s: link.File.SymbolId) Symbol.Id { - return @bitCast(@intFromEnum(s)); + return @bitCast(@backingInt(s)); } fn index(s: Symbol.Id, elf: *const Elf) Symbol.Index { @@ -2814,7 +2814,7 @@ fn lazySymbolInner(elf: *Elf, lazy: link.File.LazySymbol) Error!link.File.Symbol const name = std.fmt.bufPrint( &name_buf, "__lazy_{t}_{d}", - .{ lazy.kind, @intFromEnum(lazy.ty) }, + .{ lazy.kind, @backingInt(lazy.ty) }, ) catch unreachable; gop.value_ptr.* = .{ .lsi = elf.addLocalSymbolAssumeCapacity(.{ @@ -2829,8 +2829,8 @@ fn lazySymbolInner(elf: *Elf, lazy: link.File.LazySymbol) Error!link.File.Symbol .first_got_reloc = .none, }; elf.nodes.appendAssumeCapacity(switch (lazy.kind) { - .code => .{ .lazy_code = @enumFromInt(gop.index) }, - .const_data => .{ .lazy_const_data = @enumFromInt(gop.index) }, + .code => .{ .lazy_code = @fromBackingInt(@intCast(gop.index)) }, + .const_data => .{ .lazy_const_data = @fromBackingInt(@intCast(gop.index)) }, }); elf.synth_prog_node.increaseEstimatedTotalItems(1); } @@ -2994,19 +2994,19 @@ fn String(section: StringSection) type { fn slice(str: @This(), elf: *Elf) [:0]const u8 { const section_node = section.shndx(elf).get(elf).ni; - const overlong = section_node.sliceConst(&elf.mf)[@intFromEnum(str)..]; + const overlong = section_node.sliceConst(&elf.mf)[@backingInt(str)..]; return overlong[0..std.mem.findScalar(u8, overlong, 0).? :0]; } }; } fn string(elf: *Elf, comptime section: StringSection, key: []const u8) Error!String(section) { const st: *StringTable = &@field(elf, @tagName(section)); - return @enumFromInt(try st.get(elf, section.shndx(elf), key)); + return @fromBackingInt(@intCast(try st.get(elf, section.shndx(elf), key))); } /// Like `string`, but asserts that the string is already in `section`. fn stringExisting(elf: *Elf, comptime section: StringSection, key: []const u8) String(section) { const st: *StringTable = &@field(elf, @tagName(section)); - return @enumFromInt(st.getExisting(elf, section.shndx(elf), key)); + return @fromBackingInt(@intCast(st.getExisting(elf, section.shndx(elf), key))); } const StringTable = struct { @@ -3688,7 +3688,7 @@ fn initHeaders( const sh_undef: *ElfN.Shdr = @ptrCast(@alignCast(elf.ni.shdr.slice(&elf.mf))); sh_undef.* = .{ - .name = @intFromEnum(String(.shstrtab).empty), + .name = @backingInt(String(.shstrtab).empty), .type = .NULL, .flags = .{ .shf = .{} }, .addr = 0, @@ -3716,7 +3716,7 @@ fn initHeaders( })); const symtab_null = @field(elf.symPtr(.null), @tagName(ct_class)); symtab_null.* = .{ - .name = @intFromEnum(String(.strtab).empty), + .name = @backingInt(String(.strtab).empty), .value = 0, .size = 0, .info = .{ .type = .NOTYPE, .bind = .LOCAL }, @@ -3749,7 +3749,7 @@ fn initHeaders( })); Section.Index.get(.strtab, elf).ni.slice(&elf.mf)[0] = 0; switch (elf.shdrPtr(.symtab)) { - inline else => |shdr| elf.targetStore(&shdr.link, @intFromEnum(Section.Index.strtab)), + inline else => |shdr| elf.targetStore(&shdr.link, @backingInt(Section.Index.strtab)), } assert(.rodata == try elf.addSection(elf.ni.rodata, .{ @@ -3872,7 +3872,7 @@ fn initHeaders( }); const dynsym_null = @field(elf.dynsymPtr(0), @tagName(ct_class)); dynsym_null.* = .{ - .name = @intFromEnum(String(.dynstr).empty), + .name = @backingInt(String(.dynstr).empty), .value = 0, .size = 0, .info = .{ .type = .NOTYPE, .bind = .LOCAL }, @@ -3926,7 +3926,7 @@ fn initHeaders( 0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp *0x0(%rip) 0x0f, 0x1f, 0x40, 0x00, // nopl 0x0(%rax) }); - elf.plt_first_symbol_reloc = @enumFromInt(elf.symbol_relocs.items.len); + elf.plt_first_symbol_reloc = @fromBackingInt(@intCast(elf.symbol_relocs.items.len)); try elf.ensureUnusedRelocCapacity(plt_ni, 2); try elf.addSymbolRelocAssumeCapacity( plt_ni, @@ -3969,7 +3969,7 @@ fn initHeaders( 0x4c, 0x00, 0x01, 0xe0, // jr $t3 }, }); - elf.plt_first_symbol_reloc = @enumFromInt(elf.symbol_relocs.items.len); + elf.plt_first_symbol_reloc = @fromBackingInt(@intCast(elf.symbol_relocs.items.len)); try elf.ensureUnusedRelocCapacity(plt_ni, 3); elf.addRelocAssumeCapacity(plt_ni, 0, got_plt_sym, 0, .{ .LARCH = .PCALA_HI20 }) catch |err| switch (err) { error.UnknownRelocation => unreachable, @@ -4184,7 +4184,7 @@ fn initHeaders( assert(elf.shdrs.items.len == shnum); for (0..shnum) |shndx_raw| { - const shndx: Section.Index = @enumFromInt(shndx_raw); + const shndx: Section.Index = @fromBackingInt(@intCast(shndx_raw)); elf.section_by_name.putAssumeCapacityNoClobber(shndx.name(elf), {}); } @@ -4239,7 +4239,7 @@ pub fn endProgress(elf: *Elf) void { } fn getNode(elf: *const Elf, ni: MappedFile.Node.Index) Node { - return elf.nodes.get(@intFromEnum(ni)); + return elf.nodes.get(@backingInt(ni)); } /// Asserts that `ni` is a section, input section, copied global, NAV, UAV, or lazy code/data. fn getNodeShndx(elf: *const Elf, ni: MappedFile.Node.Index) Section.Index { @@ -4290,15 +4290,15 @@ fn resetNodeRelocs(elf: *Elf, ni: MappedFile.Node.Index) void { .section => unreachable, // cannot contain relocs (.plt and .dynamic unsupported) .copied_global => unreachable, // cannot contain relocs .input_section => |isi| .{ - &elf.input_sections.items[@intFromEnum(isi)].first_symbol_reloc, - &elf.input_sections.items[@intFromEnum(isi)].first_got_reloc, + &elf.input_sections.items[@backingInt(isi)].first_symbol_reloc, + &elf.input_sections.items[@backingInt(isi)].first_got_reloc, }, .nav => |nmi| .{ - &elf.navs.values()[@intFromEnum(nmi)].first_symbol_reloc, - &elf.navs.values()[@intFromEnum(nmi)].first_got_reloc, + &elf.navs.values()[@backingInt(nmi)].first_symbol_reloc, + &elf.navs.values()[@backingInt(nmi)].first_got_reloc, }, .uav => |umi| .{ - &elf.uavs.values()[@intFromEnum(umi)].first_symbol_reloc, + &elf.uavs.values()[@backingInt(umi)].first_symbol_reloc, null, }, inline .lazy_code, .lazy_const_data => |lmi| .{ @@ -4309,23 +4309,23 @@ fn resetNodeRelocs(elf: *Elf, ni: MappedFile.Node.Index) void { if (symbol_relocs.* != .none) { for ( - elf.symbol_relocs.items[@intFromEnum(symbol_relocs.*)..], - @intFromEnum(symbol_relocs.*).., + elf.symbol_relocs.items[@backingInt(symbol_relocs.*)..], + @backingInt(symbol_relocs.*).., ) |*reloc, index| { if (reloc.node != ni) break; - reloc.delete(elf, @enumFromInt(index)); + reloc.delete(elf, @fromBackingInt(@intCast(index))); } } - symbol_relocs.* = @enumFromInt(elf.symbol_relocs.items.len); + symbol_relocs.* = @fromBackingInt(@intCast(elf.symbol_relocs.items.len)); if (got_relocs) |ptr| { if (ptr.* != .none) { - for (elf.got_relocs.items[@intFromEnum(ptr.*)..]) |*reloc| { + for (elf.got_relocs.items[@backingInt(ptr.*)..]) |*reloc| { if (reloc.node != ni) break; reloc.delete(elf); } } - ptr.* = @enumFromInt(elf.got_relocs.items.len); + ptr.* = @fromBackingInt(@intCast(elf.got_relocs.items.len)); } } @@ -4339,7 +4339,7 @@ fn flushMovedNodeRelocs( first_got_reloc: GotReloc.Index, ) void { if (first_symbol_reloc != .none) { - for (elf.symbol_relocs.items[@intFromEnum(first_symbol_reloc)..]) |*reloc| { + for (elf.symbol_relocs.items[@backingInt(first_symbol_reloc)..]) |*reloc| { if (reloc.node != node) break; if (reloc.rela_index.unwrap()) |rela_index| { // The node has moved, so the offset of the relocation within the section might have @@ -4351,7 +4351,7 @@ fn flushMovedNodeRelocs( } if (first_got_reloc != .none) { - for (elf.got_relocs.items[@intFromEnum(first_got_reloc)..]) |*reloc| { + for (elf.got_relocs.items[@backingInt(first_got_reloc)..]) |*reloc| { if (reloc.node != node) break; reloc.apply(elf); } @@ -4359,33 +4359,33 @@ fn flushMovedNodeRelocs( } fn identClass(elf: *const Elf) std.elf.CLASS { - return @enumFromInt(elf.mf.memory_map.memory[std.elf.EI.CLASS]); + return @fromBackingInt(@intCast(elf.mf.memory_map.memory[std.elf.EI.CLASS])); } /// Like `std.elf.ET`, but only includes the ELF machine architectures we support, so that we can /// use exhaustive `switch` statements in the linker implementation. const EhdrMachine = enum(u16) { - AARCH64 = @intFromEnum(std.elf.EM.AARCH64), - LOONGARCH = @intFromEnum(std.elf.EM.LOONGARCH), - PPC64 = @intFromEnum(std.elf.EM.PPC64), - RISCV = @intFromEnum(std.elf.EM.RISCV), - SPARCV9 = @intFromEnum(std.elf.EM.SPARCV9), - X86_64 = @intFromEnum(std.elf.EM.X86_64), + AARCH64 = @backingInt(std.elf.EM.AARCH64), + LOONGARCH = @backingInt(std.elf.EM.LOONGARCH), + PPC64 = @backingInt(std.elf.EM.PPC64), + RISCV = @backingInt(std.elf.EM.RISCV), + SPARCV9 = @backingInt(std.elf.EM.SPARCV9), + X86_64 = @backingInt(std.elf.EM.X86_64), fn toElf(m: EhdrMachine) std.elf.EM { return @bitCast(m); } /// Returns `null` if `m` is not a supported ELF machine architecture. fn fromElf(m: std.elf.EM) ?EhdrMachine { - return std.enums.fromInt(EhdrMachine, @intFromEnum(m)); + return std.enums.fromInt(EhdrMachine, @backingInt(m)); } }; /// Like `std.elf.ET`, but only includes the types of ELF file we can produce, so that we can use /// exhaustive `switch` statements in the linker implementation. const EhdrType = enum(u16) { - REL = @intFromEnum(std.elf.ET.REL), - EXEC = @intFromEnum(std.elf.ET.EXEC), - DYN = @intFromEnum(std.elf.ET.DYN), + REL = @backingInt(std.elf.ET.REL), + EXEC = @backingInt(std.elf.ET.EXEC), + DYN = @backingInt(std.elf.ET.DYN), fn toElf(t: EhdrType) std.elf.ET { return @bitCast(t); } @@ -4415,7 +4415,7 @@ fn targetPtrSize(elf: *const Elf) u8 { return elf.identClass().size(); } fn targetEndian(elf: *const Elf) std.lang.Endian { - const ident_data: std.elf.DATA = @enumFromInt(elf.mf.memory_map.memory[std.elf.EI.DATA]); + const ident_data: std.elf.DATA = @fromBackingInt(@intCast(elf.mf.memory_map.memory[std.elf.EI.DATA])); return ident_data.endian(); } fn targetTlsVariant(elf: *const Elf) union(enum) { @@ -4487,7 +4487,7 @@ fn targetLoad(elf: *const Elf, ptr: anytype) @typeInfo(@TypeOf(ptr)).pointer.chi return switch (@typeInfo(Child)) { else => @compileError(@typeName(Child)), .int => std.mem.toNative(Child, ptr.*, elf.targetEndian()), - .@"enum" => |@"enum"| @enumFromInt(elf.targetLoad(@as(*align(alignment) const @"enum".tag_type, @ptrCast(ptr)))), + .@"enum" => |@"enum"| @fromBackingInt(@intCast(elf.targetLoad(@as(*align(alignment) const @"enum".tag_type, @ptrCast(ptr))))), .@"struct" => |@"struct"| @bitCast( elf.targetLoad(@as(*align(alignment) @"struct".backing_integer.?, @ptrCast(ptr))), ), @@ -4502,7 +4502,7 @@ fn targetStore(elf: *const Elf, ptr: anytype, val: @typeInfo(@TypeOf(ptr)).point .int => ptr.* = std.mem.nativeTo(Child, val, elf.targetEndian()), .@"enum" => |@"enum"| elf.targetStore( @as(*align(alignment) @"enum".tag_type, @ptrCast(ptr)), - @intFromEnum(val), + @backingInt(val), ), .@"struct" => |@"struct"| elf.targetStore( @as(*align(alignment) @"struct".backing_integer.?, @ptrCast(ptr)), @@ -4557,7 +4557,7 @@ fn shdrPtr(elf: *Elf, shndx: Section.Index) ShdrPtr { .NONE, _ => unreachable, inline else => |class| { const shdr_slice: []class.ElfN().Shdr = @ptrCast(@alignCast(raw_slice)); - const shdr_ptr = &shdr_slice[@intFromEnum(shndx)]; + const shdr_ptr = &shdr_slice[@backingInt(shndx)]; return @unionInit(ShdrPtr, @tagName(class), shdr_ptr); }, } @@ -4574,7 +4574,7 @@ fn symPtr(elf: *Elf, index: Symbol.Index) SymPtr { inline else => |shdr, class| { const size = elf.targetLoad(&shdr.size); const slice: []class.ElfN().Sym = @ptrCast(@alignCast(raw_slice[0..@intCast(size)])); - return @unionInit(SymPtr, @tagName(class), &slice[@intFromEnum(index)]); + return @unionInit(SymPtr, @tagName(class), &slice[@backingInt(index)]); }, } } @@ -4653,7 +4653,7 @@ fn mapInputSection(elf: *Elf, opts: struct { const name_shstrtab = try elf.string(.shstrtab, name); const gop = try elf.section_by_name.getOrPut(gpa, name_shstrtab); if (gop.found_existing) { - break :existing @enumFromInt(gop.index); + break :existing @fromBackingInt(@intCast(gop.index)); } errdefer assert(elf.section_by_name.pop().?.key == name_shstrtab); const parent_node: MappedFile.Node.Index = parent: { @@ -4736,7 +4736,7 @@ fn navMapIndex(elf: *Elf, zcu: *Zcu, nav_index: InternPool.Nav.Index) Error!Node try elf.navs.ensureUnusedCapacity(gpa, 1); const nav_gop = elf.navs.getOrPutAssumeCapacity(nav_index); - const nmi: Node.NavMapIndex = @enumFromInt(nav_gop.index); + const nmi: Node.NavMapIndex = @fromBackingInt(@intCast(nav_gop.index)); if (!nav_gop.found_existing) { const shndx: Section.Index = section: { if (nav.resolved.?.@"linksection".toSlice(ip)) |@"linksection"| { @@ -4835,7 +4835,7 @@ fn uavMapIndex( }; const uav_gop = elf.uavs.getOrPutAssumeCapacity(uav_val); - const umi: Node.UavMapIndex = @enumFromInt(uav_gop.index); + const umi: Node.UavMapIndex = @fromBackingInt(@intCast(uav_gop.index)); if (!uav_gop.found_existing) { const shndx: Section.Index = .data_rel_ro; // TODO: it would be better to use `.rodata` if the UAV value doesn't have relocs const node = try elf.mf.addLastChildNode(gpa, shndx.get(elf).ni, .{ @@ -4846,7 +4846,7 @@ fn uavMapIndex( const name = std.fmt.bufPrint( &name_buf, "__anon_{d}", - .{@intFromEnum(uav_val)}, + .{@backingInt(uav_val)}, ) catch unreachable; uav_gop.value_ptr.* = .{ .lsi = elf.addLocalSymbolAssumeCapacity(.{ @@ -5061,7 +5061,7 @@ fn loadObject( const diags = &comp.link_diags; const r = &fr.interface; - const input_index: Node.InputIndex = @enumFromInt(elf.inputs.items.len); + const input_index: Node.InputIndex = @fromBackingInt(@intCast(elf.inputs.items.len)); log.debug("loadObject({f}{f})", .{ path.fmtEscapeString(), fmtMemberString(member) }); elf.checkInputIdent(path, r) catch |err| switch (err) { else => |e| return e, @@ -5251,9 +5251,9 @@ fn loadObject( .fixed = opts.node_fixed, }); elf.nodes.appendAssumeCapacity(.{ - .input_section = @enumFromInt(elf.input_sections.items.len), + .input_section = @fromBackingInt(@intCast(elf.input_sections.items.len)), }); - section.isi = @enumFromInt(elf.input_sections.items.len); + section.isi = @fromBackingInt(@intCast(elf.input_sections.items.len)); elf.input_sections.addOneAssumeCapacity().* = .{ .input = input_index, .file_location = .{ @@ -5598,7 +5598,7 @@ fn loadDso(elf: *Elf, path: std.Build.Cache.Path, fr: *Io.File.Reader) (LoadPars // insane---refer to the doc comment on `alignment` in `Elf.dso_globals`. const sym_align: std.mem.Alignment = switch (sym.value) { 0 => section_aligns[sym.shndx], - else => section_aligns[sym.shndx].min(@enumFromInt(@ctz(sym.value))), + else => section_aligns[sym.shndx].min(@fromBackingInt(@intCast(@ctz(sym.value)))), }; const name = try elf.string(.strtab, std.mem.sliceTo(dynstr[sym.name..], 0)); @@ -5900,16 +5900,16 @@ fn flushDynamic(elf: *Elf) void { dynamic_entries[dynamic_index..][0..elf.needed.count()], elf.needed.keys(), ) |*dynamic_entry, needed| { - dynamic_entry.* = .{ std.elf.DT_NEEDED, @intFromEnum(needed) }; + dynamic_entry.* = .{ std.elf.DT_NEEDED, @backingInt(needed) }; } dynamic_index += elf.needed.count(); if (elf.dynamic.soname != .empty) { - dynamic_entries[dynamic_index] = .{ std.elf.DT_SONAME, @intFromEnum(elf.dynamic.soname) }; + dynamic_entries[dynamic_index] = .{ std.elf.DT_SONAME, @backingInt(elf.dynamic.soname) }; dynamic_index += 1; } if (elf.dynamic.rpath != .empty) { - dynamic_entries[dynamic_index] = .{ std.elf.DT_RUNPATH, @intFromEnum(elf.dynamic.rpath) }; + dynamic_entries[dynamic_index] = .{ std.elf.DT_RUNPATH, @backingInt(elf.dynamic.rpath) }; dynamic_index += 1; } if (elf.dynamic.flags != 0) { @@ -6033,8 +6033,8 @@ fn addSection(elf: *Elf, segment_ni: MappedFile.Node.Index, opts: struct { break :alloc_shndx .{ shndx, shnum }; }, }; - assert(shndx < @intFromEnum(Section.Index.LORESERVE)); - break :shndx .{ @enumFromInt(shndx), @as(u64, elf.targetLoad(&ehdr.shentsize)) * @as(u64, shnum) }; + assert(shndx < @backingInt(Section.Index.LORESERVE)); + break :shndx .{ @fromBackingInt(@intCast(shndx)), @as(u64, elf.targetLoad(&ehdr.shentsize)) * @as(u64, shnum) }; }, }; try elf.ensureNodeSize(elf.ni.shdr, new_shdr_size); @@ -6066,7 +6066,7 @@ fn addSection(elf: *Elf, segment_ni: MappedFile.Node.Index, opts: struct { switch (elf.shdrPtr(shndx)) { inline else => |shdr, class| { shdr.* = .{ - .name = @intFromEnum(shstrtab_entry), + .name = @backingInt(shstrtab_entry), .type = opts.type, .flags = .{ .shf = opts.flags }, .addr = @intCast(addr), @@ -6105,7 +6105,7 @@ fn ensureUnusedRelocCapacity(elf: *Elf, node: MappedFile.Node.Index, len: usize) const rela_shndx = try elf.addSection(.none, .{ .name = rela_name, .type = .RELA, - .link = @intFromEnum(Section.Index.symtab), + .link = @backingInt(Section.Index.symtab), .info = shndx.toSection().?, .addralign = switch (class) { .NONE, _ => unreachable, @@ -6160,10 +6160,10 @@ fn addRelocAssumeCapacity( // the section offset now, but there's no point, because `flushMovedNodeRelocs` will // eventually do it for us anyway, so just init to 0. .offset = 0, - .raw_sym_index = @intFromEnum(target.index(elf)), + .raw_sym_index = @backingInt(target.index(elf)), .addend = addend, }); - const ri: SymbolReloc.Index = @enumFromInt(elf.symbol_relocs.items.len); + const ri: SymbolReloc.Index = @fromBackingInt(@intCast(elf.symbol_relocs.items.len)); const next: SymbolReloc.Index = next: { const target_ptr = target.index(elf).ptr(elf); const next = target_ptr.first_target_reloc; @@ -6621,7 +6621,7 @@ fn addSymbolRelocAssumeCapacity( } }; - const ri: SymbolReloc.Index = @enumFromInt(elf.symbol_relocs.items.len); + const ri: SymbolReloc.Index = @fromBackingInt(@intCast(elf.symbol_relocs.items.len)); const target_ptr = target.index(elf).ptr(elf); const next = target_ptr.first_target_reloc; target_ptr.first_target_reloc = ri; @@ -7125,7 +7125,7 @@ pub fn idle(elf: *Elf, tid: Zcu.PerThread.Id) link.Error!bool { task: { if (elf.input_section_pending_index < elf.input_sections.items.len) { - const isi: InputSection.Index = @enumFromInt(elf.input_section_pending_index); + const isi: InputSection.Index = @fromBackingInt(@intCast(elf.input_section_pending_index)); elf.input_section_pending_index += 1; const sub_prog_node = elf.idleProgNode(tid, elf.input_prog_node, elf.getNode(isi.node(elf))); defer sub_prog_node.end(); @@ -7148,7 +7148,7 @@ pub fn idle(elf: *Elf, tid: Zcu.PerThread.Id) link.Error!bool { .REL => { // Index in `.symtab` has changed. Relocatables are easy, we just need to update // all of the output relocations. - const symtab_index = @intFromEnum(global.symtab_index); + const symtab_index = @backingInt(global.symtab_index); var ri = sym.first_target_reloc; while (ri != .none) { const reloc = ri.get(elf); @@ -7190,7 +7190,7 @@ pub fn idle(elf: *Elf, tid: Zcu.PerThread.Id) link.Error!bool { // Update the PLT entry's reloc if there is one: if (elf.plt.getIndex(global_name)) |plt_index| { // PLT indices exactly match `.rela.plt` relocation indices. - elf.shndx.rela_plt.relaUpdateSym(elf, @enumFromInt(plt_index), global.dynsym_index); + elf.shndx.rela_plt.relaUpdateSym(elf, @fromBackingInt(@intCast(plt_index)), global.dynsym_index); } // Update relocs for any relevant GOT entries: @@ -7526,7 +7526,7 @@ fn flushMoved(elf: *Elf, ni: MappedFile.Node.Index) std.mem.Allocator.Error!void // Update local symbols const ii = isi.input(elf); var lsi, const end_lsi = ii.localSymbolRange(elf); - while (lsi != end_lsi) : (lsi = @enumFromInt(@intFromEnum(lsi) + 1)) { + while (lsi != end_lsi) : (lsi = @fromBackingInt(@intCast(@backingInt(lsi) + 1))) { if (lsi.index().ptr(elf).node != ni) continue; const visibility: std.elf.STV = switch (elf.symPtr(lsi.index())) { inline else => |sym| elf.targetLoad(&sym.other).visibility, @@ -7672,7 +7672,7 @@ fn flushResized(elf: *Elf, ni: MappedFile.Node.Index) std.mem.Allocator.Error!vo std.mem.swap(@TypeOf(ph.*), &phdr[new_phndx], next_ph); const next_ni = elf.phdrs.items[next_phndx]; elf.phdrs.items[new_phndx] = next_ni; - elf.nodes.items(.data)[@intFromEnum(next_ni)] = .{ .segment = new_phndx }; + elf.nodes.items(.data)[@backingInt(next_ni)] = .{ .segment = new_phndx }; new_phndx = @intCast(next_phndx); } if (new_phndx != phndx) { @@ -7680,7 +7680,7 @@ fn flushResized(elf: *Elf, ni: MappedFile.Node.Index) std.mem.Allocator.Error!vo elf.targetStore(&new_ph.vaddr, vaddr); new_ph.paddr = new_ph.vaddr; elf.phdrs.items[new_phndx] = ni; - elf.nodes.items(.data)[@intFromEnum(ni)] = .{ .segment = new_phndx }; + elf.nodes.items(.data)[@backingInt(ni)] = .{ .segment = new_phndx }; try ni.childrenMoved(elf.base.comp.gpa, &elf.mf); } } @@ -7736,7 +7736,7 @@ fn addPltEntry(elf: *Elf, global_name: String(.strtab), dynsym_index: u32) void // We use the existing free-list tracking of the `.rela.plt` section to also behave as a // free-list for the PLT itself---see `pltEntryIsDead` for details. - const plt_index: u32 = @intFromEnum(elf.shndx.rela_plt.relaAddOneAssumeCapacity(elf, .{ + const plt_index: u32 = @backingInt(elf.shndx.rela_plt.relaAddOneAssumeCapacity(elf, .{ .type = .jumpSlot(elf), .offset = 0, // populated later .raw_sym_index = dynsym_index, @@ -7756,7 +7756,7 @@ fn addPltEntry(elf: *Elf, global_name: String(.strtab), dynsym_index: u32) void }; // Now that we know the index, we can set the relocation's offset. - elf.shndx.rela_plt.relaSetOffset(elf, @enumFromInt(plt_index), got_plt_section.vaddr(elf) + got_plt_offset); + elf.shndx.rela_plt.relaSetOffset(elf, @fromBackingInt(@intCast(plt_index)), got_plt_section.vaddr(elf) + got_plt_offset); if (plt_index < elf.plt.count()) { // We reused a free entry, so we're already done! @@ -7951,7 +7951,7 @@ fn flushMovedPltSection(elf: *Elf, which: enum { plt, plt_sec, got_plt }, old_ad const rela_plt_shndx = elf.shndx.rela_plt; for (0..elf.plt.count()) |plt_index| { if (elf.pltEntryIsDead(plt_index)) continue; - rela_plt_shndx.relaAdjustOffset(elf, @enumFromInt(plt_index), old_addr, addr); + rela_plt_shndx.relaAdjustOffset(elf, @fromBackingInt(@intCast(plt_index)), old_addr, addr); } // We also need to update all of the references from `.plt.sec` to `.got.plt`. // However, if there's also a flush pending for `.plt.sec`, don't bother doing @@ -8002,7 +8002,7 @@ fn flushMovedPltSection(elf: *Elf, which: enum { plt, plt_sec, got_plt }, old_ad const rela_plt_shndx = elf.shndx.rela_plt; for (0..elf.plt.count()) |plt_index| { if (elf.pltEntryIsDead(plt_index)) continue; - rela_plt_shndx.relaAdjustOffset(elf, @enumFromInt(plt_index), old_addr, addr); + rela_plt_shndx.relaAdjustOffset(elf, @fromBackingInt(@intCast(plt_index)), old_addr, addr); } // We also need to update all of the references from `.plt` to `.got.plt`. // However, if there's also a flush pending for `.plt`, don't bother doing @@ -8052,7 +8052,7 @@ fn flushMovedPltSection(elf: *Elf, which: enum { plt, plt_sec, got_plt }, old_ad const rela_plt_shndx = elf.shndx.rela_plt; for (0..elf.plt.count()) |plt_index| { if (elf.pltEntryIsDead(plt_index)) continue; - rela_plt_shndx.relaAdjustOffset(elf, @enumFromInt(plt_index), old_addr, addr); + rela_plt_shndx.relaAdjustOffset(elf, @fromBackingInt(@intCast(plt_index)), old_addr, addr); } }, .plt_sec, .got_plt => unreachable, @@ -8225,10 +8225,10 @@ pub fn printNode( }), } { - const mf_node = &elf.mf.nodes.items[@intFromEnum(ni)]; + const mf_node = &elf.mf.nodes.items[@backingInt(ni)]; const off, const size = mf_node.location().resolve(&elf.mf); try w.print(" index={d} offset=0x{x} size=0x{x} align=0x{x}{s}{s}{s}{s}\n", .{ - @intFromEnum(ni), + @backingInt(ni), off, size, mf_node.flags.alignment.toByteUnits(), diff --git a/src/link/MachO.zig b/src/link/MachO.zig index 125db2983f2fa8a550b218d2d4be6d41153c1c8b..41d0c4fd5dc7a7854585b0a0d335c87a608e876c 100644 --- a/src/link/MachO.zig +++ b/src/link/MachO.zig @@ -4676,7 +4676,7 @@ pub const MachTask = extern struct { var out_port: std.c.mach_port_name_t = undefined; switch (getKernError(std.c.mach_port_allocate( self.port, - @intFromEnum(right), + @backingInt(right), &out_port, ))) { .SUCCESS => return .{ .port = out_port }, @@ -4694,7 +4694,7 @@ pub const MachTask = extern struct { self.port, port.port, port.port, - @intFromEnum(msg), + @backingInt(msg), ))) { .SUCCESS => return, .FAILURE => return error.PermissionDenied, @@ -5119,12 +5119,12 @@ pub fn machTaskForSelf() MachTask { } pub fn getKernError(err: std.c.kern_return_t) KernE { - return @as(KernE, @enumFromInt(@as(u32, @truncate(@as(usize, @intCast(err)))))); + return @as(KernE, @fromBackingInt(@intCast(@as(u32, @truncate(@as(usize, @intCast(err))))))); } pub fn unexpectedKernError(err: KernE) std.posix.UnexpectedError { if (std.options.unexpected_error_tracing) { - std.debug.print("unexpected error: {d}\n", .{@intFromEnum(err)}); + std.debug.print("unexpected error: {d}\n", .{@backingInt(err)}); std.debug.dumpCurrentStackTrace(.{}); } return error.Unexpected; diff --git a/src/link/MachO/Atom.zig b/src/link/MachO/Atom.zig index 17cbba5aecfddb67701a022217027c0669e7a7c6..a79fd6d95f28e77da73b609719111766892d1718 100644 --- a/src/link/MachO/Atom.zig +++ b/src/link/MachO/Atom.zig @@ -797,8 +797,8 @@ fn resolveRelocInner( .data_processing_immediate => aarch64.writeAddImmInst(@truncate(target), inst_code), .load_store => |load_store| { inst.load_store.register_unsigned_immediate.group.imm12 = switch (load_store.register_unsigned_immediate.decode()) { - .integer => |integer| try divExact(self, rel, @truncate(target), @as(u4, 1) << @intFromEnum(integer.group.size), macho_file), - .vector => |vector| try divExact(self, rel, @truncate(target), @as(u5, 1) << @intFromEnum(vector.group.opc1.decode(vector.group.size)), macho_file), + .integer => |integer| try divExact(self, rel, @truncate(target), @as(u4, 1) << @backingInt(integer.group.size), macho_file), + .vector => |vector| try divExact(self, rel, @truncate(target), @as(u5, 1) << @backingInt(vector.group.opc1.decode(vector.group.size)), macho_file), }; try writer.writeInt(u32, @bitCast(inst), .little); }, @@ -990,7 +990,7 @@ pub fn writeRelocs(self: Atom, macho_file: *MachO, code: []u8, buffer: []macho.r .r_pcrel = 0, .r_length = 2, .r_extern = 0, - .r_type = @intFromEnum(macho.reloc_type_arm64.ARM64_RELOC_ADDEND), + .r_type = @backingInt(macho.reloc_type_arm64.ARM64_RELOC_ADDEND), }; i += 1; } @@ -1021,7 +1021,7 @@ pub fn writeRelocs(self: Atom, macho_file: *MachO, code: []u8, buffer: []macho.r .r_pcrel = @intFromBool(rel.meta.pcrel), .r_extern = @intFromBool(r_extern), .r_length = rel.meta.length, - .r_type = @intFromEnum(r_type), + .r_type = @backingInt(r_type), }; }, .x86_64 => { @@ -1064,7 +1064,7 @@ pub fn writeRelocs(self: Atom, macho_file: *MachO, code: []u8, buffer: []macho.r .r_pcrel = @intFromBool(rel.meta.pcrel), .r_extern = @intFromBool(r_extern), .r_length = rel.meta.length, - .r_type = @intFromEnum(r_type), + .r_type = @backingInt(r_type), }; }, else => unreachable, diff --git a/src/link/MachO/Object.zig b/src/link/MachO/Object.zig index 17b7e5e768f22ebebc22c0fecaab13eba95f59b7..6f66764847e91d8264701aa9bba95266fcbd2ae5 100644 --- a/src/link/MachO/Object.zig +++ b/src/link/MachO/Object.zig @@ -979,7 +979,7 @@ fn initSymbolStabs(self: *Object, allocator: Allocator, nlists: anytype, macho_f const open = syms[i]; if (open.n_type.stab != .so) { try macho_file.reportParseError2(self.index, "unexpected symbol stab type 0x{x} as the first entry", .{ - @intFromEnum(open.n_type.stab), + @backingInt(open.n_type.stab), }); return error.MalformedObject; } @@ -1009,7 +1009,7 @@ fn initSymbolStabs(self: *Object, allocator: Allocator, nlists: anytype, macho_f stab.index = sym_lookup.find(nlist.n_value); }, _ => { - try macho_file.reportParseError2(self.index, "unhandled symbol stab type 0x{x}", .{@intFromEnum(nlist.n_type.stab)}); + try macho_file.reportParseError2(self.index, "unhandled symbol stab type 0x{x}", .{@backingInt(nlist.n_type.stab)}); return error.MalformedObject; }, else => { @@ -2032,8 +2032,8 @@ fn addReloc(offset: u32, arch: std.Target.Cpu.Arch) !macho.relocation_info { .r_length = 3, .r_extern = 0, .r_type = switch (arch) { - .aarch64 => @intFromEnum(macho.reloc_type_arm64.ARM64_RELOC_UNSIGNED), - .x86_64 => @intFromEnum(macho.reloc_type_x86_64.X86_64_RELOC_UNSIGNED), + .aarch64 => @backingInt(macho.reloc_type_arm64.ARM64_RELOC_UNSIGNED), + .x86_64 => @backingInt(macho.reloc_type_x86_64.X86_64_RELOC_UNSIGNED), else => unreachable, }, }; @@ -2844,7 +2844,7 @@ const x86_64 = struct { var i: usize = 0; while (i < relocs.len) : (i += 1) { const rel = relocs[i]; - const rel_type: macho.reloc_type_x86_64 = @enumFromInt(rel.r_type); + const rel_type: macho.reloc_type_x86_64 = @fromBackingInt(@intCast(rel.r_type)); const rel_offset = @as(u32, @intCast(rel.r_address)); var addend = switch (rel.r_length) { @@ -2853,7 +2853,7 @@ const x86_64 = struct { 2 => mem.readInt(i32, code[rel_offset..][0..4], .little), 3 => mem.readInt(i64, code[rel_offset..][0..8], .little), }; - addend += switch (@as(macho.reloc_type_x86_64, @enumFromInt(rel.r_type))) { + addend += switch (@as(macho.reloc_type_x86_64, @fromBackingInt(@intCast(rel.r_type)))) { .X86_64_RELOC_SIGNED_1 => 1, .X86_64_RELOC_SIGNED_2 => 2, .X86_64_RELOC_SIGNED_4 => 4, @@ -2884,7 +2884,7 @@ const x86_64 = struct { } else rel.r_symbolnum; const has_subtractor = if (i > 0 and - @as(macho.reloc_type_x86_64, @enumFromInt(relocs[i - 1].r_type)) == .X86_64_RELOC_SUBTRACTOR) + @as(macho.reloc_type_x86_64, @fromBackingInt(@intCast(relocs[i - 1].r_type))) == .X86_64_RELOC_SUBTRACTOR) blk: { if (rel_type != .X86_64_RELOC_UNSIGNED) { try macho_file.reportParseError2(self.index, "{s},{s}: 0x{x}: X86_64_RELOC_SUBTRACTOR followed by {s}", .{ @@ -3017,7 +3017,7 @@ const aarch64 = struct { var addend: i64 = 0; - switch (@as(macho.reloc_type_arm64, @enumFromInt(rel.r_type))) { + switch (@as(macho.reloc_type_arm64, @fromBackingInt(@intCast(rel.r_type)))) { .ARM64_RELOC_ADDEND => { addend = rel.r_symbolnum; i += 1; @@ -3028,7 +3028,7 @@ const aarch64 = struct { return error.MalformedObject; } rel = relocs[i]; - switch (@as(macho.reloc_type_arm64, @enumFromInt(rel.r_type))) { + switch (@as(macho.reloc_type_arm64, @fromBackingInt(@intCast(rel.r_type)))) { .ARM64_RELOC_PAGE21, .ARM64_RELOC_PAGEOFF12 => {}, else => |x| { try macho_file.reportParseError2( @@ -3051,7 +3051,7 @@ const aarch64 = struct { else => {}, } - const rel_type: macho.reloc_type_arm64 = @enumFromInt(rel.r_type); + const rel_type: macho.reloc_type_arm64 = @fromBackingInt(@intCast(rel.r_type)); var is_extern = rel.r_extern == 1; const target = if (!is_extern) blk: { @@ -3077,7 +3077,7 @@ const aarch64 = struct { } else rel.r_symbolnum; const has_subtractor = if (i > 0 and - @as(macho.reloc_type_arm64, @enumFromInt(relocs[i - 1].r_type)) == .ARM64_RELOC_SUBTRACTOR) + @as(macho.reloc_type_arm64, @fromBackingInt(@intCast(relocs[i - 1].r_type))) == .ARM64_RELOC_SUBTRACTOR) blk: { if (rel_type != .ARM64_RELOC_UNSIGNED) { try macho_file.reportParseError2(self.index, "{s},{s}: 0x{x}: ARM64_RELOC_SUBTRACTOR followed by {s}", .{ diff --git a/src/link/MachO/UnwindInfo.zig b/src/link/MachO/UnwindInfo.zig index cc775b538d314d57a59c329b72a8d29c0db176a2..7e54bd91e7888d230769ab962de967ebbf14ba47 100644 --- a/src/link/MachO/UnwindInfo.zig +++ b/src/link/MachO/UnwindInfo.zig @@ -30,8 +30,8 @@ fn canFold(macho_file: *MachO, lhs_ref: Record.Ref, rhs_ref: Record.Ref) bool { const lhs = lhs_ref.getUnwindRecord(macho_file); const rhs = rhs_ref.getUnwindRecord(macho_file); if (cpu_arch == .x86_64) { - if (lhs.enc.getMode() == @intFromEnum(macho.UNWIND_X86_64_MODE.STACK_IND) or - rhs.enc.getMode() == @intFromEnum(macho.UNWIND_X86_64_MODE.STACK_IND)) return false; + if (lhs.enc.getMode() == @backingInt(macho.UNWIND_X86_64_MODE.STACK_IND) or + rhs.enc.getMode() == @backingInt(macho.UNWIND_X86_64_MODE.STACK_IND)) return false; } const lhs_per = lhs.personality orelse 0; const rhs_per = rhs.personality orelse 0; @@ -412,8 +412,8 @@ pub const Encoding = extern struct { pub fn isDwarf(enc: Encoding, macho_file: *MachO) bool { const mode = enc.getMode(); return switch (macho_file.getTarget().cpu.arch) { - .aarch64 => @as(macho.UNWIND_ARM64_MODE, @enumFromInt(mode)) == .DWARF, - .x86_64 => @as(macho.UNWIND_X86_64_MODE, @enumFromInt(mode)) == .DWARF, + .aarch64 => @as(macho.UNWIND_ARM64_MODE, @fromBackingInt(@intCast(mode))) == .DWARF, + .x86_64 => @as(macho.UNWIND_X86_64_MODE, @fromBackingInt(@intCast(mode))) == .DWARF, else => unreachable, }; } @@ -421,7 +421,7 @@ pub const Encoding = extern struct { pub fn setMode(enc: *Encoding, mode: anytype) void { comptime assert(macho.UNWIND_ARM64_MODE_MASK == macho.UNWIND_X86_64_MODE_MASK); const shift = comptime @ctz(macho.UNWIND_ARM64_MODE_MASK); - enc.enc |= @as(u32, @intCast(@intFromEnum(mode))) << shift; + enc.enc |= @as(u32, @intCast(@backingInt(mode))) << shift; } pub fn hasLsda(enc: Encoding) bool { diff --git a/src/link/MachO/ZigObject.zig b/src/link/MachO/ZigObject.zig index 6b69c2df05e692704acc961ac8b55a55c10fe7aa..8d7407a0a397e9f4f0df654ef4eb45fe19e0e108 100644 --- a/src/link/MachO/ZigObject.zig +++ b/src/link/MachO/ZigObject.zig @@ -632,7 +632,7 @@ pub fn getNavVAddr( switch (reloc_info.parent) { .none => unreachable, .atom_index => |atom_index| { - const parent_atom = self.symbols.items[@intFromEnum(atom_index)].getAtom(macho_file).?; + const parent_atom = self.symbols.items[@backingInt(atom_index)].getAtom(macho_file).?; try parent_atom.addReloc(macho_file, .{ .tag = .@"extern", .offset = @intCast(reloc_info.offset), @@ -650,7 +650,7 @@ pub fn getNavVAddr( .debug_output => |debug_output| switch (debug_output) { .dwarf => |wip_nav| try wip_nav.infoExternalReloc(.{ .source_off = @intCast(reloc_info.offset), - .target_sym = @enumFromInt(sym_index), + .target_sym = @fromBackingInt(@intCast(sym_index)), .target_off = reloc_info.addend, }), .none => unreachable, @@ -671,7 +671,7 @@ pub fn getUavVAddr( switch (reloc_info.parent) { .none => unreachable, .atom_index => |atom_index| { - const parent_atom = self.symbols.items[@intFromEnum(atom_index)].getAtom(macho_file).?; + const parent_atom = self.symbols.items[@backingInt(atom_index)].getAtom(macho_file).?; try parent_atom.addReloc(macho_file, .{ .tag = .@"extern", .offset = @intCast(reloc_info.offset), @@ -689,7 +689,7 @@ pub fn getUavVAddr( .debug_output => |debug_output| switch (debug_output) { .dwarf => |wip_nav| try wip_nav.infoExternalReloc(.{ .source_off = @intCast(reloc_info.offset), - .target_sym = @enumFromInt(sym_index), + .target_sym = @fromBackingInt(@intCast(sym_index)), .target_off = reloc_info.addend, }), .none => unreachable, @@ -716,12 +716,12 @@ pub fn lowerUav( const sym = self.symbols.items[metadata.symbol_index]; const existing_alignment = sym.getAtom(macho_file).?.alignment; if (uav_alignment.order(existing_alignment).compare(.lte)) - return @enumFromInt(metadata.symbol_index); + return @fromBackingInt(@intCast(metadata.symbol_index)); } var name_buf: [32]u8 = undefined; const name = std.fmt.bufPrint(&name_buf, "__anon_{d}", .{ - @intFromEnum(uav), + @backingInt(uav), }) catch unreachable; const sym_index = self.lowerConst( macho_file, @@ -737,7 +737,7 @@ pub fn lowerUav( .{e}, ), }; - try self.uavs.put(gpa, uav, .{ .symbol_index = @intFromEnum(sym_index) }); + try self.uavs.put(gpa, uav, .{ .symbol_index = @backingInt(sym_index) }); return sym_index; } @@ -783,14 +783,14 @@ pub fn updateFunc( var aw: std.Io.Writer.Allocating = .init(gpa); defer aw.deinit(); - var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, func.owner_nav, @enumFromInt(sym_index)) else null; + var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, func.owner_nav, @fromBackingInt(@intCast(sym_index))) else null; defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit(); codegen.emitFunction( &macho_file.base, pt, func_index, - @enumFromInt(sym_index), + @fromBackingInt(@intCast(sym_index)), mir, &aw.writer, if (debug_wip_nav) |*wip_nav| .{ .dwarf = wip_nav } else .none, @@ -876,7 +876,7 @@ pub fn updateNav( const sym_index = try self.getGlobalSymbol(macho_file, name, lib_name); if (nav.resolved.?.@"threadlocal" and macho_file.base.comp.config.any_non_single_threaded) self.symbols.items[sym_index].flags.tlv = true; if (self.dwarf) |*dwarf| { - var debug_wip_nav = try dwarf.initWipNav(pt, nav_index, @enumFromInt(sym_index)); + var debug_wip_nav = try dwarf.initWipNav(pt, nav_index, @fromBackingInt(@intCast(sym_index))); defer debug_wip_nav.deinit(); dwarf.finishWipNav(pt, nav_index, &debug_wip_nav) catch |err| switch (err) { error.OutOfMemory, error.Canceled, error.AlreadyReported => |e| return e, @@ -894,7 +894,7 @@ pub fn updateNav( var aw: std.Io.Writer.Allocating = .init(zcu.gpa); defer aw.deinit(); - var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, nav_index, @enumFromInt(sym_index)) else null; + var debug_wip_nav = if (self.dwarf) |*dwarf| try dwarf.initWipNav(pt, nav_index, @fromBackingInt(@intCast(sym_index))) else null; defer if (debug_wip_nav) |*wip_nav| wip_nav.deinit(); codegen.generateSymbol( @@ -902,7 +902,7 @@ pub fn updateNav( pt, .fromInterned(nav.resolved.?.value), &aw.writer, - .{ .atom_index = @enumFromInt(sym_index) }, + .{ .atom_index = @fromBackingInt(@intCast(sym_index)) }, ) catch |err| switch (err) { error.WriteFailed => return error.OutOfMemory, else => |e| return e, @@ -1203,7 +1203,7 @@ fn lowerConst( pt, val, &aw.writer, - .{ .atom_index = @enumFromInt(sym_index) }, + .{ .atom_index = @fromBackingInt(@intCast(sym_index)) }, ) catch |err| switch (err) { error.WriteFailed => return error.OutOfMemory, else => |e| return e, @@ -1231,7 +1231,7 @@ fn lowerConst( const file_offset = sect.offset + atom.value; try macho_file.pwriteAll(code, file_offset); - return @enumFromInt(sym_index); + return @fromBackingInt(@intCast(sym_index)); } pub fn updateExports( @@ -1353,7 +1353,7 @@ fn updateLazySymbol( &required_alignment, &aw.writer, .none, - .{ .atom_index = @enumFromInt(symbol_index) }, + .{ .atom_index = @fromBackingInt(@intCast(symbol_index)) }, ); const code = aw.written(); diff --git a/src/link/MachO/eh_frame.zig b/src/link/MachO/eh_frame.zig index b67fc9d25101cecf0a9b5eae9815c37fbc12dffc..b65c68ff48f334123f117c338d15f657b0b98c3f 100644 --- a/src/link/MachO/eh_frame.zig +++ b/src/link/MachO/eh_frame.zig @@ -464,8 +464,8 @@ pub fn writeRelocs(macho_file: *MachO, code: []u8, relocs: []macho.relocation_in .r_extern = 1, .r_pcrel = 1, .r_type = switch (cpu_arch) { - .aarch64 => @intFromEnum(macho.reloc_type_arm64.ARM64_RELOC_POINTER_TO_GOT), - .x86_64 => @intFromEnum(macho.reloc_type_x86_64.X86_64_RELOC_GOT), + .aarch64 => @backingInt(macho.reloc_type_arm64.ARM64_RELOC_POINTER_TO_GOT), + .x86_64 => @backingInt(macho.reloc_type_x86_64.X86_64_RELOC_GOT), else => unreachable, }, }; diff --git a/src/link/MappedFile.zig b/src/link/MappedFile.zig index 004b3f3f409308abae8d27383e8a10f5300d9e4c..6fd6e1ab4a27da8b582f8d5daa1ca122aeb546c9 100644 --- a/src/link/MappedFile.zig +++ b/src/link/MappedFile.zig @@ -181,7 +181,7 @@ pub const Node = extern struct { pub const root: Node.Index = .none; fn get(ni: Node.Index, mf: *const MappedFile) *Node { - return &mf.nodes.items[@intFromEnum(ni)]; + return &mf.nodes.items[@backingInt(ni)]; } pub fn parent(ni: Node.Index, mf: *const MappedFile) Node.Index { @@ -561,7 +561,7 @@ fn addNode(mf: *MappedFile, gpa: std.mem.Allocator, opts: struct { break :location .{ .large, .{ .large = .{ .index = mf.large.items.len } } }; }; const free_ni: Node.Index, const free_node = free: switch (mf.free_ni) { - .none => .{ @enumFromInt(mf.nodes.items.len), mf.nodes.addOneAssumeCapacity() }, + .none => .{ @fromBackingInt(@intCast(mf.nodes.items.len)), mf.nodes.addOneAssumeCapacity() }, else => |free_ni| { const free_node = free_ni.get(mf); mf.free_ni = free_node.next; diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig index aeb6217f5dcc5c83681bb9aea5cbaa8dc4821801..10d01c2055ff5bf5c1d3734b4a4ae43411d8cc14 100644 --- a/src/link/SpirV.zig +++ b/src/link/SpirV.zig @@ -153,7 +153,7 @@ pub fn loadInput(linker: *Linker, input: link.Input) !void { var it: BinaryModule.Instruction.Iterator = .init(instructions, 0); const has_linkage = while (it.next()) |inst| switch (inst.opcode) { .OpCapability => { - const cap: spec.Capability = @enumFromInt(inst.operands[0]); + const cap: spec.Capability = @fromBackingInt(@intCast(inst.operands[0])); if (cap == .linkage) break true; }, else => break false, @@ -343,7 +343,7 @@ fn mergeFragments(linker: *Linker, gpa: Allocator, arena: Allocator) error{OutOf const id_offset = next_id - 1; frag_infos.appendAssumeCapacity(.{ .id_offset = id_offset }); if (mir.decl_result_id != .none) { - try nav_final_ids.put(gpa, nav, @enumFromInt(@intFromEnum(mir.decl_result_id) + id_offset)); + try nav_final_ids.put(gpa, nav, @fromBackingInt(@intCast(@backingInt(mir.decl_result_id) + id_offset))); } next_id += mir.id_bound - 1; } @@ -351,13 +351,13 @@ fn mergeFragments(linker: *Linker, gpa: Allocator, arena: Allocator) error{OutOf for (linker.fragments.values(), frag_infos.items) |*mir, frag_info| { for (mir.nav_refs) |ref| { if (!nav_final_ids.contains(ref.nav)) { - try nav_final_ids.put(gpa, ref.nav, @enumFromInt(@intFromEnum(ref.local_id) + frag_info.id_offset)); + try nav_final_ids.put(gpa, ref.nav, @fromBackingInt(@intCast(@backingInt(ref.local_id) + frag_info.id_offset))); } } for (mir.uav_refs) |ref| { const key = .{ ref.val, ref.storage_class }; if (!uav_final_ids.contains(key)) { - try uav_final_ids.put(gpa, key, @enumFromInt(@intFromEnum(ref.local_id) + frag_info.id_offset)); + try uav_final_ids.put(gpa, key, @fromBackingInt(@intCast(@backingInt(ref.local_id) + frag_info.id_offset))); } } } @@ -391,10 +391,10 @@ fn mergeFragments(linker: *Linker, gpa: Allocator, arena: Allocator) error{OutOf while (it.next()) |inst| { const ld = LinkageDecoration.parse(inst) orelse continue; if (ld.linkage_type != .@"export") continue; - const remapped_id: Id = @enumFromInt(@intFromEnum(ld.target_id) + id_offset); + const remapped_id: Id = @fromBackingInt(@intCast(@backingInt(ld.target_id) + id_offset)); if (extern_name_map.get(ld.name)) |nav_index| { - log.debug("extern resolve: '{s}' -> ext_fn_id={d}", .{ ld.name, @intFromEnum(remapped_id) }); + log.debug("extern resolve: '{s}' -> ext_fn_id={d}", .{ ld.name, @backingInt(remapped_id) }); nav_final_ids.getPtr(nav_index).?.* = remapped_id; _ = extern_name_map.swapRemove(ld.name); try resolved_ids.put(gpa, remapped_id, {}); @@ -579,7 +579,7 @@ fn remapFilteredInsts( switch (mode) { .skip_functions => { if (inst.opcode == .OpFunction) { - skip_function = skip_ids.contains(@enumFromInt(inst.operands[1])); + skip_function = skip_ids.contains(@fromBackingInt(@intCast(inst.operands[1]))); } if (skip_function) { if (inst.opcode == .OpFunctionEnd) skip_function = false; @@ -593,7 +593,7 @@ fn remapFilteredInsts( }, .skip_names => { if (inst.opcode == .OpName and inst.operands.len >= 1) { - if (skip_ids.contains(@enumFromInt(inst.operands[0]))) continue; + if (skip_ids.contains(@fromBackingInt(@intCast(inst.operands[0])))) continue; } }, } @@ -817,11 +817,11 @@ const LinkageDecoration = struct { fn parse(inst: BinaryModule.Instruction) ?LinkageDecoration { if (inst.opcode != .OpDecorate) return null; if (inst.operands.len < 3) return null; - if (inst.operands[1] != @intFromEnum(spec.Decoration.linkage_attributes)) return null; + if (inst.operands[1] != @backingInt(spec.Decoration.linkage_attributes)) return null; return .{ - .target_id = @enumFromInt(inst.operands[0]), + .target_id = @fromBackingInt(@intCast(inst.operands[0])), .name = std.mem.sliceTo(std.mem.sliceAsBytes(inst.operands[2 .. inst.operands.len - 1]), 0), - .linkage_type = @enumFromInt(inst.operands[inst.operands.len - 1]), + .linkage_type = @fromBackingInt(@intCast(inst.operands[inst.operands.len - 1])), }; } }; @@ -897,7 +897,7 @@ fn appendExternalObjects( while (it.next()) |inst| { const ld = LinkageDecoration.parse(inst) orelse continue; if (ld.linkage_type != .@"export") continue; - try export_map.put(gpa, ld.name, @enumFromInt(@intFromEnum(ld.target_id) + id_offset)); + try export_map.put(gpa, ld.name, @fromBackingInt(@intCast(@backingInt(ld.target_id) + id_offset))); } } @@ -920,14 +920,14 @@ fn appendExternalObjects( while (it.next()) |inst| { const ld = LinkageDecoration.parse(inst) orelse continue; if (ld.linkage_type != .import) continue; - const remapped_import: Id = @enumFromInt(@intFromEnum(ld.target_id) + id_offset); + const remapped_import: Id = @fromBackingInt(@intCast(@backingInt(ld.target_id) + id_offset)); if (export_map.get(ld.name)) |export_id| { try per_obj_remaps[obj_idx].put(gpa, ld.target_id, export_id); try resolved_linkage_ids.put(gpa, remapped_import, {}); try resolved_linkage_ids.put(gpa, export_id, {}); log.debug("cross-object resolve: '{s}' import={d} -> export={d}", .{ - ld.name, @intFromEnum(remapped_import), @intFromEnum(export_id), + ld.name, @backingInt(remapped_import), @backingInt(export_id), }); } else { has_linkage.* = true; @@ -968,7 +968,7 @@ fn appendExternalObjects( } if (LinkageDecoration.parse(inst)) |ld| { - const remapped: Id = @enumFromInt(@intFromEnum(ld.target_id) + id_offset); + const remapped: Id = @fromBackingInt(@intCast(@backingInt(ld.target_id) + id_offset)); if (resolved_linkage_ids.contains(remapped)) { if (ld.linkage_type == .@"export" and is_obj) { has_linkage.* = true; @@ -979,7 +979,7 @@ fn appendExternalObjects( } if (inst.opcode == .OpName and inst.operands.len >= 1) { - if (id_remap.contains(@enumFromInt(inst.operands[0]))) continue; + if (id_remap.contains(@fromBackingInt(@intCast(inst.operands[0])))) continue; } const dest = sections.getSection(Sections.classifyPreambleInst(inst.opcode)); @@ -990,7 +990,7 @@ fn appendExternalObjects( var skip_function = false; while (fn_it.next()) |inst| { if (inst.opcode == .OpFunction) { - skip_function = id_remap.contains(@enumFromInt(inst.operands[1])); + skip_function = id_remap.contains(@fromBackingInt(@intCast(inst.operands[1]))); } if (!skip_function) { try remapAndAppendInst(gpa, §ions.functions, ext_obj.instructions, inst, id_offset, id_remap, parser); @@ -1034,7 +1034,7 @@ fn collectEntryPointInterface( } for (mir.internal_globals) |local_id| { - const global_id: Id = @enumFromInt(@intFromEnum(local_id) + id_offset); + const global_id: Id = @fromBackingInt(@intCast(@backingInt(local_id) + id_offset)); try interface.append(gpa, global_id); } @@ -1206,11 +1206,11 @@ fn operandLiteralWordCount(kind: spec.OperandKind, inst: BinaryModule.Instructio } fn remapSingleId(word: *Word, id_offset: Word, id_remap: *const std.AutoHashMapUnmanaged(Id, Id)) void { - const id: Id = @enumFromInt(word.*); + const id: Id = @fromBackingInt(@intCast(word.*)); if (id == .none) return; if (id_remap.get(id)) |final_id| { - word.* = @intFromEnum(final_id); + word.* = @backingInt(final_id); } else { - word.* = @intFromEnum(id) + id_offset; + word.* = @backingInt(id) + id_offset; } } diff --git a/src/link/SpirV/BinaryModule.zig b/src/link/SpirV/BinaryModule.zig index 53172685dc5c55a36fa0c57ccd7226a5f1b54fd4..b19cf7c4a2b4249940ffdbe025c167aefe57b883 100644 --- a/src/link/SpirV/BinaryModule.zig +++ b/src/link/SpirV/BinaryModule.zig @@ -58,7 +58,7 @@ pub const Instruction = struct { assert(it.offset < it.words.len); return Instruction{ - .opcode = @enumFromInt(it.words[it.offset] & 0xFFFF), + .opcode = @fromBackingInt(@intCast(it.words[it.offset] & 0xFFFF)), .offset = it.offset, .operands = it.words[it.offset..][1..instruction_len], }; @@ -97,11 +97,11 @@ pub const Parser = struct { } fn mapSetAndOpcode(set: InstructionSet, opcode: u16) u32 { - return (@as(u32, @intFromEnum(set)) << 16) | opcode; + return (@as(u32, @backingInt(set)) << 16) | opcode; } pub fn getInstSpec(parser: Parser, opcode: Opcode) ?spec.Instruction { - const index = parser.opcode_table.get(mapSetAndOpcode(.core, @intFromEnum(opcode))) orelse return null; + const index = parser.opcode_table.get(mapSetAndOpcode(.core, @backingInt(opcode))) orelse return null; return InstructionSet.core.instructions()[index]; } @@ -127,10 +127,10 @@ pub const Parser = struct { const set_name = std.mem.sliceTo(std.mem.sliceAsBytes(operands[1..]), 0); const set = std.meta.stringToEnum(InstructionSet, set_name) orelse continue; if (set == .core) continue; - try binary.ext_inst_map.put(parser.gpa, @enumFromInt(operands[0]), set); + try binary.ext_inst_map.put(parser.gpa, @fromBackingInt(@intCast(operands[0])), set); }, .OpTypeInt, .OpTypeFloat => { - try binary.arith_type_width.put(parser.gpa, @enumFromInt(operands[0]), @intCast(operands[1])); + try binary.arith_type_width.put(parser.gpa, @fromBackingInt(@intCast(operands[0])), @intCast(operands[1])); }, .OpFunction => if (maybe_function_section == null) { maybe_function_section = inst.offset; @@ -145,8 +145,8 @@ pub const Parser = struct { spec_operands[1].kind == .id_result) { if (operands.len >= 2) { - if (binary.arith_type_width.get(@enumFromInt(operands[0]))) |width| { - try binary.arith_type_width.put(parser.gpa, @enumFromInt(operands[1]), width); + if (binary.arith_type_width.get(@fromBackingInt(@intCast(operands[0])))) |width| { + try binary.arith_type_width.put(parser.gpa, @fromBackingInt(@intCast(operands[1])), width); } } } @@ -165,7 +165,7 @@ pub const Parser = struct { inst: Instruction, offsets: *std.ArrayList(u16), ) !void { - const index = parser.opcode_table.get(mapSetAndOpcode(.core, @intFromEnum(inst.opcode))).?; + const index = parser.opcode_table.get(mapSetAndOpcode(.core, @backingInt(inst.opcode))).?; const operands = InstructionSet.core.instructions()[index].operands; var offset: usize = 0; @@ -190,10 +190,10 @@ pub const Parser = struct { offset = try parser.parseOperandsResultIds(binary, inst, operands[0..2], offset, offsets); if (offset + 1 >= inst.operands.len) return error.InvalidPhysicalFormat; - const set_id: ResultId = @enumFromInt(inst.operands[offset]); + const set_id: ResultId = @fromBackingInt(@intCast(inst.operands[offset])); try offsets.append(parser.gpa, @intCast(offset)); const set = binary.ext_inst_map.get(set_id) orelse { - log.err("invalid instruction set {}", .{@intFromEnum(set_id)}); + log.err("invalid instruction set {}", .{@backingInt(set_id)}); return error.InvalidId; }; const ext_opcode = std.math.cast(u16, inst.operands[offset + 1]) orelse return error.InvalidPhysicalFormat; @@ -304,7 +304,7 @@ pub const Parser = struct { }, .literal_context_dependent_number => { assert(inst.opcode == .OpConstant or inst.opcode == .OpSpecConstant); - const bit_width = binary.arith_type_width.get(@enumFromInt(inst.operands[0])) orelse { + const bit_width = binary.arith_type_width.get(@fromBackingInt(@intCast(inst.operands[0]))) orelse { log.err("invalid LiteralContextDependentNumber type {}", .{inst.operands[0]}); return error.InvalidId; }; @@ -318,7 +318,7 @@ pub const Parser = struct { .literal_spec_constant_op_integer => unreachable, .pair_literal_integer_id_ref => { assert(inst.opcode == .OpSwitch); - const bit_width = binary.arith_type_width.get(@enumFromInt(inst.operands[0])) orelse { + const bit_width = binary.arith_type_width.get(@fromBackingInt(@intCast(inst.operands[0]))) orelse { log.err("invalid OpSwitch type {}", .{inst.operands[0]}); return error.InvalidId; }; diff --git a/src/link/SpirV/dedup_types.zig b/src/link/SpirV/dedup_types.zig index 338258e17ef40eff1d9557163395689a33cb22db..df0d9a29dd78258acda42be564a14ab748638bce 100644 --- a/src/link/SpirV/dedup_types.zig +++ b/src/link/SpirV/dedup_types.zig @@ -35,7 +35,7 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { }, } if (inst.operands.len == 0) continue; - const target_id: Id = @enumFromInt(inst.operands[0]); + const target_id: Id = @fromBackingInt(@intCast(inst.operands[0])); const gop = try decorations_by_id.getOrPut(gpa, target_id); if (!gop.found_existing) gop.value_ptr.* = .empty; @@ -75,10 +75,10 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { else => continue, }; if (result_id_index >= inst.operands.len) continue; - const result_id: Id = @enumFromInt(inst.operands[result_id_index]); + const result_id: Id = @fromBackingInt(@intCast(inst.operands[result_id_index])); key_words.items.len = 0; - try key_words.append(gpa, @intFromEnum(inst.opcode)); + try key_words.append(gpa, @backingInt(inst.opcode)); id_offsets.items.len = 0; parser.parseInstructionResultIds(binary.*, inst, &id_offsets) catch continue; @@ -86,8 +86,8 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { for (inst.operands, 0..) |word, i| { if (i == result_id_index) continue; if (std.mem.indexOfScalar(u16, id_offsets.items, @intCast(i)) != null) { - const canonical = id_remap.get(@enumFromInt(word)) orelse @as(Id, @enumFromInt(word)); - try key_words.append(gpa, @intFromEnum(canonical)); + const canonical = id_remap.get(@fromBackingInt(@intCast(word))) orelse @as(Id, @fromBackingInt(@intCast(word))); + try key_words.append(gpa, @backingInt(canonical)); } else { try key_words.append(gpa, word); } @@ -100,7 +100,7 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { var hasher = std.hash.Wyhash.init(0); hasher.update(std.mem.asBytes(&dec_words[0])); for (dec_words[2..]) |w| { - const w_val = if (id_remap.get(@enumFromInt(w))) |c| @intFromEnum(c) else w; + const w_val = if (id_remap.get(@fromBackingInt(@intCast(w)))) |c| @backingInt(c) else w; hasher.update(std.mem.asBytes(&w_val)); } try dec_hashes.append(gpa, hasher.final()); @@ -151,7 +151,7 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { else => unreachable, }; if (result_id_index < inst.operands.len) { - const result_id: Id = @enumFromInt(inst.operands[result_id_index]); + const result_id: Id = @fromBackingInt(@intCast(inst.operands[result_id_index])); if (id_remap.contains(result_id)) continue; } } @@ -159,7 +159,7 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { switch (inst.opcode.class()) { .annotation, .debug => { if (inst.operands.len > 0) { - const target: Id = @enumFromInt(inst.operands[0]); + const target: Id = @fromBackingInt(@intCast(inst.operands[0])); if (id_remap.contains(target)) continue; } }, @@ -186,8 +186,8 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { max_id = @max(max_id, word.*); if (maybe_result_id_index != null and i == maybe_result_id_index.?) continue; - if (id_remap.get(@enumFromInt(word.*))) |canonical| { - word.* = @intFromEnum(canonical); + if (id_remap.get(@fromBackingInt(@intCast(word.*)))) |canonical| { + word.* = @backingInt(canonical); max_id = @max(max_id, word.*); } } diff --git a/src/link/SpirV/lower_invocation_globals.zig b/src/link/SpirV/lower_invocation_globals.zig index 7cc9604d049908c09fa63599ac2d0b61359331ef..7ea41763d3cc3c0dad0fe244c60fafbc01c58ed0 100644 --- a/src/link/SpirV/lower_invocation_globals.zig +++ b/src/link/SpirV/lower_invocation_globals.zig @@ -94,7 +94,7 @@ const ModuleInfo = struct { switch (inst.opcode) { .OpEntryPoint => { - const entry_point: ResultId = @enumFromInt(inst.operands[1]); + const entry_point: ResultId = @fromBackingInt(@intCast(inst.operands[1])); const entry = try entry_points.getOrPut(arena, entry_point); if (entry.found_existing) { log.err("Entry point type {f} has duplicate definition", .{entry_point}); @@ -102,8 +102,8 @@ const ModuleInfo = struct { } }, .OpTypeFunction => { - const fn_type: ResultId = @enumFromInt(inst.operands[0]); - const return_type: ResultId = @enumFromInt(inst.operands[1]); + const fn_type: ResultId = @fromBackingInt(@intCast(inst.operands[0])); + const return_type: ResultId = @fromBackingInt(@intCast(inst.operands[1])); const param_types: []const ResultId = @ptrCast(inst.operands[2..]); const entry = try fn_types.getOrPut(fn_type); @@ -119,15 +119,15 @@ const ModuleInfo = struct { }, .OpExtInst => { // Note: format and set are already verified by parseInstructionResultIds(). - const global_type: ResultId = @enumFromInt(inst.operands[0]); - const result_id: ResultId = @enumFromInt(inst.operands[1]); - const set_id: ResultId = @enumFromInt(inst.operands[2]); + const global_type: ResultId = @fromBackingInt(@intCast(inst.operands[0])); + const result_id: ResultId = @fromBackingInt(@intCast(inst.operands[1])); + const set_id: ResultId = @fromBackingInt(@intCast(inst.operands[2])); const set_inst = inst.operands[3]; const set = binary.ext_inst_map.get(set_id).?; if (set == .zig and set_inst == 0) { const initializer: ResultId = if (inst.operands.len >= 5) - @enumFromInt(inst.operands[4]) + @fromBackingInt(@intCast(inst.operands[4])) else .none; @@ -144,12 +144,12 @@ const ModuleInfo = struct { return error.InvalidPhysicalFormat; } - maybe_current_function = @enumFromInt(inst.operands[1]); - fn_ty_id = @enumFromInt(inst.operands[3]); + maybe_current_function = @fromBackingInt(@intCast(inst.operands[1])); + fn_ty_id = @fromBackingInt(@intCast(inst.operands[3])); function_invocation_globals.clearRetainingCapacity(); }, .OpFunctionCall => { - const callee: ResultId = @enumFromInt(inst.operands[2]); + const callee: ResultId = @fromBackingInt(@intCast(inst.operands[2])); try calls.put(arena, callee, {}); }, .OpFunctionEnd => { @@ -184,7 +184,7 @@ const ModuleInfo = struct { } for (result_id_offsets.items) |off| { - const result_id: ResultId = @enumFromInt(inst.operands[off]); + const result_id: ResultId = @fromBackingInt(@intCast(inst.operands[off])); if (invocation_globals.contains(result_id)) { try function_invocation_globals.put(arena, result_id, {}); } @@ -355,7 +355,7 @@ const ModuleBuilder = struct { global_id_base: u32, fn invocationGlobalId(self: FunctionNewInfo, index: usize) ResultId { - return @enumFromInt(self.global_id_base + @as(u32, @intCast(index))); + return @fromBackingInt(@intCast(self.global_id_base + @as(u32, @intCast(index)))); } }; @@ -384,7 +384,7 @@ const ModuleBuilder = struct { .entry_point_new_id_base = undefined, .new_functions_section = null, }; - self.entry_point_new_id_base = @intFromEnum(self.allocIds(@intCast(info.entry_points.count()))); + self.entry_point_new_id_base = @backingInt(self.allocIds(@intCast(info.entry_points.count()))); return self; } @@ -394,7 +394,7 @@ const ModuleBuilder = struct { fn allocIds(self: *ModuleBuilder, n: u32) ResultId { defer self.id_bound += n; - return @enumFromInt(self.id_bound); + return @fromBackingInt(@intCast(self.id_bound)); } fn finalize(self: *ModuleBuilder, arena: Allocator, binary: *BinaryModule) !void { @@ -435,7 +435,7 @@ const ModuleBuilder = struct { switch (inst.opcode) { .OpName => { - const id: ResultId = @enumFromInt(inst.operands[0]); + const id: ResultId = @fromBackingInt(@intCast(inst.operands[0])); if (info.invocation_globals.contains(id)) { try self.global_names.put(self.arena, id, inst.operands[1..]); continue; @@ -443,12 +443,12 @@ const ModuleBuilder = struct { if (info.dead_initializers.contains(id)) continue; }, .OpExtInstImport => { - const set_id: ResultId = @enumFromInt(inst.operands[0]); + const set_id: ResultId = @fromBackingInt(@intCast(inst.operands[0])); const set = binary.ext_inst_map.get(set_id).?; if (set == .zig) continue; }, .OpExtInst => { - const set_id: ResultId = @enumFromInt(inst.operands[2]); + const set_id: ResultId = @fromBackingInt(@intCast(inst.operands[2])); const set_inst = inst.operands[3]; const set = binary.ext_inst_map.get(set_id).?; if (set == .zig and set_inst == 0) { @@ -456,11 +456,11 @@ const ModuleBuilder = struct { } }, .OpEntryPoint => { - const original_id: ResultId = @enumFromInt(inst.operands[1]); + const original_id: ResultId = @fromBackingInt(@intCast(inst.operands[1])); const fn_info = info.functions.get(original_id).?; if (fn_info.invocation_globals.count() > 0) { const new_id_index = info.entry_points.getIndex(original_id).?; - const new_id: ResultId = @enumFromInt(self.entry_point_new_id_base + new_id_index); + const new_id: ResultId = @fromBackingInt(@intCast(self.entry_point_new_id_base + new_id_index)); try self.section.emitRaw(self.arena, .OpEntryPoint, inst.operands.len); self.section.writeWord(inst.operands[0]); self.section.writeOperand(ResultId, new_id); @@ -471,11 +471,11 @@ const ModuleBuilder = struct { continue; }, .OpExecutionMode, .OpExecutionModeId => { - const original_id: ResultId = @enumFromInt(inst.operands[0]); + const original_id: ResultId = @fromBackingInt(@intCast(inst.operands[0])); const fn_info = info.functions.get(original_id).?; if (fn_info.invocation_globals.count() > 0) { const new_id_index = info.entry_points.getIndex(original_id).?; - const new_id: ResultId = @enumFromInt(self.entry_point_new_id_base + new_id_index); + const new_id: ResultId = @fromBackingInt(@intCast(self.entry_point_new_id_base + new_id_index)); try self.section.emitRaw(self.arena, inst.opcode, inst.operands.len); self.section.writeOperand(ResultId, new_id); self.section.writeWords(inst.operands[1..]); @@ -512,7 +512,7 @@ const ModuleBuilder = struct { const new_type = try self.internFunctionType(fn_info.return_type, new_param_types); try self.function_new_info.put(self.arena, func, .{ .new_function_type = new_type, - .global_id_base = @intFromEnum(self.allocIds(@intCast(invocation_global_count))), + .global_id_base = @backingInt(self.allocIds(@intCast(invocation_global_count))), }); } } @@ -583,20 +583,20 @@ const ModuleBuilder = struct { // Replace the result-ids with the global's new result-id if required. for (result_id_offsets.items) |off| { - const result_id: ResultId = @enumFromInt(operands.items[off]); + const result_id: ResultId = @fromBackingInt(@intCast(operands.items[off])); if (info.invocation_globals.contains(result_id)) { const func = maybe_current_function.?; const new_info = self.function_new_info.get(func).?; const fn_info = info.functions.get(func).?; const index = fn_info.invocation_globals.getIndex(result_id).?; - operands.items[off] = @intFromEnum(new_info.invocationGlobalId(index)); + operands.items[off] = @backingInt(new_info.invocationGlobalId(index)); } } switch (inst.opcode) { .OpFunction => { // Re-declare the function with the new parameters. - const func: ResultId = @enumFromInt(operands.items[1]); + const func: ResultId = @fromBackingInt(@intCast(operands.items[1])); if (info.dead_initializers.contains(func)) { skip_until_end = true; continue; @@ -628,7 +628,7 @@ const ModuleBuilder = struct { .OpFunctionCall => { // Add the required invocation globals to the function's new parameter list. const caller = maybe_current_function.?; - const callee: ResultId = @enumFromInt(operands.items[2]); + const callee: ResultId = @fromBackingInt(@intCast(operands.items[2])); const caller_info = info.functions.get(caller).?; const callee_info = info.functions.get(callee).?; const caller_new_info = self.function_new_info.get(caller).?; @@ -663,7 +663,7 @@ const ModuleBuilder = struct { for (info.entry_points.keys(), 0..) |func, entry_point_index| { const fn_info = info.functions.get(func).?; if (fn_info.invocation_globals.count() == 0) continue; - const ep_id: ResultId = @enumFromInt(self.entry_point_new_id_base + @as(u32, @intCast(entry_point_index))); + const ep_id: ResultId = @fromBackingInt(@intCast(self.entry_point_new_id_base + @as(u32, @intCast(entry_point_index)))); const fn_type = self.function_types.get(.{ .return_type = fn_info.return_type, .param_types = fn_info.param_types, @@ -677,9 +677,9 @@ const ModuleBuilder = struct { }); // Emit OpFunctionParameter instructions for the original kernel's parameters. - const params_id_base: u32 = @intFromEnum(self.allocIds(@intCast(fn_info.param_types.len))); + const params_id_base: u32 = @backingInt(self.allocIds(@intCast(fn_info.param_types.len))); for (fn_info.param_types, 0..) |param_type, i| { - const id: ResultId = @enumFromInt(params_id_base + @as(u32, @intCast(i))); + const id: ResultId = @fromBackingInt(@intCast(params_id_base + @as(u32, @intCast(i)))); try self.section.emit(arena, .OpFunctionParameter, .{ .id_result_type = param_type, .id_result = id, @@ -703,11 +703,11 @@ const ModuleBuilder = struct { } // Declare the IDs of the invocation globals. - const global_id_base: u32 = @intFromEnum(self.allocIds(@intCast(all_function_invocation_globals.count()))); + const global_id_base: u32 = @backingInt(self.allocIds(@intCast(all_function_invocation_globals.count()))); for (all_function_invocation_globals.keys(), 0..) |global, i| { const global_info = info.invocation_globals.get(global).?; - const id: ResultId = @enumFromInt(global_id_base + @as(u32, @intCast(i))); + const id: ResultId = @fromBackingInt(@intCast(global_id_base + @as(u32, @intCast(i)))); try self.section.emit(arena, .OpVariable, .{ .id_result_type = global_info.ty, .id_result = id, @@ -764,13 +764,13 @@ const ModuleBuilder = struct { // Add the invocation globals for (callee_info.invocation_globals.keys()) |global| { const index = all_globals.getIndex(global).?; - const id: ResultId = @enumFromInt(global_id_base + @as(u32, @intCast(index))); + const id: ResultId = @fromBackingInt(@intCast(global_id_base + @as(u32, @intCast(index)))); self.section.writeOperand(ResultId, id); } // Add the arguments for (0..callee_info.param_types.len) |index| { - const id: ResultId = @enumFromInt(params_id_base + @as(u32, @intCast(index))); + const id: ResultId = @fromBackingInt(@intCast(params_id_base + @as(u32, @intCast(index)))); self.section.writeOperand(ResultId, id); } } diff --git a/src/link/SpirV/prune_unused.zig b/src/link/SpirV/prune_unused.zig index 356da14952784938ade741ba08e5ed52fd859df3..2ca052152fdbb371e05a8d8fc5aac95fa8402f11 100644 --- a/src/link/SpirV/prune_unused.zig +++ b/src/link/SpirV/prune_unused.zig @@ -59,11 +59,11 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { while (it.next()) |inst| { if (inst.offset >= binary.functions_start) break; if (inst.opcode == .OpDecorate and inst.operands.len >= 2 and - inst.operands[1] == @intFromEnum(spec.Decoration.linkage_attributes)) + inst.operands[1] == @backingInt(spec.Decoration.linkage_attributes)) { // Last word after the string is the linkage type; Export = 0. - if (inst.operands[inst.operands.len - 1] == @intFromEnum(spec.LinkageType.@"export")) { - const target: ResultId = @enumFromInt(inst.operands[0]); + if (inst.operands[inst.operands.len - 1] == @backingInt(spec.LinkageType.@"export")) { + const target: ResultId = @fromBackingInt(@intCast(inst.operands[0])); if (id_to_index.get(target)) |index| { alive.set(index); } @@ -133,7 +133,7 @@ pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { } else { // annotation-style: emit only if the target id is alive if (inst.operands.len > 0) { - const target: ResultId = @enumFromInt(inst.operands[0]); + const target: ResultId = @fromBackingInt(@intCast(inst.operands[0])); if (id_to_index.get(target)) |idx| { if (!alive.isSet(idx)) continue; } else continue; @@ -199,14 +199,14 @@ fn markAlive( var i = start; while (i < end) : (i += 1) { const off = id_offset_buf.items[i]; - const id: ResultId = @enumFromInt(inst.operands[off]); + const id: ResultId = @fromBackingInt(@intCast(inst.operands[off])); const index = id_to_index.get(id) orelse continue; if (alive.isSet(index)) continue; alive.set(index); const offset = code_offsets.items[index]; const ref_inst = BinaryModule.Instruction{ - .opcode = @enumFromInt(binary.instructions[offset] & 0xFFFF), + .opcode = @fromBackingInt(@intCast(binary.instructions[offset] & 0xFFFF)), .offset = offset, .operands = blk: { const l = binary.instructions[offset] >> 16; @@ -231,7 +231,7 @@ fn markAlive( fn getResultId(inst: BinaryModule.Instruction, inst_spec: spec.Instruction) ?ResultId { for (0..@min(2, inst_spec.operands.len)) |i| { if (inst_spec.operands[i].kind == .id_result) { - if (i < inst.operands.len) return @enumFromInt(inst.operands[i]); + if (i < inst.operands.len) return @fromBackingInt(@intCast(inst.operands[i])); } } return null; diff --git a/src/link/Wasm.zig b/src/link/Wasm.zig index 40c3e412b4ac88c019cf6885e2d9e4bb1e2b329e..a1445d3b4fbe49d94f43cb88cab30a237f4cd7cc 100644 --- a/src/link/Wasm.zig +++ b/src/link/Wasm.zig @@ -332,7 +332,7 @@ pub const ObjectIndex = enum(u32) { _, pub fn ptr(index: ObjectIndex, wasm: *const Wasm) *Object { - return &wasm.objects.items[@intFromEnum(index)]; + return &wasm.objects.items[@backingInt(index)]; } }; @@ -341,7 +341,7 @@ pub const FunctionIndex = enum(u32) { _, pub fn ptr(index: FunctionIndex, wasm: *const Wasm) *FunctionImport.Resolution { - return &wasm.functions.keys()[@intFromEnum(index)]; + return &wasm.functions.keys()[@backingInt(index)]; } pub fn fromIpNav(wasm: *const Wasm, nav_index: InternPool.Nav.Index) ?FunctionIndex { @@ -349,7 +349,7 @@ pub const FunctionIndex = enum(u32) { } pub fn fromTagIndexType(wasm: *const Wasm, tag_type: InternPool.Index) ?FunctionIndex { - const zcu_func: ZcuFunc.Index = @enumFromInt(wasm.zcu_funcs.getIndex(tag_type) orelse return null); + const zcu_func: ZcuFunc.Index = @fromBackingInt(@intCast(wasm.zcu_funcs.getIndex(tag_type) orelse return null)); return fromResolution(wasm, .pack(wasm, .{ .zcu_func = zcu_func })); } @@ -364,7 +364,7 @@ pub const FunctionIndex = enum(u32) { pub fn fromResolution(wasm: *const Wasm, resolution: FunctionImport.Resolution) ?FunctionIndex { const i = wasm.functions.getIndex(resolution) orelse return null; - return @enumFromInt(i); + return @fromBackingInt(@intCast(i)); } }; @@ -386,7 +386,7 @@ pub const OutputFunctionIndex = enum(u32) { } pub fn fromFunctionIndex(wasm: *const Wasm, index: FunctionIndex) OutputFunctionIndex { - return @enumFromInt(wasm.flush_buffer.function_imports.entries.len + @intFromEnum(index)); + return @fromBackingInt(@intCast(wasm.flush_buffer.function_imports.entries.len + @backingInt(index))); } pub fn fromObjectFunction(wasm: *const Wasm, index: ObjectFunctionIndex) OutputFunctionIndex { @@ -428,7 +428,7 @@ pub const OutputFunctionIndex = enum(u32) { } pub fn fromSymbolName(wasm: *const Wasm, name: String) OutputFunctionIndex { - if (wasm.flush_buffer.function_imports.getIndex(name)) |i| return @enumFromInt(i); + if (wasm.flush_buffer.function_imports.getIndex(name)) |i| return @fromBackingInt(@intCast(i)); return fromFunctionIndex(wasm, FunctionIndex.fromSymbolName(wasm, name) orelse { if (std.debug.runtime_safety) { std.debug.panic("function index for symbol not found: {s}", .{name.slice(wasm)}); @@ -442,7 +442,7 @@ pub const GlobalIndex = enum(u32) { _, /// This is only accurate when not emitting an object and there is a Zcu. - pub const stack_pointer: GlobalIndex = @enumFromInt(0); + pub const stack_pointer: GlobalIndex = @fromBackingInt(@intCast(0)); /// Same as `stack_pointer` but with a safety assertion. pub fn stackPointer(wasm: *const Wasm) ObjectGlobal.Index { @@ -453,16 +453,16 @@ pub const GlobalIndex = enum(u32) { } pub fn ptr(index: GlobalIndex, f: *const Flush) *Wasm.GlobalImport.Resolution { - return &f.globals.items[@intFromEnum(index)]; + return &f.globals.items[@backingInt(index)]; } pub fn fromIpNav(wasm: *const Wasm, nav_index: InternPool.Nav.Index) ?GlobalIndex { const i = wasm.globals.getIndex(.fromIpNav(wasm, nav_index)) orelse return null; - return @enumFromInt(i); + return @fromBackingInt(@intCast(i)); } pub fn fromObjectGlobal(wasm: *const Wasm, i: ObjectGlobalIndex) GlobalIndex { - return @enumFromInt(wasm.globals.getIndex(.fromObjectGlobal(wasm, i)).?); + return @fromBackingInt(@intCast(wasm.globals.getIndex(.fromObjectGlobal(wasm, i)).?)); } pub fn fromObjectGlobalHandlingWeak(wasm: *const Wasm, index: ObjectGlobalIndex) GlobalIndex { @@ -475,7 +475,7 @@ pub const GlobalIndex = enum(u32) { pub fn fromSymbolName(wasm: *const Wasm, name: String) GlobalIndex { const import = wasm.object_global_imports.getPtr(name).?; - return @enumFromInt(wasm.globals.getIndex(import.resolution).?); + return @fromBackingInt(@intCast(wasm.globals.getIndex(import.resolution).?)); } }; @@ -484,16 +484,16 @@ pub const TableIndex = enum(u32) { _, pub fn ptr(index: TableIndex, f: *const Flush) *Wasm.TableImport.Resolution { - return &f.tables.items[@intFromEnum(index)]; + return &f.tables.items[@backingInt(index)]; } pub fn fromObjectTable(wasm: *const Wasm, i: ObjectTableIndex) TableIndex { - return @enumFromInt(wasm.tables.getIndex(.fromObjectTable(i)).?); + return @fromBackingInt(@intCast(wasm.tables.getIndex(.fromObjectTable(i)).?)); } pub fn fromSymbolName(wasm: *const Wasm, name: String) TableIndex { const import = wasm.object_table_imports.getPtr(name).?; - return @enumFromInt(wasm.tables.getIndex(import.resolution).?); + return @fromBackingInt(@intCast(wasm.tables.getIndex(import.resolution).?)); } }; @@ -524,7 +524,7 @@ pub const SourceLocation = enum(u32) { return switch (unpacked) { .zig_object_nofile => .zig_object_nofile, .none => .none, - .object_index => |object_index| @enumFromInt(@intFromEnum(object_index)), + .object_index => |object_index| @fromBackingInt(@intCast(@backingInt(object_index))), .source_location_index => @panic("TODO"), }; } @@ -534,8 +534,8 @@ pub const SourceLocation = enum(u32) { .zig_object_nofile => .zig_object_nofile, .none => .none, _ => { - const i = @intFromEnum(sl); - if (i < wasm.objects.items.len) return .{ .object_index = @enumFromInt(i) }; + const i = @backingInt(sl); + if (i < wasm.objects.items.len) return .{ .object_index = @fromBackingInt(@intCast(i)) }; const sl_index = i - wasm.objects.items.len; _ = sl_index; @panic("TODO"); @@ -748,11 +748,11 @@ pub const NavsObjIndex = enum(u32) { _, pub fn key(i: @This(), wasm: *const Wasm) *InternPool.Nav.Index { - return &wasm.navs_obj.keys()[@intFromEnum(i)]; + return &wasm.navs_obj.keys()[@backingInt(i)]; } pub fn value(i: @This(), wasm: *const Wasm) *ZcuDataObj { - return &wasm.navs_obj.values()[@intFromEnum(i)]; + return &wasm.navs_obj.values()[@backingInt(i)]; } pub fn name(i: @This(), wasm: *const Wasm) [:0]const u8 { @@ -768,11 +768,11 @@ pub const NavsExeIndex = enum(u32) { _, pub fn key(i: @This(), wasm: *const Wasm) *InternPool.Nav.Index { - return &wasm.navs_exe.keys()[@intFromEnum(i)]; + return &wasm.navs_exe.keys()[@backingInt(i)]; } pub fn value(i: @This(), wasm: *const Wasm) *ZcuDataExe { - return &wasm.navs_exe.values()[@intFromEnum(i)]; + return &wasm.navs_exe.values()[@backingInt(i)]; } pub fn name(i: @This(), wasm: *const Wasm) [:0]const u8 { @@ -788,11 +788,11 @@ pub const UavsObjIndex = enum(u32) { _, pub fn key(i: @This(), wasm: *const Wasm) *InternPool.Index { - return &wasm.uavs_obj.keys()[@intFromEnum(i)]; + return &wasm.uavs_obj.keys()[@backingInt(i)]; } pub fn value(i: @This(), wasm: *const Wasm) *ZcuDataObj { - return &wasm.uavs_obj.values()[@intFromEnum(i)]; + return &wasm.uavs_obj.values()[@backingInt(i)]; } }; @@ -801,11 +801,11 @@ pub const UavsExeIndex = enum(u32) { _, pub fn key(i: @This(), wasm: *const Wasm) *InternPool.Index { - return &wasm.uavs_exe.keys()[@intFromEnum(i)]; + return &wasm.uavs_exe.keys()[@backingInt(i)]; } pub fn value(i: @This(), wasm: *const Wasm) *ZcuDataExe { - return &wasm.uavs_exe.values()[@intFromEnum(i)]; + return &wasm.uavs_exe.values()[@backingInt(i)]; } }; @@ -899,11 +899,11 @@ pub const ZcuFunc = union { _, pub fn key(i: @This(), wasm: *const Wasm) *InternPool.Index { - return &wasm.zcu_funcs.keys()[@intFromEnum(i)]; + return &wasm.zcu_funcs.keys()[@backingInt(i)]; } pub fn value(i: @This(), wasm: *const Wasm) *ZcuFunc { - return &wasm.zcu_funcs.values()[@intFromEnum(i)]; + return &wasm.zcu_funcs.values()[@backingInt(i)]; } pub fn name(i: @This(), wasm: *const Wasm) [:0]const u8 { @@ -972,7 +972,7 @@ pub const FunctionImport = extern struct { // Next, index into `zcu_funcs`. _, - const first_object_function = @intFromEnum(Resolution.__wasm_init_tls) + 1; + const first_object_function = @backingInt(Resolution.__wasm_init_tls) + 1; pub const Unpacked = union(enum) { unresolved, @@ -992,14 +992,14 @@ pub const FunctionImport = extern struct { .__wasm_init_memory => .__wasm_init_memory, .__wasm_init_tls => .__wasm_init_tls, _ => { - const object_function_index = @intFromEnum(r) - first_object_function; + const object_function_index = @backingInt(r) - first_object_function; const zcu_func_index = if (object_function_index < wasm.object_functions.items.len) - return .{ .object_function = @enumFromInt(object_function_index) } + return .{ .object_function = @fromBackingInt(@intCast(object_function_index)) } else object_function_index - wasm.object_functions.items.len; - return .{ .zcu_func = @enumFromInt(zcu_func_index) }; + return .{ .zcu_func = @fromBackingInt(@intCast(zcu_func_index)) }; }, }; } @@ -1011,8 +1011,8 @@ pub const FunctionImport = extern struct { .__wasm_call_ctors => .__wasm_call_ctors, .__wasm_init_memory => .__wasm_init_memory, .__wasm_init_tls => .__wasm_init_tls, - .object_function => |i| @enumFromInt(first_object_function + @intFromEnum(i)), - .zcu_func => |i| @enumFromInt(first_object_function + wasm.object_functions.items.len + @intFromEnum(i)), + .object_function => |i| @fromBackingInt(@intCast(first_object_function + @backingInt(i))), + .zcu_func => |i| @fromBackingInt(@intCast(first_object_function + wasm.object_functions.items.len + @backingInt(i))), }; } @@ -1027,7 +1027,7 @@ pub const FunctionImport = extern struct { } pub fn fromIpIndex(wasm: *const Wasm, ip_index: InternPool.Index) Resolution { - return fromZcuFunc(wasm, @enumFromInt(wasm.zcu_funcs.getIndex(ip_index).?)); + return fromZcuFunc(wasm, @fromBackingInt(@intCast(wasm.zcu_funcs.getIndex(ip_index).?))); } pub fn fromObjectFunction(wasm: *const Wasm, object_function: ObjectFunctionIndex) Resolution { @@ -1072,11 +1072,11 @@ pub const FunctionImport = extern struct { _, pub fn key(index: Index, wasm: *const Wasm) *String { - return &wasm.object_function_imports.keys()[@intFromEnum(index)]; + return &wasm.object_function_imports.keys()[@backingInt(index)]; } pub fn value(index: Index, wasm: *const Wasm) *FunctionImport { - return &wasm.object_function_imports.values()[@intFromEnum(index)]; + return &wasm.object_function_imports.values()[@backingInt(index)]; } pub fn symbolName(index: Index, wasm: *const Wasm) String { @@ -1139,7 +1139,7 @@ pub const GlobalImport = extern struct { // Next, index into `navs_obj` or `navs_exe` depending on whether emitting an object. _, - const first_object_global = @intFromEnum(Resolution.__tls_size) + 1; + const first_object_global = @backingInt(Resolution.__tls_size) + 1; pub const Unpacked = union(enum) { unresolved, @@ -1164,17 +1164,17 @@ pub const GlobalImport = extern struct { .__tls_base => .__tls_base, .__tls_size => .__tls_size, _ => { - const i: u32 = @intFromEnum(r); + const i: u32 = @backingInt(r); const object_global_index = i - first_object_global; if (object_global_index < wasm.object_globals.items.len) - return .{ .object_global = @enumFromInt(object_global_index) }; + return .{ .object_global = @fromBackingInt(@intCast(object_global_index)) }; const comp = wasm.base.comp; const is_obj = comp.config.output_mode == .Obj; const nav_index = object_global_index - wasm.object_globals.items.len; return if (is_obj) .{ - .nav_obj = @enumFromInt(nav_index), + .nav_obj = @fromBackingInt(@intCast(nav_index)), } else .{ - .nav_exe = @enumFromInt(nav_index), + .nav_exe = @fromBackingInt(@intCast(nav_index)), }; }, }; @@ -1189,9 +1189,9 @@ pub const GlobalImport = extern struct { .__tls_align => .__tls_align, .__tls_base => .__tls_base, .__tls_size => .__tls_size, - .object_global => |i| @enumFromInt(first_object_global + @intFromEnum(i)), - .nav_obj => |i| @enumFromInt(first_object_global + wasm.object_globals.items.len + @intFromEnum(i)), - .nav_exe => |i| @enumFromInt(first_object_global + wasm.object_globals.items.len + @intFromEnum(i)), + .object_global => |i| @fromBackingInt(@intCast(first_object_global + @backingInt(i))), + .nav_obj => |i| @fromBackingInt(@intCast(first_object_global + wasm.object_globals.items.len + @backingInt(i))), + .nav_exe => |i| @fromBackingInt(@intCast(first_object_global + wasm.object_globals.items.len + @backingInt(i))), }; } @@ -1199,9 +1199,9 @@ pub const GlobalImport = extern struct { const comp = wasm.base.comp; const is_obj = comp.config.output_mode == .Obj; return pack(wasm, if (is_obj) .{ - .nav_obj = @enumFromInt(wasm.navs_obj.getIndex(ip_nav).?), + .nav_obj = @fromBackingInt(@intCast(wasm.navs_obj.getIndex(ip_nav).?)), } else .{ - .nav_exe = @enumFromInt(wasm.navs_exe.getIndex(ip_nav).?), + .nav_exe = @fromBackingInt(@intCast(wasm.navs_exe.getIndex(ip_nav).?)), }); } @@ -1230,11 +1230,11 @@ pub const GlobalImport = extern struct { _, pub fn key(index: Index, wasm: *const Wasm) *String { - return &wasm.object_global_imports.keys()[@intFromEnum(index)]; + return &wasm.object_global_imports.keys()[@backingInt(index)]; } pub fn value(index: Index, wasm: *const Wasm) *GlobalImport { - return &wasm.object_global_imports.values()[@intFromEnum(index)]; + return &wasm.object_global_imports.values()[@backingInt(index)]; } pub fn symbolName(index: Index, wasm: *const Wasm) String { @@ -1321,7 +1321,7 @@ pub const TableImport = extern struct { // Next, index into `object_tables`. _, - const first_object_table = @intFromEnum(Resolution.__indirect_function_table) + 1; + const first_object_table = @backingInt(Resolution.__indirect_function_table) + 1; pub const Unpacked = union(enum) { unresolved, @@ -1333,7 +1333,7 @@ pub const TableImport = extern struct { return switch (r) { .unresolved => .unresolved, .__indirect_function_table => .__indirect_function_table, - _ => .{ .object_table = @enumFromInt(@intFromEnum(r) - first_object_table) }, + _ => .{ .object_table = @fromBackingInt(@intCast(@backingInt(r) - first_object_table)) }, }; } @@ -1341,7 +1341,7 @@ pub const TableImport = extern struct { return switch (unpacked) { .unresolved => .unresolved, .__indirect_function_table => .__indirect_function_table, - .object_table => |i| @enumFromInt(first_object_table + @intFromEnum(i)), + .object_table => |i| @fromBackingInt(@intCast(first_object_table + @backingInt(i))), }; } @@ -1375,11 +1375,11 @@ pub const TableImport = extern struct { _, pub fn key(index: Index, wasm: *const Wasm) *String { - return &wasm.object_table_imports.keys()[@intFromEnum(index)]; + return &wasm.object_table_imports.keys()[@backingInt(index)]; } pub fn value(index: Index, wasm: *const Wasm) *TableImport { - return &wasm.object_table_imports.values()[@intFromEnum(index)]; + return &wasm.object_table_imports.values()[@backingInt(index)]; } pub fn name(index: Index, wasm: *const Wasm) String { @@ -1434,7 +1434,7 @@ pub const ObjectTableIndex = enum(u32) { _, pub fn ptr(index: ObjectTableIndex, wasm: *const Wasm) *Table { - return &wasm.object_tables.items[@intFromEnum(index)]; + return &wasm.object_tables.items[@backingInt(index)]; } pub fn chaseWeak(i: ObjectTableIndex, wasm: *const Wasm) ObjectTableIndex { @@ -1452,7 +1452,7 @@ pub const ObjectGlobalIndex = enum(u32) { _, pub fn ptr(index: ObjectGlobalIndex, wasm: *const Wasm) *ObjectGlobal { - return &wasm.object_globals.items[@intFromEnum(index)]; + return &wasm.object_globals.items[@backingInt(index)]; } pub fn name(index: ObjectGlobalIndex, wasm: *const Wasm) OptionalString { @@ -1480,7 +1480,7 @@ pub const ObjectMemory = extern struct { _, pub fn ptr(index: Index, wasm: *const Wasm) *ObjectMemory { - return &wasm.object_memories.items[@intFromEnum(index)]; + return &wasm.object_memories.items[@backingInt(index)]; } }; @@ -1501,11 +1501,11 @@ pub const ObjectFunctionIndex = enum(u32) { _, pub fn ptr(index: ObjectFunctionIndex, wasm: *const Wasm) *ObjectFunction { - return &wasm.object_functions.items[@intFromEnum(index)]; + return &wasm.object_functions.items[@backingInt(index)]; } pub fn toOptional(i: ObjectFunctionIndex) OptionalObjectFunctionIndex { - const result: OptionalObjectFunctionIndex = @enumFromInt(@intFromEnum(i)); + const result: OptionalObjectFunctionIndex = @fromBackingInt(@intCast(@backingInt(i))); assert(result != .none); return result; } @@ -1527,7 +1527,7 @@ pub const OptionalObjectFunctionIndex = enum(u32) { pub fn unwrap(i: OptionalObjectFunctionIndex) ?ObjectFunctionIndex { if (i == .none) return null; - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } }; @@ -1562,7 +1562,7 @@ pub const ObjectDataSegment = extern struct { _, pub fn ptr(i: Index, wasm: *const Wasm) *ObjectDataSegment { - return &wasm.object_data_segments.items[@intFromEnum(i)]; + return &wasm.object_data_segments.items[@backingInt(i)]; } }; @@ -1588,7 +1588,7 @@ pub const ObjectData = extern struct { _, pub fn ptr(i: Index, wasm: *const Wasm) *ObjectData { - return &wasm.object_datas.items[@intFromEnum(i)]; + return &wasm.object_datas.items[@backingInt(i)]; } }; }; @@ -1609,7 +1609,7 @@ pub const ObjectDataImport = extern struct { /// Next, index into `navs_obj` or `navs_exe` depending on whether emitting an object. _, - const first_object = @intFromEnum(Resolution.__heap_end) + 1; + const first_object = @backingInt(Resolution.__heap_end) + 1; pub const Unpacked = union(enum) { unresolved, @@ -1632,10 +1632,10 @@ pub const ObjectDataImport = extern struct { .__heap_base => .__heap_base, .__heap_end => .__heap_end, _ => { - const object_index = @intFromEnum(r) - first_object; + const object_index = @backingInt(r) - first_object; const uav_index = if (object_index < wasm.object_datas.items.len) - return .{ .object = @enumFromInt(object_index) } + return .{ .object = @fromBackingInt(@intCast(object_index)) } else object_index - wasm.object_datas.items.len; @@ -1643,18 +1643,18 @@ pub const ObjectDataImport = extern struct { const is_obj = comp.config.output_mode == .Obj; if (is_obj) { const nav_index = if (uav_index < wasm.uavs_obj.entries.len) - return .{ .uav_obj = @enumFromInt(uav_index) } + return .{ .uav_obj = @fromBackingInt(@intCast(uav_index)) } else uav_index - wasm.uavs_obj.entries.len; - return .{ .nav_obj = @enumFromInt(nav_index) }; + return .{ .nav_obj = @fromBackingInt(@intCast(nav_index)) }; } else { const nav_index = if (uav_index < wasm.uavs_exe.entries.len) - return .{ .uav_exe = @enumFromInt(uav_index) } + return .{ .uav_exe = @fromBackingInt(@intCast(uav_index)) } else uav_index - wasm.uavs_exe.entries.len; - return .{ .nav_exe = @enumFromInt(nav_index) }; + return .{ .nav_exe = @fromBackingInt(@intCast(nav_index)) }; } }, }; @@ -1667,10 +1667,10 @@ pub const ObjectDataImport = extern struct { .__zig_error_name_table => .__zig_error_name_table, .__heap_base => .__heap_base, .__heap_end => .__heap_end, - .object => |i| @enumFromInt(first_object + @intFromEnum(i)), - inline .uav_exe, .uav_obj => |i| @enumFromInt(first_object + wasm.object_datas.items.len + @intFromEnum(i)), - .nav_exe => |i| @enumFromInt(first_object + wasm.object_datas.items.len + wasm.uavs_exe.entries.len + @intFromEnum(i)), - .nav_obj => |i| @enumFromInt(first_object + wasm.object_datas.items.len + wasm.uavs_obj.entries.len + @intFromEnum(i)), + .object => |i| @fromBackingInt(@intCast(first_object + @backingInt(i))), + inline .uav_exe, .uav_obj => |i| @fromBackingInt(@intCast(first_object + wasm.object_datas.items.len + @backingInt(i))), + .nav_exe => |i| @fromBackingInt(@intCast(first_object + wasm.object_datas.items.len + wasm.uavs_exe.entries.len + @backingInt(i))), + .nav_obj => |i| @fromBackingInt(@intCast(first_object + wasm.object_datas.items.len + wasm.uavs_obj.entries.len + @backingInt(i))), }; } @@ -1721,11 +1721,11 @@ pub const ObjectDataImport = extern struct { _, pub fn value(i: @This(), wasm: *const Wasm) *ObjectDataImport { - return &wasm.object_data_imports.values()[@intFromEnum(i)]; + return &wasm.object_data_imports.values()[@backingInt(i)]; } pub fn fromSymbolName(wasm: *const Wasm, name: String) ?Index { - return @enumFromInt(wasm.object_data_imports.getIndex(name) orelse return null); + return @fromBackingInt(@intCast(wasm.object_data_imports.getIndex(name) orelse return null)); } }; }; @@ -1742,7 +1742,7 @@ pub const DataPayload = extern struct { _, pub fn unwrap(off: Off) ?u32 { - return if (off == .none) null else @intFromEnum(off); + return if (off == .none) null else @backingInt(off); } }; @@ -1769,7 +1769,7 @@ pub const DataSegmentId = enum(u32) { /// Next, index into `navs_obj` or `navs_exe` depending on whether emitting an object. _, - const first_object = @intFromEnum(DataSegmentId.__heap_end) + 1; + const first_object = @backingInt(DataSegmentId.__heap_end) + 1; pub const Category = enum { /// Thread-local variables. @@ -1803,10 +1803,10 @@ pub const DataSegmentId = enum(u32) { .__zig_tag_name_table => .__zig_tag_name_table, .__heap_base => .__heap_base, .__heap_end => .__heap_end, - .object => |i| @enumFromInt(first_object + @intFromEnum(i)), - inline .uav_exe, .uav_obj => |i| @enumFromInt(first_object + wasm.object_data_segments.items.len + @intFromEnum(i)), - .nav_exe => |i| @enumFromInt(first_object + wasm.object_data_segments.items.len + wasm.uavs_exe.entries.len + @intFromEnum(i)), - .nav_obj => |i| @enumFromInt(first_object + wasm.object_data_segments.items.len + wasm.uavs_obj.entries.len + @intFromEnum(i)), + .object => |i| @fromBackingInt(@intCast(first_object + @backingInt(i))), + inline .uav_exe, .uav_obj => |i| @fromBackingInt(@intCast(first_object + wasm.object_data_segments.items.len + @backingInt(i))), + .nav_exe => |i| @fromBackingInt(@intCast(first_object + wasm.object_data_segments.items.len + wasm.uavs_exe.entries.len + @backingInt(i))), + .nav_obj => |i| @fromBackingInt(@intCast(first_object + wasm.object_data_segments.items.len + wasm.uavs_obj.entries.len + @backingInt(i))), }; } @@ -1819,10 +1819,10 @@ pub const DataSegmentId = enum(u32) { .__heap_base => .__heap_base, .__heap_end => .__heap_end, _ => { - const object_index = @intFromEnum(id) - first_object; + const object_index = @backingInt(id) - first_object; const uav_index = if (object_index < wasm.object_data_segments.items.len) - return .{ .object = @enumFromInt(object_index) } + return .{ .object = @fromBackingInt(@intCast(object_index)) } else object_index - wasm.object_data_segments.items.len; @@ -1830,18 +1830,18 @@ pub const DataSegmentId = enum(u32) { const is_obj = comp.config.output_mode == .Obj; if (is_obj) { const nav_index = if (uav_index < wasm.uavs_obj.entries.len) - return .{ .uav_obj = @enumFromInt(uav_index) } + return .{ .uav_obj = @fromBackingInt(@intCast(uav_index)) } else uav_index - wasm.uavs_obj.entries.len; - return .{ .nav_obj = @enumFromInt(nav_index) }; + return .{ .nav_obj = @fromBackingInt(@intCast(nav_index)) }; } else { const nav_index = if (uav_index < wasm.uavs_exe.entries.len) - return .{ .uav_exe = @enumFromInt(uav_index) } + return .{ .uav_exe = @fromBackingInt(@intCast(uav_index)) } else uav_index - wasm.uavs_exe.entries.len; - return .{ .nav_exe = @enumFromInt(nav_index) }; + return .{ .nav_exe = @fromBackingInt(@intCast(nav_index)) }; } }, }; @@ -1851,9 +1851,9 @@ pub const DataSegmentId = enum(u32) { const comp = wasm.base.comp; const is_obj = comp.config.output_mode == .Obj; return pack(wasm, if (is_obj) .{ - .nav_obj = @enumFromInt(wasm.navs_obj.getIndex(nav_index).?), + .nav_obj = @fromBackingInt(@intCast(wasm.navs_obj.getIndex(nav_index).?)), } else .{ - .nav_exe = @enumFromInt(wasm.navs_exe.getIndex(nav_index).?), + .nav_exe = @fromBackingInt(@intCast(wasm.navs_exe.getIndex(nav_index).?)), }); } @@ -2086,10 +2086,10 @@ pub const CustomSegment = extern struct { pub const Expr = enum(u32) { _, - pub const end = @intFromEnum(std.wasm.Opcode.end); + pub const end = @backingInt(std.wasm.Opcode.end); pub fn slice(index: Expr, wasm: *const Wasm) [:end]const u8 { - const start_slice = wasm.string_bytes.items[@intFromEnum(index)..]; + const start_slice = wasm.string_bytes.items[@backingInt(index)..]; const end_pos = Object.exprEndPos(start_slice, 0) catch |err| switch (err) { error.InvalidInitOpcode => unreachable, }; @@ -2106,7 +2106,7 @@ pub const FunctionType = extern struct { _, pub fn ptr(i: Index, wasm: *const Wasm) *FunctionType { - return &wasm.func_types.keys()[@intFromEnum(i)]; + return &wasm.func_types.keys()[@backingInt(i)]; } pub fn fmt(i: Index, wasm: *const Wasm) Formatter { @@ -2197,7 +2197,7 @@ pub const String = enum(u32) { } pub fn hash(ctx: @This(), key: String) u64 { - return std.hash_map.hashString(mem.sliceTo(ctx.bytes[@intFromEnum(key)..], 0)); + return std.hash_map.hashString(mem.sliceTo(ctx.bytes[@backingInt(key)..], 0)); } }; @@ -2205,7 +2205,7 @@ pub const String = enum(u32) { bytes: []const u8, pub fn eql(ctx: @This(), a: []const u8, b: String) bool { - return mem.eql(u8, a, mem.sliceTo(ctx.bytes[@intFromEnum(b)..], 0)); + return mem.eql(u8, a, mem.sliceTo(ctx.bytes[@backingInt(b)..], 0)); } pub fn hash(_: @This(), adapted_key: []const u8) u64 { @@ -2215,12 +2215,12 @@ pub const String = enum(u32) { }; pub fn slice(index: String, wasm: *const Wasm) [:0]const u8 { - const start_slice = wasm.string_bytes.items[@intFromEnum(index)..]; + const start_slice = wasm.string_bytes.items[@backingInt(index)..]; return start_slice[0..mem.indexOfScalar(u8, start_slice, 0).? :0]; } pub fn toOptional(i: String) OptionalString { - const result: OptionalString = @enumFromInt(@intFromEnum(i)); + const result: OptionalString = @fromBackingInt(@intCast(@backingInt(i))); assert(result != .none); return result; } @@ -2232,7 +2232,7 @@ pub const OptionalString = enum(u32) { pub fn unwrap(i: OptionalString) ?String { if (i == .none) return null; - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } pub fn slice(index: OptionalString, wasm: *const Wasm) ?[:0]const u8 { @@ -2246,11 +2246,11 @@ pub const ValtypeList = enum(u32) { _, pub fn fromString(s: String) ValtypeList { - return @enumFromInt(@intFromEnum(s)); + return @fromBackingInt(@intCast(@backingInt(s))); } pub fn slice(index: ValtypeList, wasm: *const Wasm) []const std.wasm.Valtype { - return @ptrCast(String.slice(@enumFromInt(@intFromEnum(index)), wasm)); + return @ptrCast(String.slice(@fromBackingInt(@intCast(@backingInt(index))), wasm)); } }; @@ -2259,7 +2259,7 @@ pub const ZcuImportIndex = enum(u32) { _, pub fn ptr(index: ZcuImportIndex, wasm: *const Wasm) *InternPool.Nav.Index { - return &wasm.imports.keys()[@intFromEnum(index)]; + return &wasm.imports.keys()[@backingInt(index)]; } pub fn importName(index: ZcuImportIndex, wasm: *const Wasm) String { @@ -2310,16 +2310,16 @@ pub const FunctionImportId = enum(u32) { pub fn pack(unpacked: Unpacked, wasm: *const Wasm) FunctionImportId { return switch (unpacked) { - .object_function_import => |i| @enumFromInt(@intFromEnum(i)), - .zcu_import => |i| @enumFromInt(@intFromEnum(i) + wasm.object_function_imports.entries.len), + .object_function_import => |i| @fromBackingInt(@intCast(@backingInt(i))), + .zcu_import => |i| @fromBackingInt(@intCast(@backingInt(i) + wasm.object_function_imports.entries.len)), }; } pub fn unpack(id: FunctionImportId, wasm: *const Wasm) Unpacked { - const i = @intFromEnum(id); - if (i < wasm.object_function_imports.entries.len) return .{ .object_function_import = @enumFromInt(i) }; + const i = @backingInt(id); + if (i < wasm.object_function_imports.entries.len) return .{ .object_function_import = @fromBackingInt(@intCast(i)) }; const zcu_import_i = i - wasm.object_function_imports.entries.len; - return .{ .zcu_import = @enumFromInt(zcu_import_i) }; + return .{ .zcu_import = @fromBackingInt(@intCast(zcu_import_i)) }; } pub fn fromObject(function_import_index: FunctionImport.Index, wasm: *const Wasm) FunctionImportId { @@ -2337,10 +2337,10 @@ pub const FunctionImportId = enum(u32) { .object_function_import => |obj_func_index| { // TODO binary search for (wasm.objects.items, 0..) |o, i| { - if (o.function_imports.off <= @intFromEnum(obj_func_index) and - o.function_imports.off + o.function_imports.len > @intFromEnum(obj_func_index)) + if (o.function_imports.off <= @backingInt(obj_func_index) and + o.function_imports.off + o.function_imports.len > @backingInt(obj_func_index)) { - return .pack(.{ .object_index = @enumFromInt(i) }, wasm); + return .pack(.{ .object_index = @fromBackingInt(@intCast(i)) }, wasm); } } else unreachable; }, @@ -2397,16 +2397,16 @@ pub const GlobalImportId = enum(u32) { pub fn pack(unpacked: Unpacked, wasm: *const Wasm) GlobalImportId { return switch (unpacked) { - .object_global_import => |i| @enumFromInt(@intFromEnum(i)), - .zcu_import => |i| @enumFromInt(@intFromEnum(i) + wasm.object_global_imports.entries.len), + .object_global_import => |i| @fromBackingInt(@intCast(@backingInt(i))), + .zcu_import => |i| @fromBackingInt(@intCast(@backingInt(i) + wasm.object_global_imports.entries.len)), }; } pub fn unpack(id: GlobalImportId, wasm: *const Wasm) Unpacked { - const i = @intFromEnum(id); - if (i < wasm.object_global_imports.entries.len) return .{ .object_global_import = @enumFromInt(i) }; + const i = @backingInt(id); + if (i < wasm.object_global_imports.entries.len) return .{ .object_global_import = @fromBackingInt(@intCast(i)) }; const zcu_import_i = i - wasm.object_global_imports.entries.len; - return .{ .zcu_import = @enumFromInt(zcu_import_i) }; + return .{ .zcu_import = @fromBackingInt(@intCast(zcu_import_i)) }; } pub fn fromObject(object_global_import: GlobalImport.Index, wasm: *const Wasm) GlobalImportId { @@ -2420,10 +2420,10 @@ pub const GlobalImportId = enum(u32) { .object_global_import => |obj_global_index| { // TODO binary search for (wasm.objects.items, 0..) |o, i| { - if (o.global_imports.off <= @intFromEnum(obj_global_index) and - o.global_imports.off + o.global_imports.len > @intFromEnum(obj_global_index)) + if (o.global_imports.off <= @backingInt(obj_global_index) and + o.global_imports.off + o.global_imports.len > @backingInt(obj_global_index)) { - return .pack(.{ .object_index = @enumFromInt(i) }, wasm); + return .pack(.{ .object_index = @fromBackingInt(@intCast(i)) }, wasm); } } else unreachable; }, @@ -2462,16 +2462,16 @@ pub const DataImportId = enum(u32) { pub fn pack(unpacked: Unpacked, wasm: *const Wasm) DataImportId { return switch (unpacked) { - .object_data_import => |i| @enumFromInt(@intFromEnum(i)), - .zcu_import => |i| @enumFromInt(@intFromEnum(i) + wasm.object_data_imports.entries.len), + .object_data_import => |i| @fromBackingInt(@intCast(@backingInt(i))), + .zcu_import => |i| @fromBackingInt(@intCast(@backingInt(i) + wasm.object_data_imports.entries.len)), }; } pub fn unpack(id: DataImportId, wasm: *const Wasm) Unpacked { - const i = @intFromEnum(id); - if (i < wasm.object_data_imports.entries.len) return .{ .object_data_import = @enumFromInt(i) }; + const i = @backingInt(id); + if (i < wasm.object_data_imports.entries.len) return .{ .object_data_import = @fromBackingInt(@intCast(i)) }; const zcu_import_i = i - wasm.object_data_imports.entries.len; - return .{ .zcu_import = @enumFromInt(zcu_import_i) }; + return .{ .zcu_import = @fromBackingInt(@intCast(zcu_import_i)) }; } pub fn fromZcuImport(zcu_import: ZcuImportIndex, wasm: *const Wasm) DataImportId { @@ -2487,10 +2487,10 @@ pub const DataImportId = enum(u32) { .object_data_import => |obj_data_index| { // TODO binary search for (wasm.objects.items, 0..) |o, i| { - if (o.data_imports.off <= @intFromEnum(obj_data_index) and - o.data_imports.off + o.data_imports.len > @intFromEnum(obj_data_index)) + if (o.data_imports.off <= @backingInt(obj_data_index) and + o.data_imports.off + o.data_imports.len > @backingInt(obj_data_index)) { - return .pack(.{ .object_index = @enumFromInt(i) }, wasm); + return .pack(.{ .object_index = @fromBackingInt(@intCast(i)) }, wasm); } } else unreachable; }, @@ -2504,7 +2504,7 @@ pub const SymbolTableIndex = enum(u32) { _, pub fn key(i: @This(), wasm: *const Wasm) *String { - return &wasm.symbol_table.keys()[@intFromEnum(i)]; + return &wasm.symbol_table.keys()[@backingInt(i)]; } }; @@ -2755,7 +2755,7 @@ pub const InitFunc = extern struct { pub fn lessThan(ctx: void, lhs: InitFunc, rhs: InitFunc) bool { _ = ctx; if (lhs.priority == rhs.priority) { - return @intFromEnum(lhs.function_index) < @intFromEnum(rhs.function_index); + return @backingInt(lhs.function_index) < @backingInt(rhs.function_index); } else { return lhs.priority < rhs.priority; } @@ -2805,11 +2805,11 @@ pub const Feature = packed struct(u8) { _, pub fn fromString(s: String) Set { - return @enumFromInt(@intFromEnum(s)); + return @fromBackingInt(@intCast(@backingInt(s))); } pub fn string(s: Set) String { - return @enumFromInt(@intFromEnum(s)); + return @fromBackingInt(@intCast(@backingInt(s))); } pub fn slice(s: Set, wasm: *const Wasm) [:sentinel]const Feature { @@ -3246,7 +3246,7 @@ pub fn updateFunc( .locals_len = @intCast(mir.locals.len), .prologue = mir.prologue, } }); - wasm.functions.putAssumeCapacity(.pack(wasm, .{ .zcu_func = @enumFromInt(wasm.zcu_funcs.entries.len - 1) }), {}); + wasm.functions.putAssumeCapacity(.pack(wasm, .{ .zcu_func = @fromBackingInt(@intCast(wasm.zcu_funcs.entries.len - 1)) }), {}); } // Generate code for the "Nav", storing it in memory to be later written to @@ -3335,7 +3335,7 @@ pub fn deleteExport( const export_name = wasm.getExistingString(name_slice).?; switch (exported) { .nav => |nav_index| { - log.debug("deleteExport '{s}' nav={d}", .{ name_slice, @intFromEnum(nav_index) }); + log.debug("deleteExport '{s}' nav={d}", .{ name_slice, @backingInt(nav_index) }); assert(wasm.nav_exports.swapRemove(.{ .nav_index = nav_index, .name = export_name })); }, .uav => |uav_index| assert(wasm.uav_exports.swapRemove(.{ .uav_index = uav_index, .name = export_name })), @@ -3357,7 +3357,7 @@ pub fn updateExports( const name = try wasm.internString(name_slice); switch (exported) { .nav => |nav_index| { - log.debug("updateExports '{s}' nav={d}", .{ name_slice, @intFromEnum(nav_index) }); + log.debug("updateExports '{s}' nav={d}", .{ name_slice, @backingInt(nav_index) }); try wasm.nav_exports.put(gpa, .{ .nav_index = nav_index, .name = name }, export_idx); }, .uav => |uav_index| try wasm.uav_exports.put(gpa, .{ .uav_index = uav_index, .name = name }, export_idx), @@ -3446,7 +3446,7 @@ pub fn prelink(wasm: *Wasm, prog_node: std.Progress.Node) link.Error!void { @panic("TODO"); } else { try wasm.globals.put(gpa, .__stack_pointer, {}); - assert(wasm.globals.entries.len - 1 == @intFromEnum(GlobalIndex.stack_pointer)); + assert(wasm.globals.entries.len - 1 == @backingInt(GlobalIndex.stack_pointer)); } } @@ -3454,7 +3454,7 @@ pub fn prelink(wasm: *Wasm, prog_node: std.Progress.Node) link.Error!void { // At the end, output functions and globals will be populated. for (wasm.object_function_imports.keys(), wasm.object_function_imports.values(), 0..) |name, *import, i| { if (import.flags.isIncluded(rdynamic)) { - try markFunctionImport(wasm, name, import, @enumFromInt(i)); + try markFunctionImport(wasm, name, import, @fromBackingInt(@intCast(i))); } } // Also treat init functions as roots. @@ -3468,7 +3468,7 @@ pub fn prelink(wasm: *Wasm, prog_node: std.Progress.Node) link.Error!void { for (wasm.object_global_imports.keys(), wasm.object_global_imports.values(), 0..) |name, *import, i| { if (import.flags.isIncluded(rdynamic)) { - try markGlobalImport(wasm, name, import, @enumFromInt(i)); + try markGlobalImport(wasm, name, import, @fromBackingInt(@intCast(i))); } } wasm.globals_end_prelink = @intCast(wasm.globals.entries.len); @@ -3476,13 +3476,13 @@ pub fn prelink(wasm: *Wasm, prog_node: std.Progress.Node) link.Error!void { for (wasm.object_table_imports.keys(), wasm.object_table_imports.values(), 0..) |name, *import, i| { if (import.flags.isIncluded(rdynamic)) { - try markTableImport(wasm, name, import, @enumFromInt(i)); + try markTableImport(wasm, name, import, @fromBackingInt(@intCast(i))); } } for (wasm.object_data_imports.keys(), wasm.object_data_imports.values(), 0..) |name, *import, i| { if (import.flags.isIncluded(rdynamic)) { - try markDataImport(wasm, name, import, @enumFromInt(i)); + try markDataImport(wasm, name, import, @fromBackingInt(@intCast(i))); } } @@ -3548,9 +3548,9 @@ fn markFunction(wasm: *Wasm, i: ObjectFunctionIndex, override_export: bool) link if (!is_obj and (override_export or function.flags.isExported(rdynamic))) { const symbol_name = function.name.unwrap().?; if (!override_export and function.flags.visibility_hidden) { - try wasm.hidden_function_exports.put(gpa, symbol_name, @enumFromInt(gop.index)); + try wasm.hidden_function_exports.put(gpa, symbol_name, @fromBackingInt(@intCast(gop.index))); } else { - try wasm.function_exports.put(gpa, symbol_name, @enumFromInt(gop.index)); + try wasm.function_exports.put(gpa, symbol_name, @fromBackingInt(@intCast(gop.index))); } } @@ -3619,7 +3619,7 @@ fn markGlobal(wasm: *Wasm, i: ObjectGlobalIndex, override_export: bool) link.Err if (!is_obj and (override_export or global.flags.isExported(rdynamic))) try wasm.global_exports.append(gpa, .{ .name = global.name.unwrap().?, - .global_index = @enumFromInt(gop.index), + .global_index = @fromBackingInt(@intCast(gop.index)), }); try wasm.markRelocations(global.relocations(wasm)); @@ -3703,7 +3703,7 @@ fn markRelocations(wasm: *Wasm, relocs: ObjectRelocation.IterableSlice) link.Err .function_import_offset_i64, => { const name = pointee.symbol_name; - const i: FunctionImport.Index = @enumFromInt(wasm.object_function_imports.getIndex(name).?); + const i: FunctionImport.Index = @fromBackingInt(@intCast(wasm.object_function_imports.getIndex(name).?)); try markFunctionImport(wasm, name, i.value(wasm), i); }, .table_import_index_sleb, @@ -3715,17 +3715,17 @@ fn markRelocations(wasm: *Wasm, relocs: ObjectRelocation.IterableSlice) link.Err => { const name = pointee.symbol_name; try wasm.object_indirect_function_import_set.put(gpa, name, {}); - const i: FunctionImport.Index = @enumFromInt(wasm.object_function_imports.getIndex(name).?); + const i: FunctionImport.Index = @fromBackingInt(@intCast(wasm.object_function_imports.getIndex(name).?)); try markFunctionImport(wasm, name, i.value(wasm), i); }, .global_import_index_leb, .global_import_index_i32 => { const name = pointee.symbol_name; - const i: GlobalImport.Index = @enumFromInt(wasm.object_global_imports.getIndex(name).?); + const i: GlobalImport.Index = @fromBackingInt(@intCast(wasm.object_global_imports.getIndex(name).?)); try markGlobalImport(wasm, name, i.value(wasm), i); }, .table_import_number_leb => { const name = pointee.symbol_name; - const i: TableImport.Index = @enumFromInt(wasm.object_table_imports.getIndex(name).?); + const i: TableImport.Index = @fromBackingInt(@intCast(wasm.object_table_imports.getIndex(name).?)); try markTableImport(wasm, name, i.value(wasm), i); }, .memory_addr_import_leb, @@ -3871,7 +3871,7 @@ pub fn internString(wasm: *Wasm, bytes: []const u8) Allocator.Error!String { if (gop.found_existing) return gop.key_ptr.*; try wasm.string_bytes.ensureUnusedCapacity(gpa, bytes.len + 1); - const new_off: String = @enumFromInt(wasm.string_bytes.items.len); + const new_off: String = @fromBackingInt(@intCast(wasm.string_bytes.items.len)); wasm.string_bytes.appendSliceAssumeCapacity(bytes); wasm.string_bytes.appendAssumeCapacity(0); @@ -3906,12 +3906,12 @@ pub fn getExistingValtypeList(wasm: *const Wasm, valtype_list: []const std.wasm. pub fn addFuncType(wasm: *Wasm, ft: FunctionType) Allocator.Error!FunctionType.Index { const gpa = wasm.base.comp.gpa; const gop = try wasm.func_types.getOrPut(gpa, ft); - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn getExistingFuncType(wasm: *const Wasm, ft: FunctionType) ?FunctionType.Index { const index = wasm.func_types.getIndex(ft) orelse return null; - return @enumFromInt(index); + return @fromBackingInt(@intCast(index)); } pub fn getExistingFuncType2(wasm: *const Wasm, params: []const std.wasm.Valtype, returns: []const std.wasm.Valtype) FunctionType.Index { @@ -3960,14 +3960,14 @@ pub fn addExpr(wasm: *Wasm, bytes: []const u8) Allocator.Error!Expr { // it is likely for globals to share initialization values. Then again // there may not be very many globals in total. try wasm.string_bytes.appendSlice(gpa, bytes); - return @enumFromInt(wasm.string_bytes.items.len - bytes.len); + return @fromBackingInt(@intCast(wasm.string_bytes.items.len - bytes.len)); } pub fn addRelocatableDataPayload(wasm: *Wasm, bytes: []const u8) Allocator.Error!DataPayload { const gpa = wasm.base.comp.gpa; try wasm.string_bytes.appendSlice(gpa, bytes); return .{ - .off = @enumFromInt(wasm.string_bytes.items.len - bytes.len), + .off = @fromBackingInt(@intCast(wasm.string_bytes.items.len - bytes.len)), .len = @intCast(bytes.len), }; } @@ -3976,10 +3976,10 @@ pub fn uavSymbolIndex(wasm: *Wasm, ip_index: InternPool.Index) Allocator.Error!S const comp = wasm.base.comp; assert(comp.config.output_mode == .Obj); const gpa = comp.gpa; - const name = try wasm.internStringFmt("__anon_{d}", .{@intFromEnum(ip_index)}); + const name = try wasm.internStringFmt("__anon_{d}", .{@backingInt(ip_index)}); const gop = try wasm.symbol_table.getOrPut(gpa, name); gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn navSymbolIndex(wasm: *Wasm, nav_index: InternPool.Nav.Index) Allocator.Error!SymbolTableIndex { @@ -3992,7 +3992,7 @@ pub fn navSymbolIndex(wasm: *Wasm, nav_index: InternPool.Nav.Index) Allocator.Er const name = try wasm.internString(nav.fqn.toSlice(ip)); const gop = try wasm.symbol_table.getOrPut(gpa, name); gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn errorNameTableSymbolIndex(wasm: *Wasm) Allocator.Error!SymbolTableIndex { @@ -4001,7 +4001,7 @@ pub fn errorNameTableSymbolIndex(wasm: *Wasm) Allocator.Error!SymbolTableIndex { const gpa = comp.gpa; const gop = try wasm.symbol_table.getOrPut(gpa, wasm.preloaded_strings.__zig_error_name_table); gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn stackPointerSymbolIndex(wasm: *Wasm) Allocator.Error!SymbolTableIndex { @@ -4010,7 +4010,7 @@ pub fn stackPointerSymbolIndex(wasm: *Wasm) Allocator.Error!SymbolTableIndex { const gpa = comp.gpa; const gop = try wasm.symbol_table.getOrPut(gpa, wasm.preloaded_strings.__stack_pointer); gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn tagTableIndexSymbolIndex(wasm: *Wasm, ip_index: InternPool.Index) Allocator.Error!SymbolTableIndex { @@ -4020,7 +4020,7 @@ pub fn tagTableIndexSymbolIndex(wasm: *Wasm, ip_index: InternPool.Index) Allocat const name = try wasm.internStringFmt("__zig_tag_name_{d}", .{ip_index}); const gop = try wasm.symbol_table.getOrPut(gpa, name); gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn symbolNameIndex(wasm: *Wasm, name: String) Allocator.Error!SymbolTableIndex { @@ -4029,7 +4029,7 @@ pub fn symbolNameIndex(wasm: *Wasm, name: String) Allocator.Error!SymbolTableInd const gpa = comp.gpa; const gop = try wasm.symbol_table.getOrPut(gpa, name); gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn addUavReloc( @@ -4075,7 +4075,7 @@ pub fn addUavReloc( }; gop.value_ptr.count += 1; try wasm.uav_fixups.append(gpa, .{ - .uavs_exe_index = @enumFromInt(gop.index), + .uavs_exe_index = @fromBackingInt(@intCast(gop.index)), .offset = @intCast(reloc_offset), .addend = addend, }); @@ -4092,7 +4092,7 @@ pub fn refNavObj(wasm: *Wasm, nav_index: InternPool.Nav.Index) !NavsObjIndex { .code = undefined, .relocs = undefined, }; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } pub fn refNavExe(wasm: *Wasm, nav_index: InternPool.Nav.Index) !NavsExeIndex { @@ -4109,7 +4109,7 @@ pub fn refNavExe(wasm: *Wasm, nav_index: InternPool.Nav.Index) !NavsExeIndex { .count = 0, }; } - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } /// Asserts it is called after `Flush.data_segments` is fully populated and sorted. @@ -4117,7 +4117,7 @@ pub fn uavAddr(wasm: *Wasm, ip_index: InternPool.Index) u32 { assert(wasm.flush_buffer.memory_layout_finished); const comp = wasm.base.comp; assert(comp.config.output_mode != .Obj); - const uav_index: UavsExeIndex = @enumFromInt(wasm.uavs_exe.getIndex(ip_index).?); + const uav_index: UavsExeIndex = @fromBackingInt(@intCast(wasm.uavs_exe.getIndex(ip_index).?)); const ds_id: DataSegmentId = .pack(wasm, .{ .uav_exe = uav_index }); return wasm.flush_buffer.data_segments.get(ds_id).?; } @@ -4128,7 +4128,7 @@ pub fn navAddr(wasm: *Wasm, nav_index: InternPool.Nav.Index) u32 { const comp = wasm.base.comp; assert(comp.config.output_mode != .Obj); if (wasm.navs_exe.getIndex(nav_index)) |i| { - const navs_exe_index: NavsExeIndex = @enumFromInt(i); + const navs_exe_index: NavsExeIndex = @fromBackingInt(@intCast(i)); log.debug("navAddr {s} {}", .{ navs_exe_index.name(wasm), nav_index }); const ds_id: DataSegmentId = .pack(wasm, .{ .nav_exe = navs_exe_index }); return wasm.flush_buffer.data_segments.get(ds_id).?; @@ -4279,7 +4279,7 @@ fn lowerZcuData(wasm: *Wasm, pt: Zcu.PerThread, ip_index: InternPool.Index) !Zcu wasm.string_bytes_lock.unlock(); const naive_code: DataPayload = .{ - .off = @enumFromInt(code_start), + .off = @fromBackingInt(@intCast(code_start)), .len = code_len, }; @@ -4329,7 +4329,7 @@ fn pointerSize(wasm: *const Wasm) u32 { fn addZcuImportReserved(wasm: *Wasm, nav_index: InternPool.Nav.Index) ZcuImportIndex { const gop = wasm.imports.getOrPutAssumeCapacity(nav_index); gop.value_ptr.* = {}; - return @enumFromInt(gop.index); + return @fromBackingInt(@intCast(gop.index)); } fn resolveFunctionSynthetic( diff --git a/src/link/Wasm/Flush.zig b/src/link/Wasm/Flush.zig index a19fd7a57f38f88b727ba883595bc4f434fdc6ea..410ebb7e4434595ecbe1353810235ad1f6b468b2 100644 --- a/src/link/Wasm/Flush.zig +++ b/src/link/Wasm/Flush.zig @@ -51,7 +51,7 @@ pub const FuncTypeIndex = enum(u32) { _, pub fn fromTypeIndex(i: Wasm.FunctionType.Index, f: *const Flush) FuncTypeIndex { - return @enumFromInt(f.func_types.getIndex(i).?); + return @fromBackingInt(@intCast(f.func_types.getIndex(i).?)); } }; @@ -68,16 +68,16 @@ const IndirectFunctionTableIndex = enum(u32) { } fn fromOutputFunctionIndex(f: *const Flush, i: Wasm.OutputFunctionIndex) IndirectFunctionTableIndex { - return @enumFromInt(f.indirect_function_table.getIndex(i).?); + return @fromBackingInt(@intCast(f.indirect_function_table.getIndex(i).?)); } fn fromZcuIndirectFunctionSetIndex(i: Wasm.ZcuIndirectFunctionSetIndex) IndirectFunctionTableIndex { // These are the same since those are added to the table first. - return @enumFromInt(@intFromEnum(i)); + return @fromBackingInt(@intCast(@backingInt(i))); } fn toAbi(i: IndirectFunctionTableIndex) u32 { - return @intFromEnum(i) + 1; + return @backingInt(i) + 1; } }; @@ -139,11 +139,11 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { for (wasm.mir_instructions.items(.tag), wasm.mir_instructions.items(.data)) |tag, *data| switch (tag) { .call_intrinsic => { const symbol_name = try wasm.internString(@tagName(data.intrinsic)); - const i: Wasm.FunctionImport.Index = @enumFromInt(wasm.object_function_imports.getIndex(symbol_name) orelse { + const i: Wasm.FunctionImport.Index = @fromBackingInt(@intCast(wasm.object_function_imports.getIndex(symbol_name) orelse { return diags.fail("missing compiler runtime intrinsic '{t}' (undefined linker symbol)", .{ data.intrinsic, }); - }); + })); try wasm.markFunctionImport(symbol_name, i.value(wasm), i); log.debug("markFunctionImport intrinsic {d}={t}", .{ i, data.intrinsic }); }, @@ -157,7 +157,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { .type_index = try wasm.internFunctionType(.auto, &.{int_tag_ty.ip_index}, .u32, false, target), } }; } - try wasm.functions.put(gpa, .fromZcuFunc(wasm, @enumFromInt(gop.index)), {}); + try wasm.functions.put(gpa, .fromZcuFunc(wasm, @fromBackingInt(@intCast(gop.index))), {}); }, .enum_tag_name_table_ref => { assert(ip.indexToKey(data.ip_index) == .enum_type); @@ -181,7 +181,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { while (i < f.function_imports.entries.len) { const symbol_name = f.function_imports.keys()[i]; if (wasm.object_function_imports.getIndex(symbol_name)) |import_index_usize| { - const import_index: Wasm.FunctionImport.Index = @enumFromInt(import_index_usize); + const import_index: Wasm.FunctionImport.Index = @fromBackingInt(@intCast(import_index_usize)); try wasm.markFunctionImport(symbol_name, import_index.value(wasm), import_index); f.function_imports.swapRemoveAt(i); continue; @@ -195,7 +195,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { while (i < f.data_imports.entries.len) { const symbol_name = f.data_imports.keys()[i]; if (wasm.object_data_imports.getIndex(symbol_name)) |import_index_usize| { - const import_index: Wasm.ObjectDataImport.Index = @enumFromInt(import_index_usize); + const import_index: Wasm.ObjectDataImport.Index = @fromBackingInt(@intCast(import_index_usize)); try wasm.markDataImport(symbol_name, import_index.value(wasm), import_index); f.data_imports.swapRemoveAt(i); continue; @@ -313,16 +313,16 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { if (!is_obj) assert(wasm.uavs_obj.entries.len == 0); if (!is_obj) assert(wasm.navs_obj.entries.len == 0); for (0..wasm.uavs_obj.entries.len) |uavs_index| f.data_segments.putAssumeCapacityNoClobber(.pack(wasm, .{ - .uav_obj = @enumFromInt(uavs_index), + .uav_obj = @fromBackingInt(@intCast(uavs_index)), }), @as(u32, undefined)); for (0..wasm.navs_obj.entries.len) |navs_index| f.data_segments.putAssumeCapacityNoClobber(.pack(wasm, .{ - .nav_obj = @enumFromInt(navs_index), + .nav_obj = @fromBackingInt(@intCast(navs_index)), }), @as(u32, undefined)); for (0..wasm.uavs_exe.entries.len) |uavs_index| f.data_segments.putAssumeCapacityNoClobber(.pack(wasm, .{ - .uav_exe = @enumFromInt(uavs_index), + .uav_exe = @fromBackingInt(@intCast(uavs_index)), }), @as(u32, undefined)); for (0..wasm.navs_exe.entries.len) |navs_index| f.data_segments.putAssumeCapacityNoClobber(.pack(wasm, .{ - .nav_exe = @enumFromInt(navs_index), + .nav_exe = @fromBackingInt(@intCast(navs_index)), }), @as(u32, undefined)); if (wasm.error_name_table_ref_count > 0) { f.data_segments.putAssumeCapacity(.__zig_error_names, @as(u32, undefined)); @@ -371,8 +371,8 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { pub fn lessThan(ctx: @This(), lhs: usize, rhs: usize) bool { const lhs_segment = ctx.segments[lhs]; const rhs_segment = ctx.segments[rhs]; - const lhs_category = @intFromEnum(lhs_segment.category(ctx.wasm)); - const rhs_category = @intFromEnum(rhs_segment.category(ctx.wasm)); + const lhs_category = @backingInt(lhs_segment.category(ctx.wasm)); + const rhs_category = @backingInt(rhs_segment.category(ctx.wasm)); switch (std.math.order(lhs_category, rhs_category)) { .lt => return true, .gt => return false, @@ -404,7 +404,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { .gt => return false, .eq => {}, } - return @intFromEnum(lhs_segment) < @intFromEnum(rhs_segment); + return @backingInt(lhs_segment) < @backingInt(rhs_segment); } }; f.data_segments.sortUnstable(@as(Sort, .{ @@ -486,7 +486,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const size = segment_id.size(wasm); segment_vaddr.* = @intCast(start_addr); - log.debug("0x{x} {d} {s}", .{ start_addr, @intFromEnum(segment_id), segment_id.name(wasm) }); + log.debug("0x{x} {d} {s}", .{ start_addr, @backingInt(segment_id), segment_id.name(wasm) }); memory_ptr = start_addr + size; } if (category != .zero) try f.data_segment_groups.append(gpa, .{ @@ -593,12 +593,12 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const params = func_type.params.slice(wasm); try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(params.len))); for (params) |param_ty| { - try appendLeb128(gpa, binary_bytes, @intFromEnum(param_ty)); + try appendLeb128(gpa, binary_bytes, @backingInt(param_ty)); } const returns = func_type.returns.slice(wasm); try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(returns.len))); for (returns) |ret_ty| { - try appendLeb128(gpa, binary_bytes, @intFromEnum(ret_ty)); + try appendLeb128(gpa, binary_bytes, @backingInt(ret_ty)); } } replaceVecSectionHeader(binary_bytes, header_offset, .type, @intCast(f.func_types.entries.len)); @@ -625,9 +625,9 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.function)); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.function)); const type_index: FuncTypeIndex = .fromTypeIndex(id.functionType(wasm), f); - try appendLeb128(gpa, binary_bytes, @intFromEnum(type_index)); + try appendLeb128(gpa, binary_bytes, @backingInt(type_index)); } total_imports += f.function_imports.entries.len; @@ -641,8 +641,8 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.table)); - try appendLeb128(gpa, binary_bytes, @intFromEnum(@as(std.wasm.RefType, table_import.flags.ref_type.to()))); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.table)); + try appendLeb128(gpa, binary_bytes, @backingInt(@as(std.wasm.RefType, table_import.flags.ref_type.to()))); try emitLimits(gpa, binary_bytes, table_import.limits()); } total_imports += wasm.table_imports.entries.len; @@ -670,9 +670,9 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.global)); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.global)); const global_type = id.globalType(wasm); - try appendLeb128(gpa, binary_bytes, @intFromEnum(@as(std.wasm.Valtype, global_type.valtype))); + try appendLeb128(gpa, binary_bytes, @backingInt(@as(std.wasm.Valtype, global_type.valtype))); try binary_bytes.append(gpa, @intFromBool(global_type.mutable)); } total_imports += f.global_imports.entries.len; @@ -690,7 +690,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const header_offset = try reserveVecSectionHeader(gpa, binary_bytes); for (wasm.functions.keys()) |function| { const index: FuncTypeIndex = .fromTypeIndex(function.typeIndex(wasm), f); - try appendLeb128(gpa, binary_bytes, @intFromEnum(index)); + try appendLeb128(gpa, binary_bytes, @backingInt(index)); } replaceVecSectionHeader(binary_bytes, header_offset, .function, @intCast(wasm.functions.count())); @@ -702,7 +702,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const header_offset = try reserveVecSectionHeader(gpa, binary_bytes); for (wasm.tables.keys()) |table| { - try appendLeb128(gpa, binary_bytes, @intFromEnum(@as(std.wasm.RefType, table.refType(wasm)))); + try appendLeb128(gpa, binary_bytes, @backingInt(@as(std.wasm.RefType, table.refType(wasm)))); try emitLimits(gpa, binary_bytes, table.limits(wasm)); } @@ -735,7 +735,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { .object_global => |i| { const global = i.ptr(wasm); try binary_bytes.appendSlice(gpa, &.{ - @intFromEnum(@as(std.wasm.Valtype, global.flags.global_type.valtype.to())), + @backingInt(@as(std.wasm.Valtype, global.flags.global_type.valtype.to())), @intFromBool(global.flags.global_type.mutable), }); try emitExpr(wasm, binary_bytes, global.expr); @@ -758,9 +758,9 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const name = exp_name.slice(wasm); try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.function)); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.function)); const func_index = Wasm.OutputFunctionIndex.fromFunctionIndex(wasm, function_index); - try appendLeb128(gpa, binary_bytes, @intFromEnum(func_index)); + try appendLeb128(gpa, binary_bytes, @backingInt(func_index)); } exports_len += wasm.function_exports.entries.len; @@ -769,7 +769,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const index: u32 = @intCast(wasm.tables.getIndex(.__indirect_function_table).?); try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.table)); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.table)); try appendLeb128(gpa, binary_bytes, index); exports_len += 1; } @@ -778,7 +778,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const name = "memory"; try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.memory)); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.memory)); try appendLeb128(gpa, binary_bytes, @as(u32, 0)); exports_len += 1; } @@ -787,8 +787,8 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const name = exp.name.slice(wasm); try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.global)); - try appendLeb128(gpa, binary_bytes, @intFromEnum(exp.global_index)); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.global)); + try appendLeb128(gpa, binary_bytes, @backingInt(exp.global_index)); } exports_len += wasm.global_exports.items.len; @@ -802,7 +802,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { // start section if (wasm.functions.getIndex(.__wasm_init_memory)) |func_index| { - try emitStartSection(gpa, binary_bytes, .fromFunctionIndex(wasm, @enumFromInt(func_index))); + try emitStartSection(gpa, binary_bytes, .fromFunctionIndex(wasm, @fromBackingInt(@intCast(func_index)))); } else if (Wasm.OutputFunctionIndex.fromResolution(wasm, wasm.entry_resolution)) |func_index| { try emitStartSection(gpa, binary_bytes, func_index); } @@ -830,7 +830,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { } try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(f.indirect_function_table.entries.len))); for (f.indirect_function_table.keys()) |func_index| { - try appendLeb128(gpa, binary_bytes, @intFromEnum(func_index)); + try appendLeb128(gpa, binary_bytes, @backingInt(func_index)); } replaceVecSectionHeader(binary_bytes, header_offset, .element, 1); @@ -966,7 +966,7 @@ pub fn finish(f: *Flush, wasm: *Wasm) !void { const group_size = group_end_addr - group_start_addr; log.debug("emit data section group, {d} bytes", .{group_size}); const flags: Object.DataSegmentFlags = if (segment_id.isPassive(wasm)) .passive else .active; - try appendLeb128(gpa, binary_bytes, @intFromEnum(flags)); + try appendLeb128(gpa, binary_bytes, @backingInt(flags)); // Passive segments are initialized at runtime. if (flags != .passive) { var aw: std.Io.Writer.Allocating = .fromArrayList(gpa, binary_bytes); @@ -1119,7 +1119,7 @@ fn emitNameSection( { const sub_offset = try reserveCustomSectionHeader(gpa, binary_bytes); - defer replaceHeader(binary_bytes, sub_offset, @intFromEnum(std.wasm.NameSubsection.function)); + defer replaceHeader(binary_bytes, sub_offset, @backingInt(std.wasm.NameSubsection.function)); const total_functions: u32 = @intCast(f.function_imports.entries.len + wasm.functions.entries.len); try appendLeb128(gpa, binary_bytes, total_functions); @@ -1140,7 +1140,7 @@ fn emitNameSection( { const sub_offset = try reserveCustomSectionHeader(gpa, binary_bytes); - defer replaceHeader(binary_bytes, sub_offset, @intFromEnum(std.wasm.NameSubsection.global)); + defer replaceHeader(binary_bytes, sub_offset, @backingInt(std.wasm.NameSubsection.global)); const total_globals: u32 = @intCast(f.global_imports.entries.len + wasm.globals.entries.len); try appendLeb128(gpa, binary_bytes, total_globals); @@ -1161,7 +1161,7 @@ fn emitNameSection( { const sub_offset = try reserveCustomSectionHeader(gpa, binary_bytes); - defer replaceHeader(binary_bytes, sub_offset, @intFromEnum(std.wasm.NameSubsection.data_segment)); + defer replaceHeader(binary_bytes, sub_offset, @backingInt(std.wasm.NameSubsection.data_segment)); const total_data_segments: u32 = @intCast(data_segment_groups.len); try appendLeb128(gpa, binary_bytes, total_data_segments); @@ -1194,7 +1194,7 @@ fn emitFeaturesSection( var safety_count = feature_count; for (target.cpu.arch.allFeaturesList(), 0..) |*feature, i| { - if (!target.cpu.has(.wasm, @as(std.Target.wasm.Feature, @enumFromInt(i)))) continue; + if (!target.cpu.has(.wasm, @as(std.Target.wasm.Feature, @fromBackingInt(@intCast(i))))) continue; safety_count -= 1; try appendLeb128(gpa, binary_bytes, @as(u32, '+')); @@ -1318,7 +1318,7 @@ fn replaceVecSectionHeader( const size: u32 = @intCast(bytes.items.len - offset - section_header_reserve_size + uleb128size(n_items)); var buf: [section_header_reserve_size]u8 = undefined; var w: std.Io.Writer = .fixed(&buf); - w.writeByte(@intFromEnum(section)) catch unreachable; + w.writeByte(@backingInt(section)) catch unreachable; w.writeUleb128(size) catch unreachable; w.writeUleb128(n_items) catch unreachable; bytes.replaceRangeAssumeCapacity(offset, section_header_reserve_size, w.buffered()); @@ -1382,34 +1382,34 @@ fn emitMemoryImport( try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(name.len))); try binary_bytes.appendSlice(gpa, name); - try binary_bytes.append(gpa, @intFromEnum(std.wasm.ExternalKind.memory)); + try binary_bytes.append(gpa, @backingInt(std.wasm.ExternalKind.memory)); try emitLimits(gpa, binary_bytes, memory_import.limits()); } fn emitInit(writer: *std.Io.Writer, init_expr: std.wasm.InitExpression) !void { switch (init_expr) { .i32_const => |val| { - try writer.writeByte(@intFromEnum(std.wasm.Opcode.i32_const)); + try writer.writeByte(@backingInt(std.wasm.Opcode.i32_const)); try writer.writeSleb128(val); }, .i64_const => |val| { - try writer.writeByte(@intFromEnum(std.wasm.Opcode.i64_const)); + try writer.writeByte(@backingInt(std.wasm.Opcode.i64_const)); try writer.writeSleb128(val); }, .f32_const => |val| { - try writer.writeByte(@intFromEnum(std.wasm.Opcode.f32_const)); + try writer.writeByte(@backingInt(std.wasm.Opcode.f32_const)); try writer.writeInt(u32, @bitCast(val), .little); }, .f64_const => |val| { - try writer.writeByte(@intFromEnum(std.wasm.Opcode.f64_const)); + try writer.writeByte(@backingInt(std.wasm.Opcode.f64_const)); try writer.writeInt(u64, @bitCast(val), .little); }, .global_get => |val| { - try writer.writeByte(@intFromEnum(std.wasm.Opcode.global_get)); + try writer.writeByte(@backingInt(std.wasm.Opcode.global_get)); try writer.writeUleb128(val); }, } - try writer.writeByte(@intFromEnum(std.wasm.Opcode.end)); + try writer.writeByte(@backingInt(std.wasm.Opcode.end)); } pub fn emitExpr(wasm: *const Wasm, binary_bytes: *ArrayList(u8), expr: Wasm.Expr) Allocator.Error!void { @@ -1420,7 +1420,7 @@ pub fn emitExpr(wasm: *const Wasm, binary_bytes: *ArrayList(u8), expr: Wasm.Expr fn emitSegmentInfo(wasm: *Wasm, binary_bytes: *std.array_list.Managed(u8)) !void { const gpa = wasm.base.comp.gpa; - try appendLeb128(gpa, binary_bytes, @intFromEnum(Wasm.SubsectionType.segment_info)); + try appendLeb128(gpa, binary_bytes, @backingInt(Wasm.SubsectionType.segment_info)); const segment_offset = binary_bytes.items.len; try appendLeb128(gpa, binary_bytes, @as(u32, @intCast(wasm.segment_info.count()))); @@ -1554,19 +1554,19 @@ fn reloc_sleb64_table_index(code: []u8, i: IndirectFunctionTableIndex) void { } fn reloc_u32_function(code: []u8, function: Wasm.OutputFunctionIndex) void { - mem.writeInt(u32, code[0..4], @intFromEnum(function), .little); + mem.writeInt(u32, code[0..4], @backingInt(function), .little); } fn reloc_leb_function(code: []u8, function: Wasm.OutputFunctionIndex) void { - leb.writeUnsignedFixed(5, code[0..5], @intFromEnum(function)); + leb.writeUnsignedFixed(5, code[0..5], @backingInt(function)); } fn reloc_u32_global(code: []u8, global: Wasm.GlobalIndex) void { - mem.writeInt(u32, code[0..4], @intFromEnum(global), .little); + mem.writeInt(u32, code[0..4], @backingInt(global), .little); } fn reloc_leb_global(code: []u8, global: Wasm.GlobalIndex) void { - leb.writeUnsignedFixed(5, code[0..5], @intFromEnum(global)); + leb.writeUnsignedFixed(5, code[0..5], @backingInt(global)); } const RelocAddr = struct { @@ -1618,11 +1618,11 @@ fn reloc_sleb64_addr(code: []u8, ra: RelocAddr) void { } fn reloc_leb_table(code: []u8, table: Wasm.TableIndex) void { - leb.writeUnsignedFixed(5, code[0..5], @intFromEnum(table)); + leb.writeUnsignedFixed(5, code[0..5], @backingInt(table)); } fn reloc_leb_type(code: []u8, index: FuncTypeIndex) void { - leb.writeUnsignedFixed(5, code[0..5], @intFromEnum(index)); + leb.writeUnsignedFixed(5, code[0..5], @backingInt(index)); } fn emitCallCtorsFunction(wasm: *const Wasm, binary_bytes: *ArrayList(u8)) Allocator.Error!void { @@ -1640,14 +1640,14 @@ fn emitCallCtorsFunction(wasm: *const Wasm, binary_bytes: *ArrayList(u8)) Alloca // Call function by its function index try binary_bytes.ensureUnusedCapacity(gpa, 1 + 5 + n_returns + 1); const call_index: Wasm.OutputFunctionIndex = .fromObjectFunction(wasm, init_func.function_index); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.call)); - appendReservedUleb32(binary_bytes, @intFromEnum(call_index)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.call)); + appendReservedUleb32(binary_bytes, @backingInt(call_index)); // drop all returned values from the stack as __wasm_call_ctors has no return value - binary_bytes.appendNTimesAssumeCapacity(@intFromEnum(std.wasm.Opcode.drop), n_returns); + binary_bytes.appendNTimesAssumeCapacity(@backingInt(std.wasm.Opcode.drop), n_returns); } - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); // end function body + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); // end function body } fn emitInitMemoryFunction( @@ -1674,31 +1674,31 @@ fn emitInitMemoryFunction( try binary_bytes.ensureUnusedCapacity(gpa, 2 * 3 + 6 * 3 + 1 + 6 * 3 + 1 + 5 * 4 + 1 + 1); // destination blocks // based on values we jump to corresponding label - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block)); // $drop - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.empty)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.block)); // $drop + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.BlockType.empty)); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block)); // $wait - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.empty)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.block)); // $wait + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.BlockType.empty)); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block)); // $init - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.empty)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.block)); // $init + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.BlockType.empty)); // atomically check appendReservedI32Const(binary_bytes, flag_address); appendReservedI32Const(binary_bytes, 0); appendReservedI32Const(binary_bytes, 1); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.atomics_prefix)); - appendReservedUleb32(binary_bytes, @intFromEnum(std.wasm.AtomicsOpcode.i32_atomic_rmw_cmpxchg)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.atomics_prefix)); + appendReservedUleb32(binary_bytes, @backingInt(std.wasm.AtomicsOpcode.i32_atomic_rmw_cmpxchg)); appendReservedUleb32(binary_bytes, 2); // alignment appendReservedUleb32(binary_bytes, 0); // offset // based on the value from the atomic check, jump to the label. - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_table)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.br_table)); appendReservedUleb32(binary_bytes, 2); // length of the table (we have 3 blocks but because of the mandatory default the length is 2). appendReservedUleb32(binary_bytes, 0); // $init appendReservedUleb32(binary_bytes, 1); // $wait appendReservedUleb32(binary_bytes, 2); // $drop - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); } const segment_groups = wasm.flush_buffer.data_segment_groups.items; @@ -1723,19 +1723,19 @@ fn emitInitMemoryFunction( // global. This allows the runtime to use this static copy of the // TLS data for the first/main thread. appendReservedI32Const(binary_bytes, start_addr); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.global_set)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.global_set)); appendReservedUleb32(binary_bytes, virtual_addrs.tls_base.?); } appendReservedI32Const(binary_bytes, 0); appendReservedI32Const(binary_bytes, segment_size); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.misc_prefix)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.misc_prefix)); if (segment.isBss(wasm)) { // fill bss segment with zeroes - appendReservedUleb32(binary_bytes, @intFromEnum(std.wasm.MiscOpcode.memory_fill)); + appendReservedUleb32(binary_bytes, @backingInt(std.wasm.MiscOpcode.memory_fill)); } else { // initialize the segment - appendReservedUleb32(binary_bytes, @intFromEnum(std.wasm.MiscOpcode.memory_init)); + appendReservedUleb32(binary_bytes, @backingInt(std.wasm.MiscOpcode.memory_init)); appendReservedUleb32(binary_bytes, @intCast(segment_index)); } binary_bytes.appendAssumeCapacity(0); // memory index immediate @@ -1747,38 +1747,38 @@ fn emitInitMemoryFunction( // we set the init memory flag to value '2' appendReservedI32Const(binary_bytes, flag_address); appendReservedI32Const(binary_bytes, 2); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.atomics_prefix)); - appendReservedUleb32(binary_bytes, @intFromEnum(std.wasm.AtomicsOpcode.i32_atomic_store)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.atomics_prefix)); + appendReservedUleb32(binary_bytes, @backingInt(std.wasm.AtomicsOpcode.i32_atomic_store)); appendReservedUleb32(binary_bytes, @as(u32, 2)); // alignment appendReservedUleb32(binary_bytes, @as(u32, 0)); // offset // notify any waiters for segment initialization completion appendReservedI32Const(binary_bytes, flag_address); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); appendReservedLeb128(binary_bytes, @as(i32, -1)); // number of waiters - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.atomics_prefix)); - appendReservedUleb32(binary_bytes, @intFromEnum(std.wasm.AtomicsOpcode.memory_atomic_notify)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.atomics_prefix)); + appendReservedUleb32(binary_bytes, @backingInt(std.wasm.AtomicsOpcode.memory_atomic_notify)); appendReservedUleb32(binary_bytes, @as(u32, 2)); // alignment appendReservedUleb32(binary_bytes, @as(u32, 0)); // offset - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.drop)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.drop)); // branch and drop segments - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.br)); appendReservedUleb32(binary_bytes, @as(u32, 1)); // wait for thread to initialize memory segments - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); // end $wait + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); // end $wait appendReservedI32Const(binary_bytes, flag_address); appendReservedI32Const(binary_bytes, 1); // expected flag value - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_const)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i64_const)); appendReservedLeb128(binary_bytes, @as(i64, -1)); // timeout - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.atomics_prefix)); - appendReservedUleb32(binary_bytes, @intFromEnum(std.wasm.AtomicsOpcode.memory_atomic_wait32)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.atomics_prefix)); + appendReservedUleb32(binary_bytes, @backingInt(std.wasm.AtomicsOpcode.memory_atomic_wait32)); appendReservedUleb32(binary_bytes, @as(u32, 2)); // alignment appendReservedUleb32(binary_bytes, @as(u32, 0)); // offset - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.drop)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.drop)); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); // end $drop + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); // end $drop } for (segment_groups, 0..) |group, segment_index| { @@ -1791,13 +1791,13 @@ fn emitInitMemoryFunction( try binary_bytes.ensureUnusedCapacity(gpa, 1 + 5 + 5 + 1); - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.misc_prefix)); - appendReservedUleb32(binary_bytes, @intFromEnum(std.wasm.MiscOpcode.data_drop)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.misc_prefix)); + appendReservedUleb32(binary_bytes, @backingInt(std.wasm.MiscOpcode.data_drop)); appendReservedUleb32(binary_bytes, @intCast(segment_index)); } // End of the function body - binary_bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + binary_bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); } fn emitInitTlsFunction(wasm: *const Wasm, bytes: *ArrayList(u8)) Allocator.Error!void { @@ -1821,28 +1821,28 @@ fn emitInitTlsFunction(wasm: *const Wasm, bytes: *ArrayList(u8)) Allocator.Error const param_local: u32 = 0; - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.local_get)); appendReservedUleb32(bytes, param_local); - const tls_base_global_index: Wasm.GlobalIndex = @enumFromInt(wasm.globals.getIndex(.__tls_base).?); - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.global_set)); - appendReservedUleb32(bytes, @intFromEnum(tls_base_global_index)); + const tls_base_global_index: Wasm.GlobalIndex = @fromBackingInt(@intCast(wasm.globals.getIndex(.__tls_base).?)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.global_set)); + appendReservedUleb32(bytes, @backingInt(tls_base_global_index)); // load stack values for the bulk-memory operation { - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.local_get)); appendReservedUleb32(bytes, param_local); - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); appendReservedUleb32(bytes, 0); //segment offset - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); appendReservedUleb32(bytes, group_size); //segment offset } // perform the bulk-memory operation to initialize the data segment - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.misc_prefix)); - appendReservedUleb32(bytes, @intFromEnum(std.wasm.MiscOpcode.memory_init)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.misc_prefix)); + appendReservedUleb32(bytes, @backingInt(std.wasm.MiscOpcode.memory_init)); // segment immediate appendReservedUleb32(bytes, data_segment_index); // memory index immediate (always 0) @@ -1853,17 +1853,17 @@ fn emitInitTlsFunction(wasm: *const Wasm, bytes: *ArrayList(u8)) Allocator.Error // which performs all runtime TLS relocations. This is a synthetic function, // generated by the linker. if (wasm.functions.getIndex(.__wasm_apply_global_tls_relocs)) |function_index| { - const output_function_index: Wasm.OutputFunctionIndex = .fromFunctionIndex(wasm, @enumFromInt(function_index)); - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.call)); - appendReservedUleb32(bytes, @intFromEnum(output_function_index)); + const output_function_index: Wasm.OutputFunctionIndex = .fromFunctionIndex(wasm, @fromBackingInt(@intCast(function_index))); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.call)); + appendReservedUleb32(bytes, @backingInt(output_function_index)); } - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); } fn emitStartSection(gpa: Allocator, bytes: *ArrayList(u8), i: Wasm.OutputFunctionIndex) !void { const header_offset = try reserveVecSectionHeader(gpa, bytes); - replaceVecSectionHeader(bytes, header_offset, .start, @intFromEnum(i)); + replaceVecSectionHeader(bytes, header_offset, .start, @backingInt(i)); } fn emitTagIndexFunction( @@ -1887,31 +1887,31 @@ fn emitTagIndexFunction( appendReservedUleb32(code, 0); // no locals - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.empty)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.block)); + code.appendAssumeCapacity(@backingInt(std.wasm.BlockType.empty)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.local_get)); appendReservedUleb32(code, 0); appendReservedI32Const(code, len); // if < len -> break out of block - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_lt_u)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_lt_u)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_if)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.br_if)); appendReservedUleb32(code, 0); // invalid -> return -1 appendReservedI32Const(code, ~@as(u32, 0)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.@"return")); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.@"return")); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); // valid -> return input - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.local_get)); appendReservedUleb32(code, 0); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); return; } @@ -1931,8 +1931,8 @@ fn emitTagIndexFunction( for (tag_values, 0..) |tag_value, tag_index| { // block for this if case - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.block)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.BlockType.empty)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.block)); + code.appendAssumeCapacity(@backingInt(std.wasm.BlockType.empty)); const val: Zcu.Value = .fromInterned(tag_value); if (is_big_int) { @@ -1947,21 +1947,21 @@ fn emitTagIndexFunction( try code.ensureUnusedCapacity(gpa, 35 * num_limbs); for (0..num_limbs) |limb_index| { - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.local_get)); appendReservedUleb32(code, 0); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_load)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i64_load)); appendReservedUleb32(code, @ctz(@as(u32, 8))); appendReservedUleb32(code, @intCast(limb_index * 8)); appendReservedI64Const(code, limbs[limb_index]); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_ne)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i64_ne)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_if)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.br_if)); appendReservedUleb32(code, 0); } } else { - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.local_get)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.local_get)); appendReservedUleb32(code, 0); switch (int_info.bits) { @@ -1971,7 +1971,7 @@ fn emitTagIndexFunction( .unsigned => @intCast(val.toUnsignedInt(zcu)), }; appendReservedI32Const(code, x); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_ne)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_ne)); }, 33...64 => { const x: u64 = switch (int_info.signedness) { @@ -1979,30 +1979,30 @@ fn emitTagIndexFunction( .unsigned => val.toUnsignedInt(zcu), }; appendReservedI64Const(code, x); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_ne)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i64_ne)); }, else => unreachable, } - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.br_if)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.br_if)); appendReservedUleb32(code, 0); } appendReservedI32Const(code, @intCast(tag_index)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.@"return")); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.@"return")); // end the block for this case - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); } appendReservedI32Const(code, ~@as(u32, 0)); - code.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + code.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); } /// Writes an unsigned 32-bit integer as a LEB128-encoded 'i32.const' value. fn appendReservedI32Const(bytes: *ArrayList(u8), val: u32) void { - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); var w: std.Io.Writer = .fromArrayList(bytes); defer bytes.* = w.toArrayList(); return w.writeSleb128(@as(i32, @bitCast(val))) catch |err| switch (err) { @@ -2012,7 +2012,7 @@ fn appendReservedI32Const(bytes: *ArrayList(u8), val: u32) void { /// Writes an unsigned 64-bit integer as a LEB128-encoded 'i64.const' value. fn appendReservedI64Const(bytes: *ArrayList(u8), val: u64) void { - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i64_const)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i64_const)); var w: std.Io.Writer = .fromArrayList(bytes); defer bytes.* = w.toArrayList(); return w.writeSleb128(@as(i64, @bitCast(val))) catch |err| switch (err) { @@ -2030,11 +2030,11 @@ fn appendReservedUleb32(bytes: *ArrayList(u8), val: u32) void { fn appendGlobal(gpa: Allocator, bytes: *ArrayList(u8), mutable: u8, val: u32) Allocator.Error!void { try bytes.ensureUnusedCapacity(gpa, 9); - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Valtype.i32)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Valtype.i32)); bytes.appendAssumeCapacity(mutable); - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.i32_const)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.i32_const)); appendReservedUleb32(bytes, val); - bytes.appendAssumeCapacity(@intFromEnum(std.wasm.Opcode.end)); + bytes.appendAssumeCapacity(@backingInt(std.wasm.Opcode.end)); } fn appendLeb128(gpa: Allocator, bytes: *ArrayList(u8), value: anytype) Allocator.Error!void { diff --git a/src/link/Wasm/Object.zig b/src/link/Wasm/Object.zig index a6fdd5350528ee474f2a4fd11856e6e59cec3c4d..a9b5a1fe42a27b160b833b9854468ebbba419c17 100644 --- a/src/link/Wasm/Object.zig +++ b/src/link/Wasm/Object.zig @@ -195,7 +195,7 @@ pub const ScratchSpace = struct { _, fn ptr(index: FuncImportIndex, ss: *const ScratchSpace) *FunctionImport { - return &ss.func_imports.items[@intFromEnum(index)]; + return &ss.func_imports.items[@backingInt(index)]; } }; @@ -204,7 +204,7 @@ pub const ScratchSpace = struct { _, fn ptr(index: GlobalImportIndex, ss: *const ScratchSpace) *GlobalImport { - return &ss.global_imports.items[@intFromEnum(index)]; + return &ss.global_imports.items[@backingInt(index)]; } }; @@ -213,7 +213,7 @@ pub const ScratchSpace = struct { _, fn ptr(index: TableImportIndex, ss: *const ScratchSpace) *TableImport { - return &ss.table_imports.items[@intFromEnum(index)]; + return &ss.table_imports.items[@backingInt(index)]; } }; @@ -222,7 +222,7 @@ pub const ScratchSpace = struct { _, fn ptr(index: FuncTypeIndex, ss: *const ScratchSpace) *Wasm.FunctionType.Index { - return &ss.func_types.items[@intFromEnum(index)]; + return &ss.func_types.items[@backingInt(index)]; } }; @@ -285,7 +285,7 @@ pub fn parse( const table_imports_start: u32 = @intCast(wasm.object_table_imports.entries.len); const data_imports_start: u32 = @intCast(wasm.object_data_imports.entries.len); const local_section_index_base = wasm.object_total_sections; - const object_index: Wasm.ObjectIndex = @enumFromInt(wasm.objects.items.len); + const object_index: Wasm.ObjectIndex = @fromBackingInt(@intCast(wasm.objects.items.len)); const source_location: Wasm.SourceLocation = .fromObject(object_index, wasm); ss.clear(); @@ -299,9 +299,9 @@ pub fn parse( var global_section_index: ?Wasm.ObjectSectionIndex = null; var data_section_index: ?Wasm.ObjectSectionIndex = null; while (pos < bytes.len) : (wasm.object_total_sections += 1) { - const section_index: Wasm.ObjectSectionIndex = @enumFromInt(wasm.object_total_sections); + const section_index: Wasm.ObjectSectionIndex = @fromBackingInt(@intCast(wasm.object_total_sections)); - const section_tag: std.wasm.Section = @enumFromInt(bytes[pos]); + const section_tag: std.wasm.Section = @fromBackingInt(@intCast(bytes[pos])); pos += 1; const len, pos = readLeb(u32, bytes, pos); @@ -316,13 +316,13 @@ pub fn parse( if (section_version != 2) return error.UnsupportedVersion; while (pos < section_end) { const sub_type, pos = readLeb(u8, bytes, pos); - log.debug("found subsection: {s}", .{@tagName(@as(SubsectionType, @enumFromInt(sub_type)))}); + log.debug("found subsection: {s}", .{@tagName(@as(SubsectionType, @fromBackingInt(@intCast(sub_type))))}); const payload_len, pos = readLeb(u32, bytes, pos); if (payload_len == 0) break; const count, pos = readLeb(u32, bytes, pos); - switch (@as(SubsectionType, @enumFromInt(sub_type))) { + switch (@as(SubsectionType, @fromBackingInt(@intCast(sub_type)))) { .segment_info => { for (try ss.segment_info.addManyAsSlice(gpa, count)) |*segment| { const name, pos = readBytes(bytes, pos); @@ -340,7 +340,7 @@ pub fn parse( .flags = .{ .strings = flags.strings, .tls = tls, - .alignment = @enumFromInt(alignment), + .alignment = @fromBackingInt(@intCast(alignment)), .retain = flags.retain, }, }; @@ -418,27 +418,27 @@ pub fn parse( const segment_offset, pos = readLeb(u32, bytes, pos); const size, pos = readLeb(u32, bytes, pos); try wasm.object_datas.append(gpa, .{ - .segment = @enumFromInt(data_segment_start + segment_index), + .segment = @fromBackingInt(@intCast(data_segment_start + segment_index)), .offset = segment_offset, .size = size, .name = interned_name, .flags = symbol.flags, }); symbol.pointee = .{ - .data = @enumFromInt(wasm.object_datas.items.len - 1), + .data = @fromBackingInt(@intCast(wasm.object_datas.items.len - 1)), }; } }, .section => { const local_section, pos = readLeb(u32, bytes, pos); - const section: Wasm.ObjectSectionIndex = @enumFromInt(local_section_index_base + local_section); + const section: Wasm.ObjectSectionIndex = @fromBackingInt(@intCast(local_section_index_base + local_section)); symbol.pointee = .{ .section = section }; }, .function => { const local_index, pos = readLeb(u32, bytes, pos); if (symbol.flags.undefined) { - const function_import: ScratchSpace.FuncImportIndex = @enumFromInt(local_index); + const function_import: ScratchSpace.FuncImportIndex = @fromBackingInt(@intCast(local_index)); symbol.pointee = .{ .function_import = function_import }; if (symbol.flags.explicit_name) { const name, pos = readBytes(bytes, pos); @@ -447,7 +447,7 @@ pub fn parse( symbol.name = function_import.ptr(ss).name.toOptional(); } } else { - symbol.pointee = .{ .function = @enumFromInt(functions_start + (local_index - ss.func_imports.items.len)) }; + symbol.pointee = .{ .function = @fromBackingInt(@intCast(functions_start + (local_index - ss.func_imports.items.len))) }; const name, pos = readBytes(bytes, pos); symbol.name = (try wasm.internString(name)).toOptional(); } @@ -455,7 +455,7 @@ pub fn parse( .global => { const local_index, pos = readLeb(u32, bytes, pos); if (symbol.flags.undefined) { - const global_import: ScratchSpace.GlobalImportIndex = @enumFromInt(local_index); + const global_import: ScratchSpace.GlobalImportIndex = @fromBackingInt(@intCast(local_index)); symbol.pointee = .{ .global_import = global_import }; if (symbol.flags.explicit_name) { const name, pos = readBytes(bytes, pos); @@ -464,7 +464,7 @@ pub fn parse( symbol.name = global_import.ptr(ss).name.toOptional(); } } else { - symbol.pointee = .{ .global = @enumFromInt(globals_start + (local_index - ss.global_imports.items.len)) }; + symbol.pointee = .{ .global = @fromBackingInt(@intCast(globals_start + (local_index - ss.global_imports.items.len))) }; const name, pos = readBytes(bytes, pos); symbol.name = (try wasm.internString(name)).toOptional(); } @@ -473,7 +473,7 @@ pub fn parse( const local_index, pos = readLeb(u32, bytes, pos); if (symbol.flags.undefined) { table_import_symbol_count += 1; - const table_import: ScratchSpace.TableImportIndex = @enumFromInt(local_index); + const table_import: ScratchSpace.TableImportIndex = @fromBackingInt(@intCast(local_index)); symbol.pointee = .{ .table_import = table_import }; if (symbol.flags.explicit_name) { const name, pos = readBytes(bytes, pos); @@ -482,13 +482,13 @@ pub fn parse( symbol.name = table_import.ptr(ss).name.toOptional(); } } else { - symbol.pointee = .{ .table = @enumFromInt(tables_start + (local_index - ss.table_imports.items.len)) }; + symbol.pointee = .{ .table = @fromBackingInt(@intCast(tables_start + (local_index - ss.table_imports.items.len))) }; const name, pos = readBytes(bytes, pos); symbol.name = (try wasm.internString(name)).toOptional(); } }, else => { - log.debug("unrecognized symbol type tag: {x}", .{@intFromEnum(tag)}); + log.debug("unrecognized symbol type tag: {x}", .{@backingInt(tag)}); return error.UnrecognizedSymbolType; }, } @@ -506,14 +506,14 @@ pub fn parse( // "Relocation sections can only target code, data and custom sections." const local_section, pos = readLeb(u32, bytes, pos); const count, pos = readLeb(u32, bytes, pos); - const section: Wasm.ObjectSectionIndex = @enumFromInt(local_section_index_base + local_section); + const section: Wasm.ObjectSectionIndex = @fromBackingInt(@intCast(local_section_index_base + local_section)); log.debug("found {d} relocations for section={d}", .{ count, section }); var prev_offset: u32 = 0; try wasm.object_relocations.ensureUnusedCapacity(gpa, count); for (0..count) |_| { - const tag: RelocationType = @enumFromInt(bytes[pos]); + const tag: RelocationType = @fromBackingInt(@intCast(bytes[pos])); pos += 1; const offset, pos = readLeb(u32, bytes, pos); const index, pos = readLeb(u32, bytes, pos); @@ -668,7 +668,7 @@ pub fn parse( try wasm.object_custom_segments.put(gpa, section_index, .{ .payload = .{ - .off = @enumFromInt(data_off), + .off = @fromBackingInt(@intCast(data_off)), .len = @intCast(debug_content.len), }, .flags = .{}, @@ -706,7 +706,7 @@ pub fn parse( try ss.func_imports.append(gpa, .{ .module_name = interned_module_name, .name = interned_name, - .function_index = @enumFromInt(function), + .function_index = @fromBackingInt(@intCast(function)), }); }, .memory => { @@ -766,7 +766,7 @@ pub fn parse( const functions_len, pos = readLeb(u32, bytes, pos); for (try ss.func_type_indexes.addManyAsSlice(gpa, functions_len)) |*func_type_index| { const i, pos = readLeb(u32, bytes, pos); - func_type_index.* = @enumFromInt(i); + func_type_index.* = @fromBackingInt(@intCast(i)); } }, .table => { @@ -837,23 +837,23 @@ pub fn parse( // existing symbol table data if the name matches. for (try ss.exports.addManyAsSlice(gpa, exports_len)) |*exp| { const name, pos = readBytes(bytes, pos); - const kind: std.wasm.ExternalKind = @enumFromInt(bytes[pos]); + const kind: std.wasm.ExternalKind = @fromBackingInt(@intCast(bytes[pos])); pos += 1; const index, pos = readLeb(u32, bytes, pos); exp.* = .{ .name = try wasm.internString(name), .pointee = switch (kind) { - .function => .{ .function = @enumFromInt(functions_start + (index - ss.func_imports.items.len)) }, - .table => .{ .table = @enumFromInt(tables_start + (index - ss.table_imports.items.len)) }, - .memory => .{ .memory = @enumFromInt(memories_start + index) }, - .global => .{ .global = @enumFromInt(globals_start + (index - ss.global_imports.items.len)) }, + .function => .{ .function = @fromBackingInt(@intCast(functions_start + (index - ss.func_imports.items.len))) }, + .table => .{ .table = @fromBackingInt(@intCast(tables_start + (index - ss.table_imports.items.len))) }, + .memory => .{ .memory = @fromBackingInt(@intCast(memories_start + index)) }, + .global => .{ .global = @fromBackingInt(@intCast(globals_start + (index - ss.global_imports.items.len))) }, }, }; } }, .start => { const index, pos = readLeb(u32, bytes, pos); - start_function = @enumFromInt(functions_start + index); + start_function = @fromBackingInt(@intCast(functions_start + index)); }, .element => { log.warn("unimplemented: element section in {f} {?s}", .{ path, archive_member_name }); @@ -1000,7 +1000,7 @@ pub fn parse( .no_strip = true, }, .name = table_import_name.toOptional(), - .pointee = .{ .table_import = @enumFromInt(0) }, + .pointee = .{ .table_import = @fromBackingInt(@intCast(0)) }, }); } @@ -1482,7 +1482,7 @@ fn readBytes(bytes: []const u8, start_pos: usize) struct { []const u8, usize } { fn readEnum(comptime T: type, bytes: []const u8, pos: usize) struct { T, usize } { const Tag = @typeInfo(T).@"enum".tag_type; const int, const new_pos = readLeb(Tag, bytes, pos); - return .{ @enumFromInt(int), new_pos }; + return .{ @fromBackingInt(@intCast(int)), new_pos }; } fn readLimits(bytes: []const u8, start_pos: usize) struct { std.wasm.Limits, usize } { @@ -1503,7 +1503,7 @@ fn readInit(wasm: *Wasm, bytes: []const u8, pos: usize) !struct { Wasm.Expr, usi pub fn exprEndPos(bytes: []const u8, pos: usize) error{InvalidInitOpcode}!usize { const opcode = bytes[pos]; - return switch (@as(std.wasm.Opcode, @enumFromInt(opcode))) { + return switch (@as(std.wasm.Opcode, @fromBackingInt(@intCast(opcode)))) { .i32_const => readLeb(i32, bytes, pos + 1)[1], .i64_const => readLeb(i64, bytes, pos + 1)[1], .f32_const => pos + 5, diff --git a/src/main.zig b/src/main.zig index 22c3ab516de08176233f3866667bf82a2f524d55..4fe6de03247578285c251daed3eb8d3982ac5dca 100644 --- a/src/main.zig +++ b/src/main.zig @@ -140,8 +140,8 @@ pub fn log( // Hide debug messages unless: // * logging enabled with `-Dlog`. // * the --debug-log arg for the scope has been provided - if (@intFromEnum(level) > @intFromEnum(std.options.log_level) or - @intFromEnum(level) > @intFromEnum(std.log.Level.info)) + if (@backingInt(level) > @backingInt(std.options.log_level) or + @backingInt(level) > @backingInt(std.log.Level.info)) { if (!build_options.enable_logging) return; @@ -4420,7 +4420,7 @@ fn serve( } }, else => { - fatal("unrecognized message from client: 0x{x}", .{@intFromEnum(hdr.tag)}); + fatal("unrecognized message from client: 0x{x}", .{@backingInt(hdr.tag)}); }, } } @@ -5732,8 +5732,8 @@ fn cmdChangelist(arena: Allocator, io: Io, args: []const []const u8, environ_map var it = inst_map.iterator(); while (it.next()) |entry| { try stdout_bw.print(" %{d} => %{d}\n", .{ - @intFromEnum(entry.key_ptr.*), - @intFromEnum(entry.value_ptr.*), + @backingInt(entry.key_ptr.*), + @backingInt(entry.value_ptr.*), }); } } diff --git a/src/print_zir.zig b/src/print_zir.zig index 375210445b0a3efcc9615c180d5e4c721b8b3b09..ea82384d5057241deca5637307e016633173c7a3 100644 --- a/src/print_zir.zig +++ b/src/print_zir.zig @@ -26,10 +26,10 @@ pub fn renderAsText(gpa: Allocator, tree: ?Ast, zir: Zir, bw: *std.Io.Writer) !v }; const main_struct_inst: Zir.Inst.Index = .main_struct_inst; - try bw.print("%{d} ", .{@intFromEnum(main_struct_inst)}); + try bw.print("%{d} ", .{@backingInt(main_struct_inst)}); try writer.writeInstToStream(bw, main_struct_inst); try bw.writeAll("\n"); - const imports_index = zir.extra[@intFromEnum(Zir.ExtraIndex.imports)]; + const imports_index = zir.extra[@backingInt(Zir.ExtraIndex.imports)]; if (imports_index != 0) { try bw.writeAll("Imports:\n"); @@ -75,7 +75,7 @@ pub fn renderInstructionContext( try writer.writeBody(bw, block[0..block_index]); try bw.splatByteAll(' ', writer.indent - 2); - try bw.print("> %{d} ", .{@intFromEnum(block[block_index])}); + try bw.print("> %{d} ", .{@backingInt(block[block_index])}); try writer.writeInstToStream(bw, block[block_index]); try bw.writeByte('\n'); if (block_index + 1 < block.len) { @@ -105,7 +105,7 @@ pub fn renderSingleInstruction( .recurse_blocks = false, }; - try bw.print("%{d} ", .{@intFromEnum(inst)}); + try bw.print("%{d} ", .{@backingInt(inst)}); try writer.writeInstToStream(bw, inst); } @@ -184,8 +184,8 @@ const Writer = struct { inst: Zir.Inst.Index, ) Error!void { const tags = self.code.instructions.items(.tag); - const tag = tags[@intFromEnum(inst)]; - try stream.print("= {s}(", .{@tagName(tags[@intFromEnum(inst)])}); + const tag = tags[@backingInt(inst)]; + try stream.print("= {s}(", .{@tagName(tags[@backingInt(inst)])}); switch (tag) { .alloc, .alloc_mut, @@ -510,7 +510,7 @@ const Writer = struct { } fn writeExtended(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const extended = self.code.instructions.items(.data)[@intFromEnum(inst)].extended; + const extended = self.code.instructions.items(.data)[@backingInt(inst)].extended; try stream.print("{s}(", .{@tagName(extended.opcode)}); switch (extended.opcode) { .this, @@ -593,7 +593,7 @@ const Writer = struct { }, .round_op => { - const round_op: Zir.Inst.RoundOp = @enumFromInt(extended.small); + const round_op: Zir.Inst.RoundOp = @fromBackingInt(@intCast(extended.small)); const inst_data = self.code.extraData(Zir.Inst.BinNode, extended.operand).data; try stream.print("{s}, ", .{@tagName(round_op)}); try self.writeInstRef(stream, inst_data.lhs); @@ -604,7 +604,7 @@ const Writer = struct { }, .reify_slice_arg_ty => { - const reify_slice_arg_info: Zir.Inst.ReifySliceArgInfo = @enumFromInt(extended.small); + const reify_slice_arg_info: Zir.Inst.ReifySliceArgInfo = @fromBackingInt(@intCast(extended.small)); const extra = self.code.extraData(Zir.Inst.UnNode, extended.operand).data; try stream.print("{t}, ", .{reify_slice_arg_info}); try self.writeInstRef(stream, extra.operand); @@ -638,7 +638,7 @@ const Writer = struct { }, .reify_struct => { const extra = self.code.extraData(Zir.Inst.ReifyStruct, extended.operand).data; - const name_strat: Zir.Inst.NameStrategy = @enumFromInt(extended.small); + const name_strat: Zir.Inst.NameStrategy = @fromBackingInt(@intCast(extended.small)); try stream.print("line({d}), {t}, ", .{ extra.src_line, name_strat }); try self.writeInstRef(stream, extra.layout); try stream.writeAll(", "); @@ -657,7 +657,7 @@ const Writer = struct { }, .reify_union => { const extra = self.code.extraData(Zir.Inst.ReifyUnion, extended.operand).data; - const name_strat: Zir.Inst.NameStrategy = @enumFromInt(extended.small); + const name_strat: Zir.Inst.NameStrategy = @fromBackingInt(@intCast(extended.small)); try stream.print("line({d}), {t}, ", .{ extra.src_line, name_strat }); try self.writeInstRef(stream, extra.layout); try stream.writeAll(", "); @@ -676,7 +676,7 @@ const Writer = struct { }, .reify_enum => { const extra = self.code.extraData(Zir.Inst.ReifyEnum, extended.operand).data; - const name_strat: Zir.Inst.NameStrategy = @enumFromInt(extended.small); + const name_strat: Zir.Inst.NameStrategy = @fromBackingInt(@intCast(extended.small)); try stream.print("line({d}), {t}, ", .{ extra.src_line, name_strat }); try self.writeInstRef(stream, extra.tag_ty); try stream.writeAll(", "); @@ -719,14 +719,14 @@ const Writer = struct { fn writeExtNode(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void { try stream.writeAll(")) "); - const src_node: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); try self.writeSrcNode(stream, src_node); } fn writeArrayInitElemType(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].bin; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].bin; try self.writeInstRef(stream, inst_data.lhs); - try stream.print(", {d})", .{@intFromEnum(inst_data.rhs)}); + try stream.print(", {d})", .{@backingInt(inst_data.rhs)}); } fn writeUnNode( @@ -734,7 +734,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].un_node; try self.writeInstRef(stream, inst_data.operand); try stream.writeAll(") "); try self.writeSrcNode(stream, inst_data.src_node); @@ -745,7 +745,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].un_tok; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].un_tok; try self.writeInstRef(stream, inst_data.operand); try stream.writeAll(") "); try self.writeSrcTok(stream, inst_data.src_tok); @@ -756,7 +756,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.ValidateDestructure, inst_data.payload_index).data; try self.writeInstRef(stream, extra.operand); try stream.print(", {d}) (destructure=", .{extra.expect_len}); @@ -770,7 +770,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.ArrayInit, inst_data.payload_index).data; try self.writeInstRef(stream, extra.ty); try stream.print(", {d}) ", .{extra.init_count}); @@ -782,7 +782,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.ArrayTypeSentinel, inst_data.payload_index).data; try self.writeInstRef(stream, extra.len); try stream.writeAll(", "); @@ -798,7 +798,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].ptr_type; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].ptr_type; const str_allowzero = if (inst_data.flags.is_allowzero) "allowzero, " else ""; const str_const = if (!inst_data.flags.is_mutable) "const, " else ""; const str_volatile = if (inst_data.flags.is_volatile) "volatile, " else ""; @@ -813,25 +813,25 @@ const Writer = struct { var extra_index = extra.end; if (inst_data.flags.has_sentinel) { try stream.writeAll(", "); - try self.writeInstRef(stream, @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]))); + try self.writeInstRef(stream, @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index])))); extra_index += 1; } if (inst_data.flags.has_align) { try stream.writeAll(", align("); - try self.writeInstRef(stream, @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]))); + try self.writeInstRef(stream, @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index])))); extra_index += 1; if (inst_data.flags.has_bit_range) { const bit_start = extra_index + @intFromBool(inst_data.flags.has_addrspace); try stream.writeAll(":"); - try self.writeInstRef(stream, @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[bit_start]))); + try self.writeInstRef(stream, @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[bit_start])))); try stream.writeAll(":"); - try self.writeInstRef(stream, @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[bit_start + 1]))); + try self.writeInstRef(stream, @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[bit_start + 1])))); } try stream.writeAll(")"); } if (inst_data.flags.has_addrspace) { try stream.writeAll(", addrspace("); - try self.writeInstRef(stream, @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index]))); + try self.writeInstRef(stream, @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index])))); try stream.writeAll(")"); } try stream.writeAll(") "); @@ -839,14 +839,14 @@ const Writer = struct { } fn writeInt(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].int; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].int; try stream.print("{d})", .{inst_data}); } fn writeIntBig(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].str; const byte_count = inst_data.len * @sizeOf(std.math.big.Limb); - const limb_bytes = self.code.string_bytes[@intFromEnum(inst_data.start)..][0..byte_count]; + const limb_bytes = self.code.string_bytes[@backingInt(inst_data.start)..][0..byte_count]; // limb_bytes is not aligned properly; we must allocate and copy the bytes // in order to accomplish this. const limbs = try self.gpa.alloc(std.math.big.Limb, inst_data.len); @@ -863,12 +863,12 @@ const Writer = struct { } fn writeFloat(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const number = self.code.instructions.items(.data)[@intFromEnum(inst)].float; + const number = self.code.instructions.items(.data)[@backingInt(inst)].float; try stream.print("{d})", .{number}); } fn writeFloat128(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Float128, inst_data.payload_index).data; const number = extra.get(); // TODO improve std.format to be able to print f128 values @@ -881,13 +881,13 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].str; const str = inst_data.get(self.code); try stream.print("\"{f}\")", .{std.zig.fmtString(str)}); } fn writeSliceStart(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.SliceStart, inst_data.payload_index).data; try self.writeInstRef(stream, extra.lhs); try stream.writeAll(", "); @@ -897,7 +897,7 @@ const Writer = struct { } fn writeSliceEnd(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.SliceEnd, inst_data.payload_index).data; try self.writeInstRef(stream, extra.lhs); try stream.writeAll(", "); @@ -909,7 +909,7 @@ const Writer = struct { } fn writeSliceSentinel(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.SliceSentinel, inst_data.payload_index).data; try self.writeInstRef(stream, extra.lhs); try stream.writeAll(", "); @@ -923,7 +923,7 @@ const Writer = struct { } fn writeSliceLength(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.SliceLength, inst_data.payload_index).data; try self.writeInstRef(stream, extra.lhs); try stream.writeAll(", "); @@ -939,7 +939,7 @@ const Writer = struct { } fn writeUnionInit(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.UnionInit, inst_data.payload_index).data; try self.writeInstRef(stream, extra.union_type); try stream.writeAll(", "); @@ -951,7 +951,7 @@ const Writer = struct { } fn writeShuffle(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Shuffle, inst_data.payload_index).data; try self.writeInstRef(stream, extra.elem_type); try stream.writeAll(", "); @@ -978,7 +978,7 @@ const Writer = struct { } fn writeMulAdd(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.MulAdd, inst_data.payload_index).data; try self.writeInstRef(stream, extra.mulend1); try stream.writeAll(", "); @@ -990,7 +990,7 @@ const Writer = struct { } fn writeFromBackingInt(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.FromBackingInt, inst_data.payload_index); try self.writeInstRef(stream, extra.data.result_type); try stream.writeAll(", "); @@ -1000,7 +1000,7 @@ const Writer = struct { } fn writeBuiltinCall(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.BuiltinCall, inst_data.payload_index).data; try self.writeFlag(stream, "nodiscard ", extra.flags.ensure_result_used); @@ -1033,7 +1033,7 @@ const Writer = struct { } fn writeParam(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_tok; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_tok; const extra = self.code.extraData(Zir.Inst.Param, inst_data.payload_index); const body = self.code.bodySlice(extra.end, extra.data.type.body_len); try stream.print("\"{f}\", ", .{ @@ -1048,7 +1048,7 @@ const Writer = struct { } fn writePlNodeBin(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Bin, inst_data.payload_index).data; try self.writeInstRef(stream, extra.lhs); try stream.writeAll(", "); @@ -1058,7 +1058,7 @@ const Writer = struct { } fn writePlNodeMultiOp(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index); const args = self.code.refSlice(extra.end, extra.data.operands_len); try stream.writeAll("{"); @@ -1071,13 +1071,13 @@ const Writer = struct { } fn writeElemValImm(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].elem_val_imm; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].elem_val_imm; try self.writeInstRef(stream, inst_data.operand); try stream.print(", {d})", .{inst_data.idx}); } fn writeArrayInitElemPtr(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.ElemPtrImm, inst_data.payload_index).data; try self.writeInstRef(stream, extra.ptr); @@ -1086,7 +1086,7 @@ const Writer = struct { } fn writePlNodeExport(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Export, inst_data.payload_index).data; try self.writeInstRef(stream, extra.exported); @@ -1097,7 +1097,7 @@ const Writer = struct { } fn writeValidateArrayInitRefTy(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.ArrayInitRefTy, inst_data.payload_index).data; try self.writeInstRef(stream, extra.ptr_ty); @@ -1107,7 +1107,7 @@ const Writer = struct { } fn writeStructInit(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.StructInit, inst_data.payload_index); var field_i: u32 = 0; var extra_index = extra.end; @@ -1174,7 +1174,7 @@ const Writer = struct { } fn writeAtomicLoad(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.AtomicLoad, inst_data.payload_index).data; try self.writeInstRef(stream, extra.elem_type); @@ -1187,7 +1187,7 @@ const Writer = struct { } fn writeAtomicStore(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.AtomicStore, inst_data.payload_index).data; try self.writeInstRef(stream, extra.ptr); @@ -1200,7 +1200,7 @@ const Writer = struct { } fn writeAtomicRmw(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.AtomicRmw, inst_data.payload_index).data; try self.writeInstRef(stream, extra.ptr); @@ -1215,7 +1215,7 @@ const Writer = struct { } fn writeStructInitAnon(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.StructInitAnon, inst_data.payload_index); var field_i: u32 = 0; var extra_index = extra.end; @@ -1236,7 +1236,7 @@ const Writer = struct { } fn writeStructInitFieldType(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.FieldType, inst_data.payload_index).data; try self.writeInstRef(stream, extra.container_type); const field_name = self.code.nullTerminatedString(extra.name_start); @@ -1245,7 +1245,7 @@ const Writer = struct { } fn writeFieldTypeRef(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.FieldTypeRef, inst_data.payload_index).data; try self.writeInstRef(stream, extra.container_type); try stream.writeAll(", "); @@ -1271,7 +1271,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].inst_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].inst_node; try self.writeInstIndex(stream, inst_data.inst); try stream.writeAll(") "); try self.writeSrcNode(stream, inst_data.src_node); @@ -1288,7 +1288,7 @@ const Writer = struct { try self.writeFlag(stream, "volatile, ", small.is_volatile); if (tmpl_is_expr) { - try self.writeInstRef(stream, @enumFromInt(@intFromEnum(extra.data.asm_source))); + try self.writeInstRef(stream, @fromBackingInt(@intCast(@backingInt(extra.data.asm_source)))); } else { const asm_source = self.code.nullTerminatedString(extra.data.asm_source); try stream.print("\"{f}\"", .{std.zig.fmtString(asm_source)}); @@ -1354,7 +1354,7 @@ const Writer = struct { inst: Zir.Inst.Index, comptime kind: enum { direct, field }, ) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const ExtraType = switch (kind) { .direct => Zir.Inst.Call, .field => Zir.Inst.FieldCall, @@ -1366,7 +1366,7 @@ const Writer = struct { if (extra.data.flags.ensure_result_used) { try stream.writeAll("nodiscard "); } - try stream.print(".{s}, ", .{@tagName(@as(std.lang.CallModifier, @enumFromInt(extra.data.flags.packed_modifier)))}); + try stream.print(".{s}, ", .{@tagName(@as(std.lang.CallModifier, @fromBackingInt(@intCast(extra.data.flags.packed_modifier))))}); switch (kind) { .direct => try self.writeInstRef(stream, extra.data.callee), .field => { @@ -1402,7 +1402,7 @@ const Writer = struct { } fn writeBlock(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Block, inst_data.payload_index); const body = self.code.bodySlice(extra.end, extra.data.body_len); try self.writeBracedBody(stream, body); @@ -1411,7 +1411,7 @@ const Writer = struct { } fn writeBlockComptime(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.BlockComptime, inst_data.payload_index); const body = self.code.bodySlice(extra.end, extra.data.body_len); try stream.print("reason={s}, ", .{@tagName(extra.data.reason)}); @@ -1421,7 +1421,7 @@ const Writer = struct { } fn writeCondBr(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.CondBr, inst_data.payload_index); const then_body = self.code.bodySlice(extra.end, extra.data.then_body_len); const else_body = self.code.bodySlice(extra.end + then_body.len, extra.data.else_body_len); @@ -1435,7 +1435,7 @@ const Writer = struct { } fn writeTry(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Try, inst_data.payload_index); const body = self.code.bodySlice(extra.end, extra.data.body_len); try self.writeInstRef(stream, extra.data.operand); @@ -1661,9 +1661,9 @@ const Writer = struct { extra_index += 2; try stream.print("@\"{d}\": ", .{field_idx}); - try self.writeInstRef(stream, @enumFromInt(field_ty)); + try self.writeInstRef(stream, @fromBackingInt(@intCast(field_ty))); try stream.writeAll(" = "); - try self.writeInstRef(stream, @enumFromInt(field_init)); + try self.writeInstRef(stream, @fromBackingInt(@intCast(field_init))); } try stream.writeAll(" }) "); @@ -1676,7 +1676,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.ErrorSetDecl, inst_data.payload_index); try stream.writeAll("{\n"); @@ -1685,7 +1685,7 @@ const Writer = struct { var extra_index = @as(u32, @intCast(extra.end)); const extra_index_end = extra_index + extra.data.fields_len; while (extra_index < extra_index_end) : (extra_index += 1) { - const name_index: Zir.NullTerminatedString = @enumFromInt(self.code.extra[extra_index]); + const name_index: Zir.NullTerminatedString = @fromBackingInt(@intCast(self.code.extra[extra_index])); const name = self.code.nullTerminatedString(name_index); try stream.splatByteAll(' ', self.indent); try stream.print("{f},\n", .{std.zig.fmtIdP(name)}); @@ -1835,7 +1835,7 @@ const Writer = struct { } fn writePlNodeField(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Field, inst_data.payload_index).data; const name = self.code.nullTerminatedString(extra.field_name_start); try self.writeInstRef(stream, extra.lhs); @@ -1844,7 +1844,7 @@ const Writer = struct { } fn writePlNodeFieldNamed(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.FieldNamed, inst_data.payload_index).data; try self.writeInstRef(stream, extra.lhs); try stream.writeAll(", "); @@ -1854,7 +1854,7 @@ const Writer = struct { } fn writeAs(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.As, inst_data.payload_index).data; try self.writeInstRef(stream, extra.dest_type); try stream.writeAll(", "); @@ -1868,7 +1868,7 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const src_node = self.code.instructions.items(.data)[@intFromEnum(inst)].node; + const src_node = self.code.instructions.items(.data)[@backingInt(inst)].node; try stream.writeAll(") "); try self.writeSrcNode(stream, src_node); } @@ -1878,14 +1878,14 @@ const Writer = struct { stream: *std.Io.Writer, inst: Zir.Inst.Index, ) Error!void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_tok; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].str_tok; const str = inst_data.get(self.code); try stream.print("\"{f}\") ", .{std.zig.fmtString(str)}); try self.writeSrcTok(stream, inst_data.src_tok); } fn writeStrOp(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].str_op; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].str_op; const str = inst_data.getStr(self.code); try self.writeInstRef(stream, inst_data.operand); try stream.print(", \"{f}\")", .{std.zig.fmtString(str)}); @@ -1897,7 +1897,7 @@ const Writer = struct { inst: Zir.Inst.Index, inferred_error_set: bool, ) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.Func, inst_data.payload_index); var extra_index = extra.end; @@ -1909,7 +1909,7 @@ const Writer = struct { ret_ty_ref = .void_type; }, 1 => { - ret_ty_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index])); + ret_ty_ref = @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index]))); extra_index += 1; }, else => { @@ -1945,7 +1945,7 @@ const Writer = struct { } fn writeFuncFancy(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.FuncFancy, inst_data.payload_index); var extra_index: usize = extra.end; @@ -1960,7 +1960,7 @@ const Writer = struct { cc_body = self.code.bodySlice(extra_index, body_len); extra_index += cc_body.len; } else if (extra.data.bits.has_cc_ref) { - cc_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index])); + cc_ref = @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index]))); extra_index += 1; } if (extra.data.bits.has_ret_ty_body) { @@ -1969,7 +1969,7 @@ const Writer = struct { ret_ty_body = self.code.bodySlice(extra_index, body_len); extra_index += ret_ty_body.len; } else if (extra.data.bits.has_ret_ty_ref) { - ret_ty_ref = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index])); + ret_ty_ref = @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index]))); extra_index += 1; } @@ -2009,12 +2009,12 @@ const Writer = struct { var extra_index: usize = extra.end; const type_inst: Zir.Inst.Ref = if (!small.has_type) .none else blk: { - const type_inst = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index])); + const type_inst = @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index]))); extra_index += 1; break :blk type_inst; }; const align_inst: Zir.Inst.Ref = if (!small.has_align) .none else blk: { - const align_inst = @as(Zir.Inst.Ref, @enumFromInt(self.code.extra[extra_index])); + const align_inst = @as(Zir.Inst.Ref, @fromBackingInt(@intCast(self.code.extra[extra_index]))); extra_index += 1; break :blk align_inst; }; @@ -2040,7 +2040,7 @@ const Writer = struct { } fn writeBoolBr(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.BoolBr, inst_data.payload_index); const body = self.code.bodySlice(extra.end, extra.data.body_len); try self.writeInstRef(stream, extra.data.lhs); @@ -2051,7 +2051,7 @@ const Writer = struct { } fn writeIntType(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const int_type = self.code.instructions.items(.data)[@intFromEnum(inst)].int_type; + const int_type = self.code.instructions.items(.data)[@backingInt(inst)].int_type; const prefix: u8 = switch (int_type.signedness) { .signed => 'i', .unsigned => 'u', @@ -2061,7 +2061,7 @@ const Writer = struct { } fn writeSaveErrRetIndex(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].save_err_ret_index; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].save_err_ret_index; try self.writeInstRef(stream, inst_data.operand); @@ -2079,7 +2079,7 @@ const Writer = struct { } fn writeBreak(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"break"; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].@"break"; const extra = self.code.extraData(Zir.Inst.Break, inst_data.payload_index).data; try self.writeInstIndex(stream, extra.block_inst); @@ -2089,7 +2089,7 @@ const Writer = struct { } fn writeArrayInit(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index); const args = self.code.refSlice(extra.end, extra.data.operands_len); @@ -2105,7 +2105,7 @@ const Writer = struct { } fn writeArrayInitAnon(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index); const args = self.code.refSlice(extra.end, extra.data.operands_len); @@ -2120,7 +2120,7 @@ const Writer = struct { } fn writeArrayInitSent(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_node; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_node; const extra = self.code.extraData(Zir.Inst.MultiOp, inst_data.payload_index); const args = self.code.refSlice(extra.end, extra.data.operands_len); @@ -2140,7 +2140,7 @@ const Writer = struct { } fn writeUnreachable(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"unreachable"; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].@"unreachable"; try stream.writeAll(") "); try self.writeSrcNode(stream, inst_data.src_node); } @@ -2185,12 +2185,12 @@ const Writer = struct { } fn writeDbgStmt(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].dbg_stmt; try stream.print("{d}, {d})", .{ inst_data.line + 1, inst_data.column + 1 }); } fn writeDefer(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].@"defer"; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].@"defer"; const body = self.code.bodySlice(inst_data.index, inst_data.len); try self.writeBracedBody(stream, body); try stream.writeByte(')'); @@ -2254,20 +2254,20 @@ const Writer = struct { fn writeClosureGet(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void { try stream.print("{d})) ", .{extended.small}); - const src_node: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); try self.writeSrcNode(stream, src_node); } fn writeStdLangValue(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void { - const val: Zir.Inst.StdLangValue = @enumFromInt(extended.small); + const val: Zir.Inst.StdLangValue = @fromBackingInt(@intCast(extended.small)); try stream.print("{s})) ", .{@tagName(val)}); - const src_node: Ast.Node.Offset = @enumFromInt(@as(i32, @bitCast(extended.operand))); + const src_node: Ast.Node.Offset = @fromBackingInt(@intCast(@as(i32, @bitCast(extended.operand)))); try self.writeSrcNode(stream, src_node); } fn writeInplaceArithResultTy(self: *Writer, stream: *std.Io.Writer, extended: Zir.Inst.Extended.InstData) !void { - const op: Zir.Inst.InplaceOp = @enumFromInt(extended.small); - try self.writeInstRef(stream, @enumFromInt(extended.operand)); + const op: Zir.Inst.InplaceOp = @fromBackingInt(@intCast(extended.small)); + try self.writeInstRef(stream, @fromBackingInt(@intCast(extended.operand))); try stream.print(", {s}))", .{@tagName(op)}); } @@ -2277,14 +2277,14 @@ const Writer = struct { } else if (ref.toIndex()) |i| { return self.writeInstIndex(stream, i); } else { - const val: InternPool.Index = @enumFromInt(@intFromEnum(ref)); + const val: InternPool.Index = @fromBackingInt(@intCast(@backingInt(ref))); return stream.print("@{s}", .{@tagName(val)}); } } fn writeInstIndex(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { _ = self; - return stream.print("%{d}", .{@intFromEnum(inst)}); + return stream.print("%{d}", .{@backingInt(inst)}); } fn writeCaptures(self: *Writer, stream: *std.Io.Writer, captures: []const Zir.Inst.Capture, capture_names: []const Zir.NullTerminatedString) !void { @@ -2436,14 +2436,14 @@ const Writer = struct { fn writeBody(self: *Writer, stream: *std.Io.Writer, body: []const Zir.Inst.Index) !void { for (body) |inst| { try stream.splatByteAll(' ', self.indent); - try stream.print("%{d} ", .{@intFromEnum(inst)}); + try stream.print("%{d} ", .{@backingInt(inst)}); try self.writeInstToStream(stream, inst); try stream.writeByte('\n'); } } fn writeImport(self: *Writer, stream: *std.Io.Writer, inst: Zir.Inst.Index) !void { - const inst_data = self.code.instructions.items(.data)[@intFromEnum(inst)].pl_tok; + const inst_data = self.code.instructions.items(.data)[@backingInt(inst)].pl_tok; const extra = self.code.extraData(Zir.Inst.Import, inst_data.payload_index).data; try self.writeInstRef(stream, extra.res_ty); const import_path = self.code.nullTerminatedString(extra.path); diff --git a/src/print_zoir.zig b/src/print_zoir.zig index 9fdaa396519893606a9860c3c44d59cbf82d1b43..93b4553b91ef13048989775d0c67b73574fd161c 100644 --- a/src/print_zoir.zig +++ b/src/print_zoir.zig @@ -55,7 +55,7 @@ const PrintZon = struct { fn renderNode(pz: *PrintZon, node: Zoir.Node.Index) Error!void { const zoir = pz.zoir; - try pz.w.print("%{d} = ", .{@intFromEnum(node)}); + try pz.w.print("%{d} = ", .{@backingInt(node)}); switch (node.get(zoir)) { .true => try pz.w.writeAll("true"), .false => try pz.w.writeAll("false"), diff --git a/src/register_manager.zig b/src/register_manager.zig index dc08194ad5556f90becd7ba3c98e2b9562218cd3..0a7a33e3ab317463f7f5332959b6a1d6f6812404 100644 --- a/src/register_manager.zig +++ b/src/register_manager.zig @@ -381,7 +381,7 @@ const MockRegister1 = enum(u2) { r3, pub fn id(reg: MockRegister1) u2 { - return @intFromEnum(reg); + return @backingInt(reg); } const allocatable_registers = [_]MockRegister1{ .r2, .r3 }; @@ -409,7 +409,7 @@ const MockRegister2 = enum(u2) { r3, pub fn id(reg: MockRegister2) u2 { - return @intFromEnum(reg); + return @backingInt(reg); } const allocatable_registers = [_]MockRegister2{ .r0, .r1, .r2, .r3 }; @@ -441,14 +441,14 @@ const MockRegister3 = enum(u3) { x3, pub fn id(reg: MockRegister3) u3 { - return switch (@intFromEnum(reg)) { - 0...3 => @as(u3, @as(u2, @truncate(@intFromEnum(reg)))), - 4...7 => @intFromEnum(reg), + return switch (@backingInt(reg)) { + 0...3 => @as(u3, @as(u2, @truncate(@backingInt(reg)))), + 4...7 => @backingInt(reg), }; } pub fn enc(reg: MockRegister3) u2 { - return @as(u2, @truncate(@intFromEnum(reg))); + return @as(u2, @truncate(@backingInt(reg))); } const gp_regs = [_]MockRegister3{ .r0, .r1, .r2, .r3 }; diff --git a/src/target.zig b/src/target.zig index 7c568d239bf978ac342e6466224110ccafc7788b..ca3b3d93de1a74114d621c8065e96d561e413dc8 100644 --- a/src/target.zig +++ b/src/target.zig @@ -636,8 +636,8 @@ pub fn shouldBlockPointerOps(target: *const std.Target, as: AddressSpace) bool { // Physical pointers always support operations .global, .physical_storage_buffer => false, // Logical pointers that support operations with VariablePointers capability - .shared => !target.cpu.features.isEnabled(@intFromEnum(std.Target.spirv.Feature.variable_pointers)), - .storage_buffer => !target.cpu.features.isEnabled(@intFromEnum(std.Target.spirv.Feature.variable_pointers)), + .shared => !target.cpu.features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)), + .storage_buffer => !target.cpu.features.isEnabled(@backingInt(std.Target.spirv.Feature.variable_pointers)), // Logical pointers that never support operations .constant, .local, @@ -678,7 +678,7 @@ pub fn isDynamicAMDGCNFeature(target: *const std.Target, feature: std.Target.Cpu &std.Target.amdgcn.cpu.gfx1200, &std.Target.amdgcn.cpu.gfx1201, }; - const feature_tag: std.Target.amdgcn.Feature = @enumFromInt(feature.index); + const feature_tag: std.Target.amdgcn.Feature = @fromBackingInt(@intCast(feature.index)); if (feature_tag == .sramecc) { if (std.mem.indexOfScalar( diff --git a/test/behavior/call.zig b/test/behavior/call.zig index 4846d475af9548e24a518ff035a6288aa64c7352..94e19e723d60cb8cdf2f5cfc1aaa7306ec7bbd81 100644 --- a/test/behavior/call.zig +++ b/test/behavior/call.zig @@ -372,11 +372,11 @@ test "Enum constructed by @Enum passed as generic argument" { alive: bool, }); fn foo(comptime a: E, b: u32) !void { - try expect(@intFromEnum(a) == b); + try expect(@backingInt(a) == b); } }; inline for (@typeInfo(S.E).@"enum".field_names, 0..) |_, i| { - try S.foo(@as(S.E, @enumFromInt(i)), i); + try S.foo(@as(S.E, @fromBackingInt(@intCast(i))), i); } } diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index c2604072144f4b65cd34e622acc8a29c49c559f8..192afbe68d030d894827f1b0caa642ba8f79ff0c 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -440,7 +440,7 @@ test "*usize to *void" { test "@enumFromInt passed a comptime_int to an enum with one item" { const E = enum { A }; - const x = @as(E, @enumFromInt(0)); + const x = @as(E, @fromBackingInt(@intCast(0))); try expect(x == E.A); } @@ -2709,7 +2709,7 @@ test "cast builtins can wrap result in optional" { const S = struct { const MyEnum = enum(u32) { _ }; fn a() ?MyEnum { - return @enumFromInt(123); + return @fromBackingInt(@intCast(123)); } fn b() ?u32 { return @intFromFloat(42.50); @@ -2728,7 +2728,7 @@ test "cast builtins can wrap result in optional" { comptime assert(@TypeOf(rb) == u32); comptime assert(@TypeOf(rc) == *const f32); - try expect(@intFromEnum(ra) == 123); + try expect(@backingInt(ra) == 123); try expect(rb == 42); try expect(@as(*const u32, @ptrCast(rc)).* == 1); } @@ -2747,7 +2747,7 @@ test "cast builtins can wrap result in error union" { const MyEnum = enum(u32) { _ }; const E = error{ImpossibleError}; fn a() E!MyEnum { - return @enumFromInt(123); + return @fromBackingInt(@intCast(123)); } fn b() E!u32 { return @intFromFloat(42.50); @@ -2766,7 +2766,7 @@ test "cast builtins can wrap result in error union" { comptime assert(@TypeOf(rb) == u32); comptime assert(@TypeOf(rc) == *const f32); - try expect(@intFromEnum(ra) == 123); + try expect(@backingInt(ra) == 123); try expect(rb == 42); try expect(@as(*const u32, @ptrCast(rc)).* == 1); } @@ -2785,7 +2785,7 @@ test "cast builtins can wrap result in error union and optional" { const MyEnum = enum(u32) { _ }; const E = error{ImpossibleError}; fn a() E!?MyEnum { - return @enumFromInt(123); + return @fromBackingInt(@intCast(123)); } fn b() E!?u32 { return @intFromFloat(42.50); @@ -2804,7 +2804,7 @@ test "cast builtins can wrap result in error union and optional" { comptime assert(@TypeOf(rb) == u32); comptime assert(@TypeOf(rc) == *const f32); - try expect(@intFromEnum(ra) == 123); + try expect(@backingInt(ra) == 123); try expect(rb == 42); try expect(@as(*const u32, @ptrCast(rc)).* == 1); } diff --git a/test/behavior/enum.zig b/test/behavior/enum.zig index 93365bb889555b722b4ff83f4ad30d24110a293d..fb3501d4541d006092b270d4b5cf2bf85ca686c1 100644 --- a/test/behavior/enum.zig +++ b/test/behavior/enum.zig @@ -8,7 +8,7 @@ const Tag = std.meta.Tag; const Number = enum { Zero, One, Two, Three, Four }; fn shouldEqual(n: Number, expected: u3) !void { - try expect(@intFromEnum(n) == expected); + try expect(@backingInt(n) == expected); } test "enum to int" { @@ -20,7 +20,7 @@ test "enum to int" { } fn testEnumFromIntEval(x: i32) !void { - try expect(@as(EnumFromIntNumber, @enumFromInt(x)) == EnumFromIntNumber.Three); + try expect(@as(EnumFromIntNumber, @fromBackingInt(@intCast(x))) == EnumFromIntNumber.Three); } const EnumFromIntNumber = enum { Zero, One, Two, Three, Four }; @@ -597,7 +597,7 @@ const MultipleChoice = enum(u32) { }; fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void { - try expect(@intFromEnum(x) == 60); + try expect(@backingInt(x) == 60); try expect(1234 == switch (x) { MultipleChoice.A => 1, MultipleChoice.B => 2, @@ -626,7 +626,7 @@ test "non-exhaustive enum" { .b => true, _ => false, }); - e = @as(E, @enumFromInt(12)); + e = @as(E, @fromBackingInt(@intCast(12))); try expect(switch (e) { .a => false, .b => false, @@ -645,10 +645,10 @@ test "non-exhaustive enum" { }); try expect(@typeInfo(E).@"enum".field_names.len == 2); - e = @as(E, @enumFromInt(12)); - try expect(@intFromEnum(e) == 12); - e = @as(E, @enumFromInt(y)); - try expect(@intFromEnum(e) == 52); + e = @as(E, @fromBackingInt(@intCast(12))); + try expect(@backingInt(e) == 12); + e = @as(E, @fromBackingInt(@intCast(y))); + try expect(@backingInt(e) == 52); try expect(@typeInfo(E).@"enum".mode == .nonexhaustive); } }; @@ -661,12 +661,12 @@ test "empty non-exhaustive enum" { const E = enum(u8) { _ }; fn doTheTest(y: u8) !void { - var e: E = @enumFromInt(y); + var e: E = @fromBackingInt(@intCast(y)); _ = &e; try expect(switch (e) { _ => true, }); - try expect(@intFromEnum(e) == y); + try expect(@backingInt(e) == y); try expect(@typeInfo(E).@"enum".field_names.len == 0); try expect(@typeInfo(E).@"enum".field_values.len == 0); @@ -688,7 +688,7 @@ test "single field non-exhaustive enum" { .a => true, _ => false, }); - e = @as(E, @enumFromInt(12)); + e = @as(E, @fromBackingInt(@intCast(12))); try expect(switch (e) { .a => false, _ => true, @@ -704,7 +704,7 @@ test "single field non-exhaustive enum" { else => false, }); - try expect(@intFromEnum(@as(E, @enumFromInt(y))) == y); + try expect(@backingInt(@as(E, @fromBackingInt(@intCast(y)))) == y); try expect(@typeInfo(E).@"enum".field_names.len == 1); try expect(@typeInfo(E).@"enum".field_values.len == 1); try expect(@typeInfo(E).@"enum".mode == .nonexhaustive); @@ -721,7 +721,7 @@ const EnumWithTagValues = enum(u4) { D = 1 << 3, }; test "enum with tag values don't require parens" { - try expect(@intFromEnum(EnumWithTagValues.C) == 0b0100); + try expect(@backingInt(EnumWithTagValues.C) == 0b0100); } const MultipleChoice2 = enum(u32) { @@ -737,8 +737,8 @@ const MultipleChoice2 = enum(u32) { }; test "cast integer literal to enum" { - try expect(@as(MultipleChoice2, @enumFromInt(0)) == MultipleChoice2.Unspecified1); - try expect(@as(MultipleChoice2, @enumFromInt(40)) == MultipleChoice2.B); + try expect(@as(MultipleChoice2, @fromBackingInt(@intCast(0))) == MultipleChoice2.Unspecified1); + try expect(@as(MultipleChoice2, @fromBackingInt(@intCast(40))) == MultipleChoice2.B); } test "enum with specified and unspecified tag values" { @@ -749,7 +749,7 @@ test "enum with specified and unspecified tag values" { } fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void { - try expect(@intFromEnum(x) == 1000); + try expect(@backingInt(x) == 1000); try expect(1234 == switch (x) { MultipleChoice2.A => 1, MultipleChoice2.B => 2, @@ -785,7 +785,7 @@ test "casting enum to its tag type" { } fn testCastEnumTag(value: Small2) !void { - try expect(@intFromEnum(value) == 1); + try expect(@backingInt(value) == 1); } test "enum with 1 field but explicit tag type should still have the tag type" { @@ -802,27 +802,27 @@ test "signed integer as enum tag" { A2 = 1, }; - try expect(@intFromEnum(SignedEnum.A0) == -1); - try expect(@intFromEnum(SignedEnum.A1) == 0); - try expect(@intFromEnum(SignedEnum.A2) == 1); + try expect(@backingInt(SignedEnum.A0) == -1); + try expect(@backingInt(SignedEnum.A1) == 0); + try expect(@backingInt(SignedEnum.A2) == 1); } test "enum with one member and custom tag type" { const E = enum(u2) { One, }; - try expect(@intFromEnum(E.One) == 0); + try expect(@backingInt(E.One) == 0); const E2 = enum(u2) { One = 2, }; - try expect(@intFromEnum(E2.One) == 2); + try expect(@backingInt(E2.One) == 2); } test "enum with one member and u1 tag type @intFromEnum" { const Enum = enum(u1) { Test, }; - try expect(@intFromEnum(Enum.Test) == 0); + try expect(@backingInt(Enum.Test) == 0); } test "enum with one member default to u0 tag type" { @@ -886,9 +886,9 @@ test "enum value allocation" { A2, }; - try expect(@intFromEnum(LargeEnum.A0) == 0x80000000); - try expect(@intFromEnum(LargeEnum.A1) == 0x80000001); - try expect(@intFromEnum(LargeEnum.A2) == 0x80000002); + try expect(@backingInt(LargeEnum.A0) == 0x80000000); + try expect(@backingInt(LargeEnum.A1) == 0x80000001); + try expect(@backingInt(LargeEnum.A2) == 0x80000002); } test "enum literal casting to tagged union" { @@ -1068,8 +1068,8 @@ test "tag name with large enum values" { var kdf: Kdf = .aes_kdf; try expect(mem.eql(u8, @tagName(kdf), "aes_kdf")); var argon2d_value: u128 = undefined; - argon2d_value = @intFromEnum(Kdf.argon2d); - kdf = @enumFromInt(argon2d_value); + argon2d_value = @backingInt(Kdf.argon2d); + kdf = @fromBackingInt(@intCast(argon2d_value)); try expect(mem.eql(u8, @tagName(kdf), "argon2d")); kdf = .argon2id; try expect(mem.eql(u8, @tagName(kdf), "argon2id")); @@ -1343,7 +1343,7 @@ test "runtime int to enum with one possible value" { const E = enum { one }; var runtime: usize = 0; _ = &runtime; - if (@as(E, @enumFromInt(runtime)) != .one) { + if (@as(E, @fromBackingInt(@intCast(runtime))) != .one) { @compileError("test failed"); } } @@ -1354,8 +1354,8 @@ test "enum tag from a local variable" { return enum(Inner) { _ }; } }; - const i = @as(S.Int(u32), @enumFromInt(0)); - try std.testing.expect(@intFromEnum(i) == 0); + const i = @as(S.Int(u32), @fromBackingInt(@intCast(0))); + try std.testing.expect(@backingInt(i) == 0); } test "auto-numbered enum with signed tag type" { @@ -1363,14 +1363,14 @@ test "auto-numbered enum with signed tag type" { const E = enum(i32) { a, b }; - try std.testing.expectEqual(@as(i32, 0), @intFromEnum(E.a)); - try std.testing.expectEqual(@as(i32, 1), @intFromEnum(E.b)); - try std.testing.expectEqual(E.a, @as(E, @enumFromInt(0))); - try std.testing.expectEqual(E.b, @as(E, @enumFromInt(1))); - try std.testing.expectEqual(E.a, @as(E, @enumFromInt(@as(i32, 0)))); - try std.testing.expectEqual(E.b, @as(E, @enumFromInt(@as(i32, 1)))); - try std.testing.expectEqual(E.a, @as(E, @enumFromInt(@as(u32, 0)))); - try std.testing.expectEqual(E.b, @as(E, @enumFromInt(@as(u32, 1)))); + try std.testing.expectEqual(@as(i32, 0), @backingInt(E.a)); + try std.testing.expectEqual(@as(i32, 1), @backingInt(E.b)); + try std.testing.expectEqual(E.a, @as(E, @fromBackingInt(@intCast(0)))); + try std.testing.expectEqual(E.b, @as(E, @fromBackingInt(@intCast(1)))); + try std.testing.expectEqual(E.a, @as(E, @fromBackingInt(@intCast(@as(i32, 0))))); + try std.testing.expectEqual(E.b, @as(E, @fromBackingInt(@intCast(@as(i32, 1))))); + try std.testing.expectEqual(E.a, @as(E, @fromBackingInt(@intCast(@as(u32, 0))))); + try std.testing.expectEqual(E.b, @as(E, @fromBackingInt(@intCast(@as(u32, 1))))); try std.testing.expectEqualStrings("a", @tagName(E.a)); try std.testing.expectEqualStrings("b", @tagName(E.b)); } @@ -1382,7 +1382,7 @@ test "lazy initialized field" { fn getLazyInitialized(param: enum(u8) { a = @bitCast(packed struct(u8) { a: u8 }{ .a = @alignOf(struct {}) }), }) u8 { - return @intFromEnum(param); + return @backingInt(param); } test "matching captures causes enum equivalence" { @@ -1397,10 +1397,10 @@ test "matching captures causes enum equivalence" { comptime assert(S.Nonexhaustive(u16) == S.Nonexhaustive(i16)); comptime assert(S.Nonexhaustive(u8) != S.Nonexhaustive(u16)); - const a: S.Nonexhaustive(u8) = @enumFromInt(123); - const b: S.Nonexhaustive(i8) = @enumFromInt(123); + const a: S.Nonexhaustive(u8) = @fromBackingInt(@intCast(123)); + const b: S.Nonexhaustive(i8) = @fromBackingInt(@intCast(123)); comptime assert(@TypeOf(a) == @TypeOf(b)); - try expect(@intFromEnum(a) == @intFromEnum(b)); + try expect(@backingInt(a) == @backingInt(b)); } test "large enum field values" { @@ -1410,45 +1410,45 @@ test "large enum field values" { const E = enum(u64) { min = std.math.minInt(u64), max = std.math.maxInt(u64) }; var e: E = .min; try expect(e == .min); - try expect(@intFromEnum(e) == std.math.minInt(u64)); + try expect(@backingInt(e) == std.math.minInt(u64)); e = .max; try expect(e == .max); - try expect(@intFromEnum(e) == std.math.maxInt(u64)); + try expect(@backingInt(e) == std.math.maxInt(u64)); } { const E = enum(i64) { min = std.math.minInt(i64), max = std.math.maxInt(i64) }; var e: E = .min; try expect(e == .min); - try expect(@intFromEnum(e) == std.math.minInt(i64)); + try expect(@backingInt(e) == std.math.minInt(i64)); e = .max; try expect(e == .max); - try expect(@intFromEnum(e) == std.math.maxInt(i64)); + try expect(@backingInt(e) == std.math.maxInt(i64)); } { const E = enum(u128) { min = std.math.minInt(u128), max = std.math.maxInt(u128) }; var e: E = .min; try expect(e == .min); - try expect(@intFromEnum(e) == std.math.minInt(u128)); + try expect(@backingInt(e) == std.math.minInt(u128)); e = .max; try expect(e == .max); - try expect(@intFromEnum(e) == std.math.maxInt(u128)); + try expect(@backingInt(e) == std.math.maxInt(u128)); } { const E = enum(i128) { min = std.math.minInt(i128), max = std.math.maxInt(i128) }; var e: E = .min; try expect(e == .min); - try expect(@intFromEnum(e) == std.math.minInt(i128)); + try expect(@backingInt(e) == std.math.minInt(i128)); e = .max; try expect(e == .max); - try expect(@intFromEnum(e) == std.math.maxInt(i128)); + try expect(@backingInt(e) == std.math.maxInt(i128)); } } test "comptime @enumFromInt with signed arithmetic" { const E = enum(i8) { foo = -1, bar = 0 }; - const x: E = @enumFromInt(@as(i8, -1) * 0); + const x: E = @fromBackingInt(@intCast(@as(i8, -1) * 0)); comptime assert(x == .bar); - comptime assert(@intFromEnum(x) == 0); + comptime assert(@backingInt(x) == 0); } test "enum int tag type uses declaration inside the enum" { @@ -1463,7 +1463,7 @@ test "enum int tag type uses declaration inside the enum" { try expect(@sizeOf(static.E) == @sizeOf(u8)); const val: static.E = .b; try expect(val == .b); - try expect(@intFromEnum(val) == 1); + try expect(@backingInt(val) == 1); } test "convert from/to backing int" { diff --git a/test/behavior/generics.zig b/test/behavior/generics.zig index 7694b8a2966a24478423d03eea26bcbb525e8fa3..e17ea4fdd682672e5315832c936993dce36355ae 100644 --- a/test/behavior/generics.zig +++ b/test/behavior/generics.zig @@ -259,8 +259,8 @@ test "generic function instantiation turns into comptime call" { else => void, } { return .{ - .name = @typeInfo(T).@"enum".field_names[@intFromEnum(field)], - .value = @typeInfo(T).@"enum".field_values[@intFromEnum(field)], + .name = @typeInfo(T).@"enum".field_names[@backingInt(field)], + .value = @typeInfo(T).@"enum".field_values[@backingInt(field)], }; } diff --git a/test/behavior/inline_switch.zig b/test/behavior/inline_switch.zig index 25582f790edc7ae6ce8655b64aa0808eb5e8e3f1..676ef30874b6fa4685f70ae5a8cb31118a89a208 100644 --- a/test/behavior/inline_switch.zig +++ b/test/behavior/inline_switch.zig @@ -98,7 +98,7 @@ test "inline else enum" { _ = &a; switch (a) { .a, .b => {}, - inline else => |val| comptime if (@intFromEnum(val) < 4) @compileError("bad"), + inline else => |val| comptime if (@backingInt(val) < 4) @compileError("bad"), } } diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig index 54844789a2813ff178856a08f1f65e132cc1e4e8..379e5ec18343c226b0e2d67b1dca8b8d53f13340 100644 --- a/test/behavior/struct.zig +++ b/test/behavior/struct.zig @@ -1873,7 +1873,7 @@ test "runtime call in nested initializer" { B, fn letter(e: @This()) u8 { - return @intFromEnum(e); + return @backingInt(e); } }; diff --git a/test/behavior/switch.zig b/test/behavior/switch.zig index c7323ed1d623ff502da131454bcd55ade52eafb8..6a44290f859261ad1c2f02974eb8525022fc0b25 100644 --- a/test/behavior/switch.zig +++ b/test/behavior/switch.zig @@ -777,10 +777,10 @@ test "enum value without tag name used as switch item" { b = 2, _, }; - var e: E = @enumFromInt(0); + var e: E = @fromBackingInt(@intCast(0)); _ = &e; switch (e) { - @as(E, @enumFromInt(0)) => {}, + @as(E, @fromBackingInt(@intCast(0))) => {}, .a => return error.TestFailed, .b => return error.TestFailed, _ => return error.TestFailed, @@ -1117,7 +1117,7 @@ test "decl literals as switch cases" { bar = 3, _, - const foo: @This() = @enumFromInt(0xa); + const foo: @This() = @fromBackingInt(@intCast(0xa)); fn doTheTest(e: @This()) !void { switch (e) { @@ -1185,7 +1185,7 @@ test "switch with tag capture" { .a => |nothing, tag| { comptime assert(nothing == {}); comptime assert(tag == .a); - try expect(@intFromEnum(tag) == @intFromEnum(@This().a)); + try expect(@backingInt(tag) == @backingInt(@This().a)); }, .b, .d => |_, tag| { try expect(tag == .b or tag == .d); @@ -1226,8 +1226,8 @@ test "switch with complex item expressions" { try doTheSwitch(2000, 10); try doTheSwitch(2000, 5); - try doTheOtherSwitch(@enumFromInt(123)); - try doTheOtherSwitch(@enumFromInt(456)); + try doTheOtherSwitch(@fromBackingInt(@intCast(123))); + try doTheOtherSwitch(@fromBackingInt(@intCast(456))); } fn doTheSwitch(x: u32, comptime factor: u32) !void { const ok = switch (x) { @@ -1252,8 +1252,8 @@ test "switch with complex item expressions" { const E = enum(u32) { _ }; fn doTheOtherSwitch(e: E) !void { const ok = switch (e) { - @enumFromInt(123) => true, - @enumFromInt(456) => true, + @fromBackingInt(@intCast(123)) => true, + @fromBackingInt(@intCast(456)) => true, else => false, }; try expect(ok); diff --git a/test/behavior/switch_loop.zig b/test/behavior/switch_loop.zig index 40fd66fb74f07100634e5f78bf53841af45ec6b9..9f4859789c9c3f23488ae0814c67b132112a3335 100644 --- a/test/behavior/switch_loop.zig +++ b/test/behavior/switch_loop.zig @@ -256,8 +256,8 @@ test "switch loop on non-exhaustive enum" { start = .a; const result: u32 = s: switch (start) { .a => continue :s .c, - else => continue :s @enumFromInt(123), - .b, _ => |x| break :s @intFromEnum(x), + else => continue :s @fromBackingInt(@intCast(123)), + .b, _ => |x| break :s @backingInt(x), }; try expect(result == 123); } @@ -407,7 +407,7 @@ test "switch loop with tag capture" { .a => |nothing, tag| { comptime assert(nothing == {}); comptime assert(tag == .a); - try expect(@intFromEnum(tag) == @intFromEnum(@This().a)); + try expect(@backingInt(tag) == @backingInt(@This().a)); continue :label .{ .d = 456 }; }, .b, .d => |_, tag| { diff --git a/test/behavior/type.zig b/test/behavior/type.zig index d4b8a60aa697f80d32aceadfaaeec9f172b9d409..875e77ffcb037bce22bf124d5ecea3689913d163 100644 --- a/test/behavior/type.zig +++ b/test/behavior/type.zig @@ -197,13 +197,13 @@ test "Type.Enum" { const Foo = @Enum(u8, .exhaustive, &.{ "a", "b" }, &.{ 1, 5 }); try testing.expectEqual(std.builtin.Type.Enum.Mode.exhaustive, @typeInfo(Foo).@"enum".mode); - try testing.expectEqual(@as(u8, 1), @intFromEnum(Foo.a)); - try testing.expectEqual(@as(u8, 5), @intFromEnum(Foo.b)); + try testing.expectEqual(@as(u8, 1), @backingInt(Foo.a)); + try testing.expectEqual(@as(u8, 5), @backingInt(Foo.b)); const Bar = @Enum(u32, .nonexhaustive, &.{ "a", "b" }, &.{ 1, 5 }); try testing.expectEqual(std.builtin.Type.Enum.Mode.nonexhaustive, @typeInfo(Bar).@"enum".mode); - try testing.expectEqual(@as(u32, 1), @intFromEnum(Bar.a)); - try testing.expectEqual(@as(u32, 5), @intFromEnum(Bar.b)); - try testing.expectEqual(@as(u32, 6), @intFromEnum(@as(Bar, @enumFromInt(6)))); + try testing.expectEqual(@as(u32, 1), @backingInt(Bar.a)); + try testing.expectEqual(@as(u32, 5), @backingInt(Bar.b)); + try testing.expectEqual(@as(u32, 6), @backingInt(@as(Bar, @fromBackingInt(@intCast(6))))); { // from https://github.com/ziglang/zig/issues/19985 { // enum with single field can be initialized. diff --git a/test/behavior/union.zig b/test/behavior/union.zig index 6922774d4ee31976b2f7c9d8a28f00b30bab784d..340f7006e72b7f48ecaf7280cd9cd982f8600060 100644 --- a/test/behavior/union.zig +++ b/test/behavior/union.zig @@ -337,7 +337,7 @@ test "simple union(enum(u32))" { var x = MultipleChoice.C; _ = &x; try expect(x == MultipleChoice.C); - try expect(@intFromEnum(@as(Tag(MultipleChoice), x)) == 60); + try expect(@backingInt(@as(Tag(MultipleChoice), x)) == 60); } test "packed union size" { @@ -639,7 +639,7 @@ const MultipleChoice2 = union(enum(u32)) { }; fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void { - try expect(@intFromEnum(@as(Tag(MultipleChoice2), x)) == 60); + try expect(@backingInt(@as(Tag(MultipleChoice2), x)) == 60); try expect(1123 == switch (x) { MultipleChoice2.A => 1, MultipleChoice2.B => 2, @@ -701,9 +701,9 @@ test "union with only 1 field casted to its enum type which has enum value speci const t: ExprTag = e; comptime assert(t == Expr.literal); - comptime assert(@intFromEnum(t) == 33); + comptime assert(@backingInt(t) == 33); try expect(t == Expr.literal); - try expect(@intFromEnum(t) == 33); + try expect(@backingInt(t) == 33); } test "@intFromEnum works on unions" { @@ -721,9 +721,9 @@ test "@intFromEnum works on unions" { var b = Bar{ .B = undefined }; var c = Bar.C; _ = .{ &b, &c }; - try expect(@intFromEnum(a) == 0); - try expect(@intFromEnum(b) == 1); - try expect(@intFromEnum(c) == 2); + try expect(@backingInt(a) == 0); + try expect(@backingInt(b) == 1); + try expect(@backingInt(c) == 2); } test "comptime union field value equality" { @@ -1278,7 +1278,7 @@ test "@unionInit uses tag value instead of field index" { _ = &a; try expect(a.* == i); } - try expect(@intFromEnum(u) == 255); + try expect(@backingInt(u) == 255); } test "union field ptr - zero sized payload" { diff --git a/test/c.zig b/test/c.zig index f3cecb6c3454991641a192128d41539ecbee817a..b0a114bb690d9f2f3b27890f3b67b854257c86d6 100644 --- a/test/c.zig +++ b/test/c.zig @@ -15,14 +15,14 @@ test { } pub fn expectErrno(expected_errno: c.E) !void { - try std.testing.expectEqual(expected_errno, @as(c.E, @enumFromInt(c._errno().*))); - c._errno().* = @intFromEnum(c.E.SUCCESS); + try std.testing.expectEqual(expected_errno, @as(c.E, @fromBackingInt(@intCast(c._errno().*)))); + c._errno().* = @backingInt(c.E.SUCCESS); } pub fn expectErrnoAny(expected_errnos: []const c.E) !void { const errno = c._errno().*; for (expected_errnos) |expected_errno| { - if (errno == @intFromEnum(expected_errno)) break; + if (errno == @backingInt(expected_errno)) break; } else { var buffer: [64]u8 = undefined; const stderr = std.debug.lockStderr(&buffer); @@ -31,8 +31,8 @@ pub fn expectErrnoAny(expected_errnos: []const c.E) !void { for (expected_errnos[1..]) |expected_errno| { try stderr.file_writer.interface.print(", {t}", .{expected_errno}); } - try stderr.file_writer.interface.print(", found {t}\n", .{@as(c.E, @enumFromInt(errno))}); + try stderr.file_writer.interface.print(", found {t}\n", .{@as(c.E, @fromBackingInt(@intCast(errno)))}); return error.TestExpectedEqual; } - c._errno().* = @intFromEnum(c.E.SUCCESS); + c._errno().* = @backingInt(c.E.SUCCESS); } diff --git a/test/c/pthread.zig b/test/c/pthread.zig index abac50414324036b38f78b66627c839dd8868bc9..07c6ceb4eef97620f2e12e9d33167d9d870becdc 100644 --- a/test/c/pthread.zig +++ b/test/c/pthread.zig @@ -13,9 +13,9 @@ test "pthread_spinlock_t" { _ = c.pthread_spin_init(&spin, c.PTHREAD_PROCESS_PRIVATE); defer _ = c.pthread_spin_destroy(&spin); - try std.testing.expectEqual(@intFromEnum(c.E.SUCCESS), c.pthread_spin_trylock(&spin)); - try std.testing.expectEqual(@intFromEnum(c.E.SUCCESS), c.pthread_spin_unlock(&spin)); + try std.testing.expectEqual(@backingInt(c.E.SUCCESS), c.pthread_spin_trylock(&spin)); + try std.testing.expectEqual(@backingInt(c.E.SUCCESS), c.pthread_spin_unlock(&spin)); - try std.testing.expectEqual(@intFromEnum(c.E.SUCCESS), c.pthread_spin_lock(&spin)); - try std.testing.expectEqual(@intFromEnum(c.E.SUCCESS), c.pthread_spin_unlock(&spin)); + try std.testing.expectEqual(@backingInt(c.E.SUCCESS), c.pthread_spin_lock(&spin)); + try std.testing.expectEqual(@backingInt(c.E.SUCCESS), c.pthread_spin_unlock(&spin)); } diff --git a/test/c/stdlib.zig b/test/c/stdlib.zig index 931b5dc6656434a6df392d8065ef93dcd9a3ec7d..ca156819232f3597f87ee8a0700234106f010ba6 100644 --- a/test/c/stdlib.zig +++ b/test/c/stdlib.zig @@ -133,7 +133,7 @@ fn testStrToLLikeFunctionAnyErrno( test "strtol" { if (builtin.target.cpu.arch.isX86() and builtin.target.os.tag == .windows and builtin.target.abi == .msvc) return error.SkipZigTest; // TODO - c._errno().* = @intFromEnum(c.E.SUCCESS); + c._errno().* = @backingInt(c.E.SUCCESS); try testStrToLLikeFunctionAnyErrno(c.strtol, @ptrCast("stop42true"), 0, 0, 0, &.{ .SUCCESS, .INVAL }); try testStrToLLikeFunction(c.strtol, @ptrCast("42true"), 0, 42, 2, .SUCCESS); try testStrToLLikeFunction(c.strtol, @ptrCast("-01"), 0, -1, 3, .SUCCESS); @@ -173,7 +173,7 @@ test "strtol" { test "strtoll" { if (builtin.target.cpu.arch.isX86() and builtin.target.os.tag == .windows and builtin.target.abi == .msvc) return error.SkipZigTest; // TODO - c._errno().* = @intFromEnum(c.E.SUCCESS); + c._errno().* = @backingInt(c.E.SUCCESS); try testStrToLLikeFunctionAnyErrno(c.strtoll, @ptrCast("stop42true"), 0, 0, 0, &.{ .SUCCESS, .INVAL }); try testStrToLLikeFunction(c.strtoll, @ptrCast("42true"), 0, 42, 2, .SUCCESS); try testStrToLLikeFunction(c.strtoll, @ptrCast("-01"), 0, -1, 3, .SUCCESS); @@ -213,7 +213,7 @@ test "strtoll" { test "strtoul" { if (builtin.target.cpu.arch.isX86() and builtin.target.os.tag == .windows and builtin.target.abi == .msvc) return error.SkipZigTest; // TODO - c._errno().* = @intFromEnum(c.E.SUCCESS); + c._errno().* = @backingInt(c.E.SUCCESS); try testStrToLLikeFunctionAnyErrno(c.strtoul, @ptrCast("stop42true"), 0, 0, 0, &.{ .SUCCESS, .INVAL }); try testStrToLLikeFunction(c.strtoul, @ptrCast("42true"), 0, 42, 2, .SUCCESS); try testStrToLLikeFunction(c.strtoul, @ptrCast("-01"), 0, math.maxInt(c_ulong), 3, .SUCCESS); @@ -251,7 +251,7 @@ test "strtoul" { test "strtoull" { if (builtin.target.cpu.arch.isX86() and builtin.target.os.tag == .windows and builtin.target.abi == .msvc) return error.SkipZigTest; // TODO - c._errno().* = @intFromEnum(c.E.SUCCESS); + c._errno().* = @backingInt(c.E.SUCCESS); try testStrToLLikeFunctionAnyErrno(c.strtoull, @ptrCast("stop42true"), 0, 0, 0, &.{ .SUCCESS, .INVAL }); try testStrToLLikeFunction(c.strtoull, @ptrCast("42true"), 0, 42, 2, .SUCCESS); try testStrToLLikeFunction(c.strtoull, @ptrCast("-01"), 0, math.maxInt(c_ulonglong), 3, .SUCCESS); @@ -289,7 +289,7 @@ test "strtoull" { test "strtoimax" { if (builtin.target.cpu.arch.isX86() and builtin.target.os.tag == .windows and builtin.target.abi == .msvc) return error.SkipZigTest; // TODO - c._errno().* = @intFromEnum(c.E.SUCCESS); + c._errno().* = @backingInt(c.E.SUCCESS); try testStrToLLikeFunctionAnyErrno(c.strtoimax, @ptrCast("stop42true"), 0, 0, 0, &.{ .SUCCESS, .INVAL }); try testStrToLLikeFunction(c.strtoimax, @ptrCast("42true"), 0, 42, 2, .SUCCESS); try testStrToLLikeFunction(c.strtoimax, @ptrCast("-01"), 0, -1, 3, .SUCCESS); @@ -329,7 +329,7 @@ test "strtoimax" { test "strtoumax" { if (builtin.target.cpu.arch.isX86() and builtin.target.os.tag == .windows and builtin.target.abi == .msvc) return error.SkipZigTest; // TODO - c._errno().* = @intFromEnum(c.E.SUCCESS); + c._errno().* = @backingInt(c.E.SUCCESS); try testStrToLLikeFunctionAnyErrno(c.strtoumax, @ptrCast("stop42true"), 0, 0, 0, &.{ .SUCCESS, .INVAL }); try testStrToLLikeFunction(c.strtoumax, @ptrCast("42true"), 0, 42, 2, .SUCCESS); try testStrToLLikeFunction(c.strtoumax, @ptrCast("-01"), 0, math.maxInt(c.uintmax_t), 3, .SUCCESS); diff --git a/test/src/StackTrace.zig b/test/src/StackTrace.zig index 0022e5b9b616671a0a0d4809a8d648dc14cc3988..a10b70fe280d5594a853e2ca37238891d9af41ff 100644 --- a/test/src/StackTrace.zig +++ b/test/src/StackTrace.zig @@ -229,7 +229,7 @@ fn addCaseInstance( run.addCheck(.{ .expect_term = term: { if (!expect_panic) break :term .{ .exited = 0 }; if (target.result.os.tag == .windows) break :term .{ .exited = 3 }; - break :term .{ .signal = @enumFromInt(6) }; + break :term .{ .signal = @fromBackingInt(@intCast(6)) }; } }); run.expectStdOutEqual(""); diff --git a/test/standalone/windows_argv/fuzz.zig b/test/standalone/windows_argv/fuzz.zig index c53e3b4cef71fb9a51df3538232597427eb7bead..5169a3f54e42688eeb16532657f012cdb9edb422 100644 --- a/test/standalone/windows_argv/fuzz.zig +++ b/test/standalone/windows_argv/fuzz.zig @@ -162,7 +162,7 @@ fn spawnVerify(verify_path: [:0]const u16, cmd_line: [:0]const u16) !windows.DWO @sizeOf(windows.PROCESS.BASIC_INFORMATION), null, )) { - .SUCCESS => return @intFromEnum(info.ExitStatus), + .SUCCESS => return @backingInt(info.ExitStatus), else => return error.UnableToGetExitCode, } } diff --git a/tools/fetch_them_macos_headers.zig b/tools/fetch_them_macos_headers.zig index adf28e6bde3a5ebd3076f98cb414c71e881ab25a..d15bf8b7dfa9f8ccb3acbbb5d978726c16379731 100644 --- a/tools/fetch_them_macos_headers.zig +++ b/tools/fetch_them_macos_headers.zig @@ -44,7 +44,7 @@ const Target = struct { return std.fmt.allocPrint(allocator, "{s}-{s}.{d}-{s}", .{ @tagName(self.arch), @tagName(self.os), - @intFromEnum(self.os_ver), + @backingInt(self.os_ver), @tagName(self.abi), }); } @@ -97,7 +97,7 @@ pub fn main(init: std.process.Init) !void { fatal("don't know how to parse SDK version: {s}", .{ parsed_json.value.DefaultProperties.MACOSX_DEPLOYMENT_TARGET, }); - const os_ver: OsVer = @enumFromInt(version.major); + const os_ver: OsVer = @fromBackingInt(@intCast(version.major)); info("found SDK deployment target macOS {f} aka '{t}'", .{ version, os_ver }); const tmp_dir: Io.Dir = .cwd(); diff --git a/tools/gen_outline_atomics.zig b/tools/gen_outline_atomics.zig index bd36484e1e9b697deba71a6d32169c0bfde880e2..cbeff5ea76406a7756c1a25c342f9a0c31e412f3 100644 --- a/tools/gen_outline_atomics.zig +++ b/tools/gen_outline_atomics.zig @@ -145,11 +145,11 @@ const N = enum(u8) { } fn register(n: N) []const u8 { - return if (@intFromEnum(n) < 8) "w" else "x"; + return if (@backingInt(n) < 8) "w" else "x"; } fn toBytes(n: N) u8 { - return @intFromEnum(n); + return @backingInt(n); } fn toBits(n: N) u8 { @@ -213,7 +213,7 @@ fn generateCas(arena: Allocator, n: N, order: Ordering) ![]const u8 { const reg = n.register(); - if (@intFromEnum(n) < 16) { + if (@backingInt(n) < 16) { const cas = try std.fmt.allocPrint(arena, ".inst 0x08a07c41 + {s} + {s}", .{ s_def.b, o_def.m }); const ldxr = try std.fmt.allocPrint(arena, "ld{s}xr{s}", .{ o_def.a, s_def.s }); const stxr = try std.fmt.allocPrint(arena, "st{s}xr{s}", .{ o_def.l, s_def.s }); diff --git a/tools/gen_parser_oracle.zig b/tools/gen_parser_oracle.zig index 4b1bee7e20da0a6d06f0dbb82c7d4e6b7d913b28..e20b3bfc15f9e376370778c21061d4363d1dd6ba 100644 --- a/tools/gen_parser_oracle.zig +++ b/tools/gen_parser_oracle.zig @@ -398,7 +398,7 @@ const Parser = struct { _, fn get(index: Index, p: *const Parser) Node { - return p.nodes.items[@intFromEnum(index)]; + return p.nodes.items[@backingInt(index)]; } }; @@ -750,7 +750,7 @@ const Parser = struct { fn addNode(p: *Parser, node: Node) !Node.Index { try p.nodes.append(p.gpa, node); - return @enumFromInt(p.nodes.items.len - 1); + return @fromBackingInt(@intCast(p.nodes.items.len - 1)); } fn addExtra(p: *Parser, nodes: []const Node.Index) !Node.Slice { diff --git a/tools/gen_stubs.zig b/tools/gen_stubs.zig index f6ba7a5af004c434a998e0fc21fec86b5155fd68..c7cd93a8eefb9478a85c1f396e034ea59298fc6f 100644 --- a/tools/gen_stubs.zig +++ b/tools/gen_stubs.zig @@ -144,7 +144,7 @@ const Family = enum { const arches: [@typeInfo(Arch).@"enum".field_names.len]Arch = blk: { var result: [@typeInfo(Arch).@"enum".field_names.len]Arch = undefined; for (@typeInfo(Arch).@"enum".field_values) |field_value| { - const arch: Arch = @enumFromInt(field_value); + const arch: Arch = @fromBackingInt(@intCast(field_value)); result[archIndex(arch)] = arch; } break :blk result; @@ -161,7 +161,7 @@ const MultiSym = struct { fn isSingleArch(ms: MultiSym) ?Arch { var result: ?Arch = null; inline for (@typeInfo(Arch).@"enum".field_values) |field_value| { - const arch: Arch = @enumFromInt(field_value); + const arch: Arch = @fromBackingInt(@intCast(field_value)); if (ms.present[archIndex(arch)]) { if (result != null) return null; result = arch; @@ -173,7 +173,7 @@ const MultiSym = struct { fn isFamily(ms: MultiSym) ?Family { var result: ?Family = null; inline for (@typeInfo(Arch).@"enum".field_values) |field_value| { - const arch: Arch = @enumFromInt(field_value); + const arch: Arch = @fromBackingInt(@intCast(field_value)); if (ms.present[archIndex(arch)]) { const family = arch.family(); if (result) |r| if (family != r) return null; @@ -194,7 +194,7 @@ const MultiSym = struct { fn isTime32Only(ms: MultiSym) bool { inline for (@typeInfo(Arch).@"enum".field_values) |field_value| { - const arch: Arch = @enumFromInt(field_value); + const arch: Arch = @fromBackingInt(@intCast(field_value)); if (ms.present[archIndex(arch)] != arch.isTime32()) { return false; } @@ -234,7 +234,7 @@ const MultiSym = struct { fn isPtrSize(ms: MultiSym, mult: u16) bool { inline for (@typeInfo(Arch).@"enum".field_values) |field_value| { - const arch: Arch = @enumFromInt(field_value); + const arch: Arch = @fromBackingInt(@intCast(field_value)); const arch_index = archIndex(arch); if (ms.present[arch_index] and ms.size[arch_index] != arch.ptrSize() * mult) { return false; @@ -245,7 +245,7 @@ const MultiSym = struct { fn isWeak64(ms: MultiSym) bool { inline for (@typeInfo(Arch).@"enum".field_values) |field_value| { - const arch: Arch = @enumFromInt(field_value); + const arch: Arch = @fromBackingInt(@intCast(field_value)); const arch_index = archIndex(arch); const binding: u4 = switch (arch.ptrSize()) { 4 => std.elf.STB_GLOBAL, @@ -261,7 +261,7 @@ const MultiSym = struct { fn isWeakTime64(ms: MultiSym) bool { inline for (@typeInfo(Arch).@"enum".field_values) |field_value| { - const arch: Arch = @enumFromInt(field_value); + const arch: Arch = @fromBackingInt(@intCast(field_value)); const arch_index = archIndex(arch); const binding: u4 = if (arch.isTime32()) std.elf.STB_GLOBAL else std.elf.STB_WEAK; if (ms.present[arch_index] and ms.binding[arch_index] != binding) { @@ -605,7 +605,7 @@ fn parseElf(parse: Parse, comptime is_64: bool, comptime endian: std.builtin.End const name = try arena.dupe(u8, mem.sliceTo(dynstr[s(sym.st_name)..], 0)); const ty = @as(u4, @truncate(sym.st_info)); const binding = @as(u4, @truncate(sym.st_info >> 4)); - const visib = @as(elf.STV, @enumFromInt(@as(u3, @truncate(sym.st_other)))); + const visib = @as(elf.STV, @fromBackingInt(@intCast(@as(u3, @truncate(sym.st_other))))); const size = s(sym.st_size); if (size == 0) { @@ -717,7 +717,7 @@ fn parseElf(parse: Parse, comptime is_64: bool, comptime endian: std.builtin.End } fn archIndex(arch: Arch) u8 { - return @intFromEnum(arch); + return @backingInt(arch); } fn archSetName(arch_set: [arches.len]bool) []const u8 { diff --git a/tools/generate_c_size_and_align_checks.zig b/tools/generate_c_size_and_align_checks.zig index 42fa4d5937bcc2b41208c49b527ac3c44a3cfd66..09400615f2c526bdde3ce99c62b0f5a0bf386932 100644 --- a/tools/generate_c_size_and_align_checks.zig +++ b/tools/generate_c_size_and_align_checks.zig @@ -44,7 +44,7 @@ pub fn main(init: std.process.Init) !void { var stdout_writer = Io.File.stdout().writerStreaming(io, &buffer); const w = &stdout_writer.interface; inline for (@typeInfo(std.Target.CType).@"enum".field_values) |field_value| { - const c_type: std.Target.CType = @enumFromInt(field_value); + const c_type: std.Target.CType = @fromBackingInt(@intCast(field_value)); try w.print("_Static_assert(sizeof({0s}) == {1d}, \"sizeof({0s}) == {1d}\");\n", .{ cName(c_type), target.cTypeByteSize(c_type), diff --git a/tools/update-linux-headers.zig b/tools/update-linux-headers.zig index 2cf9cdc4b48cc4dfba24310bd1c8430062e3460b..6e5fc152ee263958e5a269dec503a01b81e003d7 100644 --- a/tools/update-linux-headers.zig +++ b/tools/update-linux-headers.zig @@ -39,7 +39,7 @@ const MultiArch = union(enum) { specific: Arch, fn eql(a: MultiArch, b: MultiArch) bool { - if (@intFromEnum(a) != @intFromEnum(b)) + if (@backingInt(a) != @backingInt(b)) return false; if (a != .specific) return true; diff --git a/tools/update_clang_options.zig b/tools/update_clang_options.zig index 00a88da979f6ed5d63256ec2561e09f22275ebbb..43b81238703433538070330f5d96e3fe4a337f41 100644 --- a/tools/update_clang_options.zig +++ b/tools/update_clang_options.zig @@ -666,7 +666,7 @@ pub fn main(init: std.process.Init) !void { for (all_features, 0..) |feat, i| { const llvm_name = feat.llvm_name orelse continue; - const zig_feat = @as(Feature, @enumFromInt(i)); + const zig_feat = @as(Feature, @fromBackingInt(@intCast(i))); const zig_name = @tagName(zig_feat); try llvm_to_zig_cpu_features.put(llvm_name, zig_name); } diff --git a/tools/update_cpu_features.zig b/tools/update_cpu_features.zig index a1f876282a584edb8470c76bcca72a4248c9cb04..8d0e142ab87423a56116043c5a1873da694172d4 100644 --- a/tools/update_cpu_features.zig +++ b/tools/update_cpu_features.zig @@ -76,7 +76,7 @@ const spirv_extra_features: []const Feature = blk: { .zig_name = name, .desc = "Enable " ++ name ++ " capability", .deps = &struct { - const extensions = spirv_spec.Capability.dependencies(@enumFromInt(value)); + const extensions = spirv_spec.Capability.dependencies(@fromBackingInt(@intCast(value))); const deps: [extensions.len][]const u8 = inner: { var out: [extensions.len][]const u8 = undefined; for (extensions, 0..) |ext, i| out[i] = @tagName(ext); -- 2.54.0