ISA(Instruction Set Architecture):指令集体系结构
软件和硬件之间接口的完整定义
| 内容 | 说明 |
|---|---|
| 指令集 | 支持的全部指令 |
| 操作数类型 | 支持的数据类型(如整数、浮点) |
| 寻址方式 | 操作数地址的表示方法 |
| 寄存器集 | 可用的通用寄存器和专用寄存器 |
| 存储模型 | 地址空间、字节序等 |
| 中断和异常 | 处理机制 |
| 类型 | 示例 | 功能 |
|---|---|---|
| 数据传送 | mov, load, store | 传送数据 |
| 算术运算 | add, sub, mul, div | 算术计算 |
| 逻辑运算 | and, or, xor, not | 逻辑运算 |
| 移位运算 | shl, shr | 位移操作 |
| 程序控制 | jmp, jz, call, ret | 控制执行流程 |
| 输入输出 | in, out | 与外设交互 |
格式:[opcode | rs | rt]
功能:从rs取操作数,与rt操作数运算,结果存回rs
| opcode | rs | rt |
|---|---|---|
| 4位 | 2位 | 2位 |
格式:[opcode | address]
功能:访问主存address地址单元
| opcode | address |
|---|---|
| 4位 | 4位 |
| 指令 | 类型 | 功能 | 示例 |
|---|---|---|---|
| mov | R | 传送 | mov r0, r1 |
| add | R | 加法 | add r0, r1 |
| sub | R | 减法 | sub r0, r1 |
| mul | R | 乘法 | mul r0, r1 |
| load | M | 取数(主存→寄存器) | load r0, [10] |
| store | M | 存数(寄存器→主存) | store [10], r0 |
| 寻址方式 | 操作数位置 | 特点 | 示例 |
|---|---|---|---|
| 立即寻址 | 指令中 | 最快,固定值 | mov r0, #100 |
| 直接寻址 | 主存 | 地址在指令中 | mov r0, [100] |
| 间接寻址 | 主存 | 地址所在单元存操作数地址 | mov r0, [@ptr] |
| 寄存器寻址 | 寄存器 | 最快,通用 | mov r0, r1 |
| 寄存器间接寻址 | 主存(寄存器存地址) | 灵活 | mov r0, [r1] |
| 相对寻址 | PC+偏移 | 与位置无关 | jmp $+10 |
| 变址寻址 | 变址寄存器+偏移 | 数组访问 | mov r0, [r1+8] |
指令格式:mov r0, #100
↓
操作数100直接存在于指令中
优点:获取操作数最快
缺点:操作数固定,不灵活
指令格式:mov r0, [100]
↓
指令中给出主存地址100,从M[100]取操作数
优点:直观
缺点:地址固定,不灵活
指令格式:mov r0, [@ptr]
↓
@ptr单元存操作数地址,例如@ptr=100,则从M[100]取操作数
优点:可动态修改地址
缺点:需两次访存
指令格式:mov r0, r1
↓
操作数在r1寄存器中
优点:最快(无需访存)
缺点:寄存器数量有限
指令格式:mov r0, [r1]
↓
r1存主存地址,从M[r1]取操作数
优点:灵活,可变址
缺点:需一次访存
指令格式:jmp $+10
↓
目标地址 = PC当前值 + 10
优点:与代码位置无关,可重定位
用途:分支跳转、循环
指令格式:mov r0, [r1+8]
↓
目标地址 = r1内容 + 8
优点:方便数组/表格访问
用途:数组元素访问
┌─────────────────────────────────────────────────────────┐
│ 指令执行周期 │
├─────────────────────────────────────────────────────────┤
│ │
│ ① 取指令(Fetch) PC → MAR → M → MDR → IR │
│ ↓ │
│ ② 译码(Decode) IR.opcode → 控制单元 │
│ ↓ │
│ ③ PC增量 PC → PC + 1(或跳转地址) │
│ ↓ │
│ ④ 取操作数 根据寻址方式获取操作数 │
│ ↓ │
│ ⑤ 执行(Execute) ALU运算 │
│ ↓ │
│ ⑥ 送结果 结果写入目的寄存器或主存 │
│ │
└─────────────────────────────────────────────────────────┘
模型机规格: - 8位定长指令字 - 8个通用寄存器(R0~R7) - 16个字的主存
指令格式:
R型指令:[op(4位) | rs(2位) | rt(2位)]
M型指令:[op(4位) | addr(4位)]
操作码定义:
| 操作码 | 指令 | 类型 | 功能 |
|---|---|---|---|
| 0000 | mov | R | R[rs] ← R[rt] |
| 0001 | add | R | R[rs] ← R[rs] + R[rt] |
| 0010 | sub | R | R[rs] ← R[rs] - R[rt] |
| 0011 | mul | R | R[rs] ← R[rs] × R[rt] |
| 1110 | load | M | R[rs] ← M[addr] |
| 1111 | store | M | M[addr] ← R[rs] |
例题:执行 z = x + y,其中x存放在主存5#单元,y在6#单元,结果z存入7#单元。
解法:
假设初始状态:
- R0, R1 为临时寄存器
- M[5] = x = 10
- M[6] = y = 20
- M[7] = z = 0
指令序列:
I1: load r0, [6] // R[0] ← M[6],取y到R0
→ M[6] = 20 → R0 = 20
I2: mov r1, r0 // R[1] ← R[0],复制y到R1
→ R1 = 20
I3: load r0, [5] // R[0] ← M[5],取x到R0
→ M[5] = 10 → R0 = 10
I4: add r0, r1 // R[0] ← R[0] + R[1],x+y
→ R0 = 10 + 20 = 30
I5: store [7], r0 // M[7] ← R[0],存结果z
→ M[7] = 30
PC(程序计数器)的作用:
- 存放下一条要执行的指令地址
- 正常顺序执行时,每条指令后PC+1
- 遇到跳转指令时,PC被设置为目标地址
顺序型指令:PC ← PC + 1
跳转型指令:PC ← 目标地址
源代码(.c)
↓ 预处理 (cpp)
预处理后的源程序(.i)
↓ 编译 (ccl)
汇编语言程序(.s)
↓ 汇编 (as)
可重定位目标文件(.o)
↓ 链接 (ld)
可执行目标文件
| 阶段 | 工具 | 输入 | 输出 | 说明 |
|---|---|---|---|---|
| 预处理 | 预处理器 | .c | .i | 处理#include、#define |
| 编译 | 编译器 | .i | .s | 翻译成汇编语言 |
| 汇编 | 汇编器 | .s | .o | 翻译成机器语言 |
| 链接 | 链接器 | 多个.o | 可执行文件 | 合并、重定位 |
以下寻址方式中,操作数速度最快的是( ) A. 立即寻址 B. 直接寻址 C. 寄存器寻址 D. 间接寻址
R型指令和M型指令的主要区别是( ) A. 操作数个数不同 B. 是否有存储器访问 C. 指令长度不同 D. 功能不同
指令"load r0, [6]"的功能是( ) A. R[0] ← R[6] B. R[0] ← M[6] C. M[6] ← R[0] D. M[0] ← R[6]
相对寻址方式中,转移目标地址的计算公式是( ) A. PC + 偏移量 B. 基址 + 偏移量 C. 变址 + 偏移量 D. 立即数
编译阶段生成的输出文件是( ) A. .c 文件 B. .i 文件 C. .s 文件 D. .o 文件
ISA是指______的缩写。
寻址方式中,操作数直接存在于指令中的方式是______寻址。
指令执行过程中,将PC内容送到MAR以便读取指令的阶段称为______。
指令"store [10], r0"是______型指令。
汇编阶段将______语言程序翻译成机器语言。
简述指令执行的基本过程。
比较七种寻址方式的特点。
解释ISA和微架构的区别。
说明从源代码到可执行文件的转换过程。
假设某模型机指令集如下: - load r, [addr]:R[r] ← M[addr] - store [addr], r:M[addr] ← R[r] - mov r1, r2:R[r1] ← R[r2] - add r1, r2:R[r1] ← R[r1] + R[r2]
请写出计算表达式 a = b + c 的指令序列(假设a、b、c分别存放在主存10#、11#、12#单元)
解:计算 a = b + c
假设使用R0作为临时寄存器
指令序列:
1. load r0, [11] // R[0] ← M[11],取b到R0
2. mov r1, r0 // R[1] ← R[0],暂存b到R1
3. load r0, [12] // R[0] ← M[12],取c到R0
4. add r0, r1 // R[0] ← R[0] + R[1],b+c
5. store [10], r0 // M[10] ← R[0],存结果a