• 计算机系统基础第六周作业

    第1题：汇编器开发

    请开发一个RISC-V汇编器，支持自动将以下RISC-V汇编指令编译成RISC-V机器码。要求如下：

    （1）该汇编器需支持的汇编命令包含：lui，sw，addi，add。

    （2）汇编器运行方式：创建一个名为source.s的汇编源代码文本，随意挑选4条lui，sw，addi，add汇编测试语句，将这4条汇编语句写入到source.s文本中。然后用开发的汇编器运行该文本，并将生成的机器码输出到另一个名为binary.txt的文本中。最后再比较生成的机器码与附件1中的机器码是否一致，从而验证汇编器的功能（生成的机器码在binary.txt中用16进制表示）。

    （3）汇编器功能要求如下：

    a）能进行语法纠错，例如：如果输入luik  a3, 0x200，会进行报错，并指出语法错误的位置luik。

    b）能检查参数的非法范围，例如，若输入lui  a3, 0x2000000，则会提醒0x2000000超出合法界限。

    c）不考虑压缩型指令，所以指令机器码均为4字节（32位）。

    （4）汇编器使用的开发语言没有限制。本文使用Python写。

    下面将定义Assembler类，即这个汇编器的核心，它包含几个方法来编码不同的汇编指令。首先进行初始化，再定义encode方法（它接受一个汇编指令字符串作为输入，然后基于指令的类型调用相应的编码方法），然后分别定义lui，sw，addi，add具体的encode编码方法，在每个方法中定义转换机器码、语法纠错、检查参数范围的功能。

    1. 初始化：给出寄存器注册名及其编号

    基于RISC-V的RV32I基本整数指令集的约定给出注册名和对应的编号。其中的键是RISC-V的寄存器名称，而值是它们对应的5位二进制编码。

    1.     def __init__(self):
    2.         # 注册名和其对应的编号
    3.         self.registers = {
    4.             "zero": "00000",
    5.             "ra": "00001",
    6.             "sp": "00010",
    7.             "gp": "00011",
    8.             "tp": "00100",
    9.             "t0": "00101",
    10.             "t1": "00110",
    11.             "t2": "00111",
    12.             "s0": "01000",
    13.             "s1": "01001",
    14.             "a0": "01010",
    15.             "a1": "01011",
    16.             "a2": "01100",
    17.             "a3": "01101",
    18.             "a4": "01110",
    19.             "a5": "01111",
    20.             "a6": "10000",
    21.             "a7": "10001",
    22.             "s2": "10010",
    23.             "s3": "10011",
    24.             "s4": "10100",
    25.             "s5": "10101",
    26.             "s6": "10110",
    27.             "s7": "10111",
    28.             "s8": "11000",
    29.             "s9": "11001",
    30.             "s10": "11010",
    31.             "s11": "11011",
    32.             "t3": "11100",
    33.             "t4": "11101",
    34.             "t5": "11110",
    35.             "t6": "11111"
    36.         }

    在RISC-V中，这些寄存器有特定的用途。例如：

    • zero（x0）：硬连线为0的寄存器，任何写入操作都会被忽略。
    • ra（x1）：返回地址。
    • sp（x2）：堆栈指针。
    • gp（x3）：全局指针。
    • tp（x4）：线程指针。

    之后的寄存器，如t0-t6，是临时寄存器，用于一般的操作，而a0-a7用于函数参数和返回值。s0-s11是保存寄存器，它们在调用过程中的值应该被保留。

    2. 核心调度方法：encode

    它接受一个汇编指令字符串作为输入，然后基于指令的类型调用相应的编码方法。

    1.     def encode(self, instruction):
    2.         if "lui" in instruction:
    3.             return self.encode_lui(instruction)
    4.         elif "sw" in instruction:
    5.             return self.encode_sw(instruction)
    6.         elif "addi" in instruction:
    7.             return self.encode_addi(instruction)
    8.         elif "add" in instruction:
    9.             return self.encode_add(instruction)
    10.         else:
    11.             raise ValueError(f"Unsupported instruction: {instruction}")

    其中的instruction就是我们将来要传递的汇编语句！这里只是初步判断语句的正确性：起码要保证句子里面含有lui，sw，addi，add吧？不含有的话就提前报错，这也算写的格式不对！

    3. 各类指令的编码方法

    1.     def encode_lui(self, instruction):
    2.         # 检查语法格式
    3.         if not re.match(r'^lui\s+[a-z0-9]+,\s*0x[a-fA-F0-9]+$', instruction):
    4.             raise ValueError(f"Syntax error in instruction: {instruction}")
    5.         tokens = instruction.split()
    6.         rd = self.registers.get(tokens[1].replace(',', ''))
    7.         if rd is None:
    8.             raise ValueError(f"Unknown register: {tokens[1]}")
    9.         imm = bin(int(tokens[2], 16))[2:].zfill(20)
    10.         if len(imm) > 20:
    11.             raise ValueError(f"Immediate value out of bounds: {tokens[2]}")
    12.         opcode = "0110111"
    13.         return imm + rd + opcode
    14.  
    15.     def encode_sw(self, instruction):
    16.         # 检查语法格式
    17.         if not re.match(r'^sw\s+[a-z0-9]+,\s*[0-9]+\([a-z0-9]+\)$', instruction):
    18.             raise ValueError(f"Syntax error in instruction: {instruction}")
    19.         tokens = [token for token in re.split('[ ,()]', instruction) if token]
    20.         rs2 = self.registers.get(tokens[1])
    21.         rs1 = self.registers.get(tokens[3])
    22.         if rs1 is None or rs2 is None:
    23.             raise ValueError(f"Unknown register in instruction: {instruction}")
    24.         offset = bin(int(tokens[2], 16))[2:].zfill(12)
    25.         if len(offset) > 12:
    26.             raise ValueError(f"Offset out of bounds: {tokens[2]}")
    27.         opcode = "0100011"
    28.         funct3 = "010"
    29.  
    30.         # Split the offset for the instruction format
    31.         imm_11_5 = offset[:7]
    32.         imm_4_0 = offset[7:]
    33.         return imm_11_5 + rs2 + rs1 + funct3 + imm_4_0 + opcode
    34.  
    35.     def encode_addi(self, instruction):
    36.         # 检查语法格式
    37.         if not re.match(r'^addi\s+[a-z0-9]+,\s*[a-z0-9]+,\s*-?[0-9]+$', instruction):
    38.             raise ValueError(f"Syntax error in instruction: {instruction}")
    39.         tokens = instruction.split()
    40.         rd = self.registers.get(tokens[1].replace(',', ''))
    41.         rs1 = self.registers.get(tokens[2].replace(',', ''))
    42.         if rd is None or rs1 is None:
    43.             raise ValueError(f"Unknown register in instruction: {instruction}")
    44.         imm = bin(int(tokens[3]))[2:].zfill(12)
    45.         if len(imm) > 12:
    46.             raise ValueError(f"Immediate value out of bounds: {tokens[3]}")
    47.         opcode = "0010011"
    48.         funct3 = "000"
    49.         return imm + rs1 + funct3 + rd + opcode
    50.  
    51.     def encode_add(self, instruction):
    52.         # 检查语法格式
    53.         if not re.match(r'^add\s+[a-z0-9]+,\s*[a-z0-9]+,\s*[a-z0-9]+$', instruction):
    54.             raise ValueError(f"Syntax error in instruction: {instruction}")
    55.         tokens = instruction.split()
    56.         rd = self.registers.get(tokens[1].replace(',', ''))
    57.         rs1 = self.registers.get(tokens[2].replace(',', ''))
    58.         rs2 = self.registers.get(tokens[3])
    59.         if rd is None or rs1 is None or rs2 is None:
    60.             raise ValueError(f"Unknown register in instruction: {instruction}")
    61.         opcode = "0110011"
    62.         funct3 = "000"
    63.         funct7 = "0000000"
    64.         return funct7 + rs2 + rs1 + funct3 + rd + opcode

    这些函数都大差不差，可以概括为：首先通过正则表达式检查语法格式，如果存在“luik”这种错误格式，就报错；然后将指令分解为tokens，便于转换机器码；然后就开始转换呗！转换规则都是基于RISC-V的RV32I基本整数指令集的约定。

    4. 读取source.s文件，将结果写入binary.txt

    这就涉及到Python的读写，对source.s文件中每一行指令读写后，将其内容赋给instructions，再使用核心调度方法encode( )，最后将结果以hex十六进制的格式写入binary.txt文件中。

    1.     def from_file(self, input_file="source.s"):
    2.         with open(input_file, 'r') as file:
    3.             instructions = file.readlines()
    4.             binary_codes = [self.encode(instruction.strip()) for instruction in instructions]
    5.             with open("binary.txt", 'w') as out_file:
    6.                 for code in binary_codes:
    7.                     out_file.write(hex(int(code, 2))[2:].zfill(8) + '\n')

    以上都是Assembler类的定义，也就是汇编器的定义。下面我们再创建汇编器的实例assembler，调用from_file( )函数就可以：

    1. assembler = Assembler()
    2. assembler.from_file()

    下面我们对结果进行检验，准备好source.s文件：

    1. lui a5, 0x20000
    2. addi a5, a5, 12
    3. sw a4, 4(a5)
    4. add a4, a4, a5

    运行后产生binary.txt文件，内容如下：

    1. 200007b7
    2. 00c78793
    3. 00e7a223
    4. 00f70733

    与实际汇编器的内容进行比较发现，本文开发的汇编器结果正确！至此，问题一解决！完整源码如下：

    1. import re
    2.  
    3. class Assembler:
    4.     def __init__(self):
    5.         # 注册名和其对应的编号
    6.         self.registers = {
    7.             "zero": "00000",
    8.             "ra": "00001",
    9.             "sp": "00010",
    10.             "gp": "00011",
    11.             "tp": "00100",
    12.             "t0": "00101",
    13.             "t1": "00110",
    14.             "t2": "00111",
    15.             "s0": "01000",
    16.             "s1": "01001",
    17.             "a0": "01010",
    18.             "a1": "01011",
    19.             "a2": "01100",
    20.             "a3": "01101",
    21.             "a4": "01110",
    22.             "a5": "01111",
    23.             "a6": "10000",
    24.             "a7": "10001",
    25.             "s2": "10010",
    26.             "s3": "10011",
    27.             "s4": "10100",
    28.             "s5": "10101",
    29.             "s6": "10110",
    30.             "s7": "10111",
    31.             "s8": "11000",
    32.             "s9": "11001",
    33.             "s10": "11010",
    34.             "s11": "11011",
    35.             "t3": "11100",
    36.             "t4": "11101",
    37.             "t5": "11110",
    38.             "t6": "11111"
    39.         }
    40.  
    41.     def encode(self, instruction):
    42.         if "lui" in instruction:
    43.             return self.encode_lui(instruction)
    44.         elif "sw" in instruction:
    45.             return self.encode_sw(instruction)
    46.         elif "addi" in instruction:
    47.             return self.encode_addi(instruction)
    48.         elif "add" in instruction:
    49.             return self.encode_add(instruction)
    50.         else:
    51.             raise ValueError(f"Unsupported instruction: {instruction}")
    52.  
    53.     def encode_lui(self, instruction):
    54.         # 检查语法格式
    55.         if not re.match(r'^lui\s+[a-z0-9]+,\s*0x[a-fA-F0-9]+$', instruction):
    56.             raise ValueError(f"Syntax error in instruction: {instruction}")
    57.         tokens = instruction.split()
    58.         rd = self.registers.get(tokens[1].replace(',', ''))
    59.         if rd is None:
    60.             raise ValueError(f"Unknown register: {tokens[1]}")
    61.         imm = bin(int(tokens[2], 16))[2:].zfill(20)
    62.         if len(imm) > 20:
    63.             raise ValueError(f"Immediate value out of bounds: {tokens[2]}")
    64.         opcode = "0110111"
    65.         return imm + rd + opcode
    66.  
    67.     def encode_sw(self, instruction):
    68.         # 检查语法格式
    69.         if not re.match(r'^sw\s+[a-z0-9]+,\s*[0-9]+\([a-z0-9]+\)$', instruction):
    70.             raise ValueError(f"Syntax error in instruction: {instruction}")
    71.         tokens = [token for token in re.split('[ ,()]', instruction) if token]
    72.         if len(tokens) != 4:
    73.             raise ValueError(f"Syntax error in instruction: {instruction}")
    74.         rs2 = self.registers.get(tokens[1])
    75.         rs1 = self.registers.get(tokens[3])
    76.         if rs1 is None or rs2 is None:
    77.             raise ValueError(f"Unknown register in instruction: {instruction}")
    78.         offset = bin(int(tokens[2], 16))[2:].zfill(12)
    79.         if len(offset) > 12:
    80.             raise ValueError(f"Offset out of bounds: {tokens[2]}")
    81.         opcode = "0100011"
    82.         funct3 = "010"
    83.  
    84.         # Split the offset for the instruction format
    85.         imm_11_5 = offset[:7]
    86.         imm_4_0 = offset[7:]
    87.         return imm_11_5 + rs2 + rs1 + funct3 + imm_4_0 + opcode
    88.  
    89.     def encode_addi(self, instruction):
    90.         # 检查语法格式
    91.         if not re.match(r'^addi\s+[a-z0-9]+,\s*[a-z0-9]+,\s*-?[0-9]+$', instruction):
    92.             raise ValueError(f"Syntax error in instruction: {instruction}")
    93.         tokens = instruction.split()
    94.         if len(tokens) != 4:
    95.             raise ValueError(f"Syntax error in instruction: {instruction}")
    96.         rd = self.registers.get(tokens[1].replace(',', ''))
    97.         rs1 = self.registers.get(tokens[2].replace(',', ''))
    98.         if rd is None or rs1 is None:
    99.             raise ValueError(f"Unknown register in instruction: {instruction}")
    100.         imm = bin(int(tokens[3]))[2:].zfill(12)
    101.         if len(imm) > 12:
    102.             raise ValueError(f"Immediate value out of bounds: {tokens[3]}")
    103.         opcode = "0010011"
    104.         funct3 = "000"
    105.         return imm + rs1 + funct3 + rd + opcode
    106.  
    107.     def encode_add(self, instruction):
    108.         # 检查语法格式
    109.         if not re.match(r'^add\s+[a-z0-9]+,\s*[a-z0-9]+,\s*[a-z0-9]+$', instruction):
    110.             raise ValueError(f"Syntax error in instruction: {instruction}")
    111.         tokens = instruction.split()
    112.         if len(tokens) != 4:
    113.             raise ValueError(f"Syntax error in instruction: {instruction}")
    114.         rd = self.registers.get(tokens[1].replace(',', ''))
    115.         rs1 = self.registers.get(tokens[2].replace(',', ''))
    116.         rs2 = self.registers.get(tokens[3])
    117.         if rd is None or rs1 is None or rs2 is None:
    118.             raise ValueError(f"Unknown register in instruction: {instruction}")
    119.         opcode = "0110011"
    120.         funct3 = "000"
    121.         funct7 = "0000000"
    122.         return funct7 + rs2 + rs1 + funct3 + rd + opcode
    123.  
    124.     def from_file(self, input_file="source.s"):
    125.         with open(input_file, 'r') as file:
    126.             instructions = file.readlines()
    127.             binary_codes = [self.encode(instruction.strip()) for instruction in instructions]
    128.             with open("binary.txt", 'w') as out_file:
    129.                 for code in binary_codes:
    130.                     out_file.write(hex(int(code, 2))[2:].zfill(8) + '\n')
    131.  
    132.     # 示例运行
    133. assembler = Assembler()
    134. assembler.from_file()

    第2题：手工编译

    若&a = 0x20000000，&b = 0x20000004，&c = 0x20000008，请手工写出以下语句的汇编代码的机器码：c = a + b + 0x6000（说明：汇编实现方法不唯一，能实现功能即可）。

    汇编代码实现

    Lui a4,0x20000 #a

    Lw a5,4(a4) #b

    Lw a6,8(a4) #c

    Add a6,a4,a5

    Lui a7,0x6 

    Add a6,a6,a7

    其中，Lui a7,0x6中的0x6就是0x00006，只不过按照老师上上次课讲的，可以把前面的0省略掉。因为0x6000正好是4位十六进制数，刚好超过addi的imm范围，所以需要通过加载lui的上位部分才ok！

    机器码实现

    机器码（第一行为汇编指令，第二行为机器码格式，第三行为转换的机器码）如下：(a4实际地址为x14，a5a6a7同样如此)

    Lui a4, 0x20000 加载上位指令

    imm[31:12] rd opcode

    0010,0000,0000,0000,0000,0111,0011,0111

    Lw a5, 4(a4)

    imm[11:0] rs1 funct3 rd opcode

    0000,0000,0100,0111,0010,0111,1000,0011

    同理：

    Lw a6,8(a4)的机器码为：

    0000,0000,1000,0111,0010,1000,0000,0011

    Add a6,a4,a5 #注意这里rs2是a5，rs1是a4

    funct7 rs2 rs1 funct3 rd opcode

    0000,0000,1111,0111,0000,1000,0011,0011

    Lui a7,0x6

    imm[31:12] rd opcode

    0000,0000,0000,0000,0110,1000,1000,0011

    Add a6,a6,a7

    funct7 rs2 rs1 funct3 rd opcode

    0000,0001,0001,1000,0000,1000,0011,0011

  • 相关阅读:
    7_画图常用代码
    第3章 Linux多线程开发 01线程
    vuex实现简易购物车加购效果
    《持续交付：发布可靠软件的系统方法》- 读书笔记（五）
    智能导诊系统：基于机器学习和自然语言处理技术，可快速推荐合适的科室和医生
    【leetcode top100】两数相加。无重复字符的最长子串，盛水最多的容器，三数之和
    WAMP服务器对python进行配置
    一篇文章让你理解TCP协议，搭建TCP flood攻击实验以及了解其防御原理
    从零开始学习rust语言
    Codeforces 1281F 树上背包
  • 原文地址：https://blog.csdn.net/qq_65052774/article/details/133814186