x86_64.Lower: replace slow stringToEnum call

Looking at a compilation of 'test/behavior/x86_64/unary.zig' in
callgrind showed that a full 30% of the compiler runtime was spent in
this `stringToEnum` call. Replace it with some nested `switch`
statements using `inline else` to generate the cases at comptime. There
are a lot, but most of them end up falling through to the runtime error
case, so the block will get optimized away.

Notably, this commit builds itself faster than the previous commit
builds *it*self, because the performance degradation from the compiler
having to analyze the `inline else` is beaten out by the performance
gain from using this faster logic in `Lower`

Author: mlugg

src/arch/x86_64/Lower.zig

@@ -428,7 +428,7 @@ fn encode(lower: *Lower, prefix: Prefix, mnemonic: Mnemonic, ops: []const Operan
 }
 
 fn generic(lower: *Lower, inst: Mir.Inst) Error!void {
-    @setEvalBranchQuota(2_800);
+    @setEvalBranchQuota(80_000);
     const fixes = switch (inst.ops) {
         .none => inst.data.none.fixes,
         .inst => inst.data.inst.fixes,
@@ -457,19 +457,33 @@ fn generic(lower: *Lower, inst: Mir.Inst) Error!void {
         else
             .none,
     }, mnemonic: {
-        comptime var max_len = 0;
-        inline for (@typeInfo(Mnemonic).@"enum".fields) |field| max_len = @max(field.name.len, max_len);
-        var buf: [max_len]u8 = undefined;
-
+        switch (fixes) {
+            inline else => |ct_fixes| {
+                const fixes_name = @tagName(ct_fixes);
+                const pattern = comptime fixes_name[if (std.mem.indexOfScalar(u8, fixes_name, ' ')) |i| i + " ".len else 0..];
+                const wildcard_index = comptime std.mem.indexOfScalar(u8, pattern, '_').?;
+                const header = pattern[0..wildcard_index];
+                const trailer = pattern[wildcard_index + 1 ..];
+                switch (inst.tag) {
+                    inline else => |ct_inst_tag| {
+                        const name = header ++ @tagName(ct_inst_tag) ++ trailer;
+                        if (@hasField(Mnemonic, name)) {
+                            break :mnemonic @field(Mnemonic, name);
+                        }
+                        // Fall through to runtime error case below
+                    },
+                }
+            },
+        }
+        // Error case
         const fixes_name = @tagName(fixes);
         const pattern = fixes_name[if (std.mem.indexOfScalar(u8, fixes_name, ' ')) |i| i + " ".len else 0..];
         const wildcard_index = std.mem.indexOfScalar(u8, pattern, '_').?;
-        const parts = .{ pattern[0..wildcard_index], @tagName(inst.tag), pattern[wildcard_index + "_".len ..] };
-        const err_msg = "unsupported mnemonic: ";
-        const mnemonic = std.fmt.bufPrint(&buf, "{s}{s}{s}", parts) catch
-            return lower.fail(err_msg ++ "'{s}{s}{s}'", parts);
-        break :mnemonic std.meta.stringToEnum(Mnemonic, mnemonic) orelse
-            return lower.fail(err_msg ++ "'{s}'", .{mnemonic});
+        return lower.fail("unsupported mnemonic: '{s}{s}{s}'", .{
+            pattern[0..wildcard_index],
+            @tagName(inst.tag),
+            pattern[wildcard_index + "_".len ..],
+        });
     }, switch (inst.ops) {
         .none => &.{},
         .inst => &.{