🔀 第11课：分支与跳转

📖 本课目标

深入实现分支与跳转指令：JMP、JZ/JNZ、JC/JNC、JN/JNN、CALL、RET。这些指令控制程序的执行流——从简单的条件判断到子程序调用，是结构化编程的基础。

CALL/RET与堆栈

CALL指令将返回地址（PC+3，因为CALL是3字节指令）压入堆栈，然后跳转到目标地址。RET从堆栈弹出返回地址到PC。这就是C语言函数调用的底层实现。

嵌套调用与递归

因为每次CALL都把返回地址压栈，RET都弹出，所以自然支持嵌套调用和递归：

// 嵌套调用示例
// main() → func_a() → func_b()

main:
    CALL func_a
    HLT

func_a:
    CALL func_b
    RET

func_b:
    // 做些事情
    RET

// 堆栈变化：
// CALL func_a:  PUSH main_ret, PC=func_a
// CALL func_b:  PUSH func_a_ret, PC=func_b
// RET (func_b): POP → PC=func_a_ret
// RET (func_a): POP → PC=main_ret

状态机实现

状态机是嵌入式编程的核心模式：

// 简单的状态机：LED闪烁控制器
// 状态0: LED灭，等待1秒
// 状态1: LED亮，等待0.5秒

STATE0:  // LED灭
    ANDI R1, #0xFE   // LED off (bit0=0)
    STA  R1, $FF07
    LDI  R2, #100    // 1秒(10ms×100)
WAIT0:
    LDI  R3, #10     // 10ms延时
    CALL delay_ms
    DEC  R2
    JNZ  WAIT0
    JMP  STATE1

STATE1:  // LED亮
    ORI  R1, #0x01   // LED on (bit0=1)
    STA  R1, $FF07
    LDI  R2, #50     // 0.5秒
WAIT1:
    LDI  R3, #10
    CALL delay_ms
    DEC  R2
    JNZ  WAIT1
    JMP  STATE0

协作式多任务

用状态机模拟多任务——每个"任务"是一个状态，每个循环执行一步：

// 3个协作任务的调度器
MAIN_LOOP:
    CALL task_led      // 任务1: LED闪烁
    CALL task_key      // 任务2: 键盘扫描
    CALL task_uart     // 任务3: 串口通信
    JMP  MAIN_LOOP     // 循环调度

// 每个任务内部用状态变量记录进度
// 每次被调用时执行一步，然后返回
task_led:
    LDA  R1, led_state
    CMP  R1, #0
    JZ   led_off_state
    // ... LED on state
    RET
led_off_state:
    // ... LED off state
    RET

相对分支偏移计算器

条件分支使用8位有符号偏移。偏移的计算公式：

偏移 = 目标地址 - (分支指令地址 + 指令长度)

例子：从$8010跳转到$8005
  偏移 = $8005 - ($8010 + 2) = $8005 - $8012 = -13
  -13的8位补码 = 0xF3

验证：PC = $8012 + 0xFFF3 = $8012 - 13 = $8005 ✅

例子：从$8020跳转到$8030
  偏移 = $8030 - ($8020 + 2) = $8030 - $8022 = +14
  14 = 0x0E

注意：偏移范围 = -128 ~ +127
  如果跳转距离超过这个范围，需要用JMP替代

if-else 的多种实现

同一个if-else可以有多种汇编实现，效率各不同：

// 方案1: 条件跳过then块（适合短then）
// if (R1 == 0) then_block
    JNZ  skip_then
    // then块
skip_then:

// 方案2: 条件跳到else（标准方式）
// if (R1 > 10) { then } else { else }
    LDI  R2, #10
    CMP  R1, R2
    JNN  else_block    // R1 <= 10 → else
    // then块 (R1 > 10)
    JMP  end_if
else_block:
    // else块
end_if:

// 方案3: 位测试（检查单个位）
// if (R1 的 bit3 为1)
    ANDI R1, #0x08
    JZ   bit3_is_0
    // bit3 = 1
    JMP  done
bit3_is_0:
    // bit3 = 0
done:

switch-case的跳转表实现

当case数量多且值连续时，跳转表比一连串CMP+JZ更高效：

// switch(R1) { case 0:... case 1:... case 2:... }
// 跳转表存放在000
// 每个表项是2字节地址

    // 边界检查
    CMP  R1, #3
    JNN  default_case
    
    // 计算跳转表偏移: R1 * 2
    MOV  R3, R1       // X = index
    SHL  R1           // R1 = index * 2
    MOV  R3, R1       // X = offset
    
    // 从跳转表读取目标地址
    LDA  R2, 000,X  // 地址低8位
    INC  R3
    LDA  R1, 000,X  // 地址高8位
    // JMP {R1,R2} (间接跳转)

循环展开

减少循环次数，每次迭代多做几次操作：

// 原始循环：每次处理1个元素
// for(i=0; i<100; i++) sum += array[i]
LDI R3, #0
LDI R4, #100
LOOP1:
    LDA  R2, 000,X
    ADD  R1, R2
    INC  R3
    CMP  R3, R4
    JNZ  LOOP1
// 每个元素：5条指令 + 分支开销

// 展开4倍：每次处理4个元素
// 100/4 = 25次迭代
LDI R3, #0
LDI R4, #25
LOOP4:
    LDA  R2, 000,X  // 元素0
    ADD  R1, R2
    INC  R3
    LDA  R2, 000,X  // 元素1
    ADD  R1, R2
    INC  R3
    LDA  R2, 000,X  // 元素2
    ADD  R1, R2
    INC  R3
    LDA  R2, 000,X  // 元素3
    ADD  R1, R2
    INC  R3
    DEC  R4
    JNZ  LOOP4
// 减少了75%的分支判断开销

倒计数循环

与0比较不需要CMP指令（可以用DEC+JNZ直接判断零标志），所以倒计数比正计数更高效：

// 正计数：需要CMP
    LDI  R2, #0
loop:
    // ... 循环体 ...
    INC  R2
    LDI  R3, #100
    CMP  R2, R3      // 需要CMP
    JNZ  loop

// 倒计数：DEC自动设置Z标志
    LDI  R2, #100
loop:
    // ... 循环体 ...
    DEC  R2           // DEC自动设置Z
    JNZ  loop         // 不需要CMP！省2字节

注意：条件分支taken比not taken多1个周期（需要计算偏移地址）。