看起来你现在在为自定义ISA模拟器里重复的操作数大小switch代码头疼，我来给你几个符合C23标准的优化思路，既能让代码更简洁，又不损失性能：

方案1：用预处理器宏封装重复的Switch逻辑 #

这是改动最小、最贴合你现有代码的方案——把每个场景下的switch分支抽成可复用的宏，直接消除代码冗余，而且宏展开后和原代码完全一致，编译器能做和原来一样的优化。

首先定义针对不同操作场景的宏：

// 处理寄存器到寄存器的赋值逻辑
#define HANDLER_REG_TO_REG(s, d) \
    switch (SZ_L(d)) { \
        case Op_sz8: REG_L(s,d).sz8 = REG_R(s,d).sz8; break; \
        case Op_sz16: REG_L(s,d).sz16 = REG_R(s,d).sz16; break; \
        default: return EXEC_ERROR_INVALID_OP_SZ; \
    }

// 处理立即数到寄存器的赋值逻辑
#define HANDLER_IMM_TO_REG(s, d) \
    switch (SZ_L(d)) { \
        case Op_sz8: REG_L(s,d).sz8 = IMM1(d).sz8; break; \
        case Op_sz16: REG_L(s,d).sz16 = IMM1(d).sz16; break; \
        default: return EXEC_ERROR_INVALID_OP_SZ; \
    }

然后你的MOV handler就能简化成非常清爽的版本：

switch (LAYOUT(d)) {
    case Ops_layout_Reg2:
        HANDLER_REG_TO_REG(s, d);
        break;
    case Ops_layout_RegImm:
        HANDLER_IMM_TO_REG(s, d);
        break;
    case Ops_layout_Imm2:
    case Ops_layout_ImmReg:
    default:
        return EXEC_ERROR_INVALID_3ADDR_OPS_LAYOUT;
}

这个方案完全不需要改变现有代码的语义，只是把重复的代码块打包，维护起来也方便——以后要加Op_sz32/64，只需要在宏里加一个case就行，所有用到宏的地方都会自动更新。

方案2：利用C23的_Generic泛型选择（编译期分发） #

如果想尝试更现代的C23特性，可以用_Generic来实现编译期的操作分发。不过要注意_Generic是类型驱动的，所以我们需要把操作数大小枚举和对应的类型关联起来，再封装成宏：

// 辅助宏：根据操作数大小选择对应的union成员赋值
#define CELL_SET(dst, src, sz) \
    _Generic( (sz == Op_sz8 ? (unsigned char*)0 : (unsigned short*)0), \
        unsigned char*: (dst).sz8 = (src).sz8, \
        unsigned short*: (dst).sz16 = (src).sz16 \
    )

// 封装寄存器到寄存器的赋值
#define ASSIGN_REG_REG(s, d) CELL_SET(REG_L(s,d), REG_R(s,d), SZ_L(d))
// 封装立即数到寄存器的赋值
#define ASSIGN_IMM_REG(s, d) CELL_SET(REG_L(s,d), IMM1(d), SZ_L(d))

然后在handler里还需要加一个合法性检查（因为_Generic处理不了默认情况的运行时错误）：

switch (LAYOUT(d)) {
    case Ops_layout_Reg2:
        if (SZ_L(d) != Op_sz8 && SZ_L(d) != Op_sz16) {
            return EXEC_ERROR_INVALID_OP_SZ;
        }
        ASSIGN_REG_REG(s, d);
        break;
    case Ops_layout_RegImm:
        if (SZ_L(d) != Op_sz8 && SZ_L(d) != Op_sz16) {
            return EXEC_ERROR_INVALID_OP_SZ;
        }
        ASSIGN_IMM_REG(s, d);
        break;
    // 其他case和之前一致
}

这个方案把分支逻辑从运行时的switch转移到了编译期的泛型选择，代码更简洁，而且编译期就能帮你检查是否有未处理的类型。

方案3：函数指针数组（带优化的运行时分发） #

你担心函数指针不能内联，但实际上只要开启编译器优化（比如-O2或更高），主流编译器（GCC、Clang、MSVC）都会把简单的函数指针调用内联，尤其是当数组索引是可预测的枚举值时。

首先定义静态inline的操作函数：

static inline void assign_reg_reg_8(Cell16* dst, const Cell16* src) {
    dst->sz8 = src->sz8;
}

static inline void assign_reg_reg_16(Cell16* dst, const Cell16* src) {
    dst->sz16 = src->sz16;
}

static inline void assign_imm_reg_8(Cell16* dst, const Cell16* src) {
    dst->sz8 = src->sz8;
}

static inline void assign_imm_reg_16(Cell16* dst, const Cell16* src) {
    dst->sz16 = src->sz16;
}

然后定义函数指针数组，用枚举值的整数特性做索引（比如Op_sz8=8，索引为8/8-1=0；Op_sz16=16，索引为16/8-1=1）：

static void (*const reg_reg_assign[])(Cell16*, const Cell16*) = {
    assign_reg_reg_8,
    assign_reg_reg_16
};

static void (*const imm_reg_assign[])(Cell16*, const Cell16*) = {
    assign_imm_reg_8,
    assign_imm_reg_16
};

最后在handler里调用：

switch (LAYOUT(d)) {
    case Ops_layout_Reg2: {
        int idx = SZ_L(d) / 8 - 1;
        if (idx < 0 || idx >= sizeof(reg_reg_assign)/sizeof(*reg_reg_assign)) {
            return EXEC_ERROR_INVALID_OP_SZ;
        }
        reg_reg_assign[idx](&REG_L(s,d), &REG_R(s,d));
        break;
    }
    case Ops_layout_RegImm: {
        int idx = SZ_L(d) / 8 - 1;
        if (idx < 0 || idx >= sizeof(imm_reg_assign)/sizeof(*imm_reg_assign)) {
            return EXEC_ERROR_INVALID_OP_SZ;
        }
        imm_reg_assign[idx](&REG_L(s,d), &IMM1(d));
        break;
    }
    // 其他case和之前一致
}

开启优化后，编译器会自动把这些函数指针调用内联成直接的成员赋值，和原代码的性能完全一致，同时代码结构更模块化。

总结 #

• 如果想最小化代码改动，方案1的宏封装是最优选择，完全兼容现有逻辑，维护成本低；
• 如果想尝试C23的现代特性，**方案2的_Generic**能实现编译期分发，代码更简洁；
• 如果想让代码结构更模块化，方案3的函数指针数组在开启优化后性能无损失，同时逻辑更清晰。

内容来源于stack exchange