MIPS汇编器设计

已于 2024-01-21 13:57:11 修改
阅读量523 收藏 9
点赞数 8
文章标签： python
于 2023-12-26 21:34:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74173457/article/details/135231929
版权

 题目描述

        

请使用Python/C++语言，实现一个MIPS的汇编器，完成将你常用到的汇编指令翻译为机器指令。

输入：汇编语言程序文件

输出：二进制或十六进制文件，采用Xilinx Vivado的COE文件格式

代码实现 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# created by 染汐
# URL:
# Time:
# __________    _____    _______  ____  ___.___ 
# \______   \  /  _  \   \      \ \   \/  /|   |
#  |       _/ /  /_\  \  /   |   \ \     / |   |
#  |    |   \/    |    \/    |    \/     \ |   |
#  |____|_  /\____|__  /\____|__  /___/\  \|___|
#         \/         \/         \/      \_/     
import copy

file_path = r"D:\下载\mips.asm"
output_location = r"C:\Users\86130\Desktop\result.COE"
# R类型 (op rs rt rd shamt funct) 6 5 5 5 5 6
signal = []
register = {
    "$0": "00000",
    "$at": "00001",
    "$v0": "00010",
    "$v1": "00011",
    "$t0": "01000",
    "$t1": "01001",
    "$t2": "01010",
    "$t3": "01011",
    "$t4": "01100",
    "$t5": "01101",
    "$t6": "01110",
    "$t7": "01111",
    "$s0": "10000",
    "$s1": "10001",
    "$s2": "10010",
    "$s3": "10011",
    "$s4": "10100",
    "$s5": "10101",
    "$s6": "10110",
    "$s7": "10111",
    "$t8": "11000",
    "$t9": "11001",
    "$k0": "11010",
    "$k1": "11011",
    "$gp": "11100",
    "$sp": "11101",
    "$fp": "11110",
    "$ra": "11111"
}
# nop（空操作，等效于addi $0, $0, 0）
# li $x, abcd（将一个32位立即数abcd加载到目标寄存器x，请使用lui等指令序列实现，请注意立即数是补码形式）
# mv $a, $b（将寄存器b内容复制到寄存器a中，等效于addi $a, $b, 0）
# not $a, $b（将寄存器b内容取反后复制到寄存器a中，等效于xori $a, $b, -1）
# neg $a, $b（将寄存器b内容取负后复制到寄存器a中，等效于sub $a, $0, $b）
opcode = {
    "R_Type": "000000",
    "bltz": "000001",
    "j": "000010",
    "jal": "000011",
    "beq": "000100",
    "bne": "000101",
    "blez": "000110",
    "bgtz": "000111",
    "addi": "001000",
    "addiu": "001001",
    "slti": "001010",
    "sltiu": "001011",
    "andi": "001100",
    "ori": "001101",
    "xori": "001110",
    "lui": "001111",
    "mfc0": "010000",
    "mtc0": "010000",
    "F_Type": "010001",
    "bclf": "010001",
    "bclt": "010001",
    "mul": "011100",
    "lb": "100000",
    "lh": "100001",
    "lw": "100011",
    "lbu": "100100",
    "lhu": "100101",
    "sb": "101000",
    "sh": "101001",
    "sw": "101011",
    "lwcl": "110001",
    "swcl": "111001"
}
RTypeInstruct = {
    "sll": "000000",
    "srl": "000010",
    "sra": "000011",
    "sllv": "000100",
    "srlv": "000110",
    "srav": "000111",
    "jr": "001000",
    "jalr": "001001",
    "syscall": "001100",
    "break": "001101",
    "add": "100000",
    "sub": "100010",
    "and": "100100",
    "or": "100101",
    "xor": "100110",
    "nor": "100111",
    "slt": "101010",
    "mult": "011000",
    "mfhi": "010000",
    "mthi": "010001",
    "mflo": "010010",
    "mtlo": "010011",
    "div": "011010"
}

command_dict = {
    'bltz': {'type': 'I', 'opcode': 1, 'form': ['rs', 'imm']},
    'bgez': {'type': 'I', 'opcode': 1, 'form': ['rs', 'imm']},
    'j': {'type': 'J', 'opcode': 2, 'form': ['imm']},
    'jal': {'type': 'J', 'opcode': 3, 'form': ['imm']},
    'beq': {'type': 'I', 'opcode': 4, 'form': ['rs', 'rt', 'imm']},
    'bne': {'type': 'I', 'opcode': 5, 'form': ['rs', 'rt', 'imm']},
    'blez': {'type': 'I', 'opcode': 6, 'form': ['rs', 'imm']},
    'bgtz': {"type": 'I', "opcode": 7, 'form': ['rs', 'imm']},
    'addi': {'type': 'I', 'opcode': 8, 'form': ['rt', 'rs', 'imm']},
    'addiu': {'type': 'I', 'opcode': 9, 'form': ['rt', 'rs', 'imm']},
    'slti': {'type': 'I', 'opcode': 10, 'form': ['rt', 'rs', 'imm']},
    'sltiu': {'type': 'I', 'opcode': 11, 'form': ['rt', 'rs', 'imm']},
    'andi': {'type': 'I', 'opcode': 12, 'form': ['rt', 'rs', 'imm']},
    'ori': {'type': 'I', 'opcode': 13, 'form': ['rt', 'rs', 'imm']},
    'xori': {'type': 'I', 'opcode': 14, 'form': ['rt', 'rs', 'imm']},
    'lui': {'type': 'I', 'opcode': 15, 'form': ['rt', 'imm']},
    'lb': {'type': 'I', 'opcode': 32, 'form': ['rt', 'imm', 'rs']},
    'lh': {'type': 'I', 'opcode': 33, 'form': ['rt', 'imm', 'rs']},
    'lw': {'type': 'I', 'opcode': 35, 'form': ['rt', 'imm', 'rs']},
    'sb': {'type': 'I', 'opcode': 40, 'form': ['rt', 'imm', 'rs']},
    'sh': {'type': 'I', 'opcode': 41, 'form': ['rt', 'imm', 'rs']},
    'sw': {'type': 'I', 'opcode': 43, 'form': ['rt', 'imm', 'rs']},

    'sll': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rt', 'shamt']},
    'srl': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rt', 'shamt']},
    'sra': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rt', 'shamt']},
    'sllv': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rt', 'rs']},
    'srlv': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rt', 'rs']},
    'srav': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rt', 'rs']},
    'jr': {'type': 'R', 'opcode': 0, 'form': ['rs']},
    'jalr': {'type': 'R', 'opcode': 0, 'form': ['rs']},
    'mfhi': {'type': 'R', 'opcode': 0, 'form': ['rd']},
    'mthi': {'type': 'R', 'opcode': 0, 'form': ['rs']},
    'mflo': {'type': 'R', 'opcode': 0, 'form': ['rd']},
    'mtlo': {'type': 'R', 'opcode': 0, 'form': ['rs']},
    'mult': {'type': 'R', 'opcode': 0, 'form': ['rs', "rt"]},
    'multu': {'type': 'R', 'opcode': 0, 'form': ['rs', "rt"]},
    'div': {'type': 'R', 'opcode': 0, 'form': ['rs', "rt"]},
    'divu': {'type': 'R', 'opcode': 0, 'form': ['rs', "rt"]},
    'add': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'addu': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'sub': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'subu': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'and': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'or': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'xor': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'nor': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'slt': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
    'sltu': {'type': 'R', 'opcode': 0, 'form': ['rd', 'rs', 'rt']},
}

pseudoIS = {
    'nop': {'type': 'P', 'instruction': 'addi $0, $0, 0'},
    'li': {'type': 'P', 'instruction': ''},
    'mv': {'type': 'P', 'instruction': ''},
    'not': {'type': 'P', 'instruction': ''},
    'neg': {'type': 'P', 'instruction': ''},
}
register_count = {'$0': 0, '$at': 0, '$v0': 0, '$v1': 0, '$t0': 0, '$t1': 0, '$t2': 0, '$t3': 0, '$t4': 0, '$t5': 0,
                  '$t6': 0, '$t7': 0, '$s0': 0, '$s1': 0, '$s2': 0, '$s3': 0, '$s4': 0, '$s5': 0, '$s6': 0, '$s7': 0,
                  '$t8': 0, '$t9': 0, '$k0': 0, '$k1': 0, '$gp': 0, '$sp': 0, '$fp': 0, '$ra': 0}


def decimal_to_binary(decimal, width):
    binary = bin(decimal & int("1" * width, 2))[2:]  # 将十进制数转为二进制字符串并截取指定位宽
    return binary.zfill(width)  # 补零至指定位宽


def mybin(n: str) -> str:
    if judge(n):
        n = int(eval(n))
        binary = bin(n & int("1" * 16, 2))[2:]
        return binary.zfill(16)


def judge(a: str) -> bool:
    if (a.startswith("0x") or a.startswith("0o") or a.startswith("0b") or a.isdigit()) or (
            a.startswith('-') and a[1:].isdigit()):
        return True
    return False


def RType_transfer(src: str) -> str:
    src_list = src.replace(',', ' ').replace(')', ' ').replace('(', ' ').split()
    local_opcode = "000000"
    a = command_dict[src_list[0]]["form"]
    if len(a) + 1 != len(src_list):
        return "length is not matched"
    if len(a) > 2 and a[2] == "shamt":
        if not judge(src_list[3]):
            return "shamt need an immediate number"
        elif int(eval(src_list[3])) < 0 or int(eval(src_list[3])) > 31:
            return "shamt overflow"
    local_rs = "00000"
    local_rt = "00000"
    local_rd = "00000"
    local_shamt = "00000"
    if 'rs' in a:
        if src_list[a.index('rs') + 1] not in register.keys():
            return f"No register named this"
        local_rs = register[src_list[a.index('rs') + 1]]
    if 'rt' in a:
        if src_list[a.index('rt') + 1] not in register.keys():
            return f"No register named this"
        local_rt = register[src_list[a.index('rt') + 1]]
    if 'rd' in a:
        if src_list[a.index('rd') + 1] not in register.keys():
            return f"No register named this"
        local_rd = register[src_list[a.index('rd') + 1]]
    if 'shamt' in a:
        local_shamt = mybin(src_list[a.index('shamt') + 1])[-5:]
    local_func = RTypeInstruct[src_list[0]]
    # print(local_opcode)
    # print(local_rs)
    # print(local_rt)
    # print(local_rd)
    # print(local_shamt)
    # print(local_func)
    ans = local_opcode + local_rs + local_rt + local_rd + local_shamt + local_func
    return ans


def IType_transfer(src: str) -> str:
    # I类型指令（立即数类型的缩写）
    # 分为4个字段 op rs rt  imm
    #           6  5  5   16
    src_list = src.replace(',', ' ').replace(')', ' ').replace('(', ' ').split()
    a = command_dict[src_list[0]]["form"]
    local_opcode = opcode[src_list[0]]
    local_rs = "00000"
    local_rt = "00000"
    if len(a) + 1 != len(src_list):
        return "length is not matched"
    if 'rt' in a:
        if src_list[a.index('rt') + 1] not in register.keys():
            return f"No register named this"
        local_rt = register[src_list[a.index('rt') + 1]]
    if 'rs' in a:
        if src_list[a.index('rs') + 1] not in register.keys():
            return f"No register named this"
        local_rs = register[src_list[a.index('rs') + 1]]
    if not judge(src_list[a.index('imm') + 1]):
        return "immediate number need 'int'"
    elif int(eval(src_list[a.index('imm') + 1])) < -2 ** 20 or int(
            eval(src_list[a.index('imm') + 1])) > 2 ** 20 - 1:
        return "immediate number overflow"
    local_imm = mybin(src_list[a.index('imm') + 1]).rjust(16, '0')
    ans = local_opcode + local_rs + local_rt + local_imm
    # print(local_opcode)
    # print(local_rs)
    # print(local_rt)
    # print(local_imm)
    return ans


def decimal_to_26bit_binary_complement(decimal):
    if decimal >= 0:
        binary = bin(decimal)[2:].zfill(26)  # 转换为26位二进制，并补足位数
    else:
        binary = bin(2 ** 26 + decimal)[2:]  # 转换为正数的补码形式

    return binary


def JType_transfer(src: str) -> str:
    src_list = src.split()
    x = int(eval(src_list[1]))
    if x < -2 ** 25 or x > 2 ** 25 - 1:
        return "The address is too large to address"
    ans = opcode[src_list[0]] + decimal_to_26bit_binary_complement(x)

    return ans


tmp = dict()


def read():
    # 读取文件，删空行，删空格，记跳转
    ans = []
    with open(file_path, 'r', encoding="UTF-8") as f:
        res = f.readlines()
        for i in res:
            i.strip()
            if i.isspace():
                continue
            if i.find(":") != -1:
                a = i.split(':')[0]
                tmp[a] = [[], []]
                # continue
            if i[0] == '#':
                continue
            i = i.split("#")[0].strip()
            if i.isspace() or not i:
                continue
            ans.append(i)
    for i in range(len(ans)):
        if ans[i].startswith('j ') or ans[i].startswith("jal "):
            if not ans[i].split()[-1][0].isalpha():
                ans[i] = 'error'
    res = []
    for i in range(len(ans)):
        tmp_str = ans[i].strip()
        if ':' in tmp_str:
            tmp_list = tmp_str.split(":")
            if len(tmp_list) > 1:
                res.append(tmp_list[0] + ":")
                if tmp_list[1]:
                    res.append(tmp_list[1])
            else:
                res.append(tmp_list[0])
        else:
            res.append(ans[i])
    return res


def process(src_list: list) -> None:
    # 加工函数，找到挑战指令的跳转位置
    ans = []
    flag = True
    for i in src_list:
        if i.split()[-1] in tmp.keys():
            a = src_list.index(i)
            tmp[i.split()[-1]][0].append(a)
            flag = False
            ans.append(i)
        elif i.split(":")[0] in tmp.keys():
            b = src_list.index(i)
            flag = True
            tmp[i.split(":")[0]][1].append(b)
            # local_cnt+=1
        elif flag:
            ans.append(i)


def f(src_list: list) -> list:
    # 处理跳转标签和伪指令
    # nop（空操作，等效于addi $0, $0, 0）
    # li $x, abcd（将一个32位立即数abcd加载到目标寄存器x，请使用lui等指令序列实现，请注意立即数是补码形式）
    # mv $a, $b（将寄存器b内容复制到寄存器a中，等效于addi $a, $b, 0）
    # not $a, $b（将寄存器b内容取反后复制到寄存器a中，等效于xori $a, $b, -1）
    # neg $a, $b（将寄存器b内容取负后复制到寄存器a中，等效于sub $a, $0, $b）
    ans = []
    i = 0
    length = len(src_list)
    while i < length:
        if src_list[i].split()[-1] in tmp.keys() and (i in tmp[src_list[i].split()[-1]][0]):
            ans.append(src_list[i])
            tmp[src_list[i].split()[-1]][0].remove(i)
        elif src_list[i].split(":")[0] in tmp.keys():
            i += 1
            continue
        elif src_list[i] == 'nop':
            ans.append("addi $0, $0, 0")
        elif src_list[i].replace(',', ' ').split()[0] == 'li':
            local_imm = mybin(src_list[i].replace(',', ' ').split()[-1]).rjust(32, '0')
            ans.append("lui " + src_list[i].replace(',', ' ').split()[1] + ",0b" + local_imm[0:16])
            ans.append("ori " + src_list[i].replace(',', ' ').split()[1] + ',' + src_list[i].replace(',', ' ').split()[
                1] + ",0b" + local_imm[16:])
            # lui $x, abcd[31:16]  # 将立即数的高16位加载到目标寄存器$x的高位
            # ori $x, $x, abcd[15:0]  # 将立即数的低16位加载到目标寄存器$x的低位
        elif src_list[i].split()[0] == 'mv':
            command_str = src_list[i].replace('mv', "addi") + ',0'
            ans.append(command_str)
        elif src_list[i].split()[0] == 'not':
            command_str = src_list[i].replace('not', "xori") + ',-1'
            ans.append(command_str)
        elif src_list[i].split()[0] == 'neg':
            tmp_list = src_list[i].replace('neg', "sub").replace(',', ' ').split()
            tmp_src = tmp_list[0] + " " + tmp_list[1] + ',$0,' + tmp_list[2]
            ans.append(tmp_src)
        else:
            if not src_list[i].split()[-1] in tmp.keys():
                ans.append(src_list[i])
        i += 1
    return ans


def translate(unfolded_list: list) -> list:
    # 将跳转符号转换成数字

    ans = []
    J = ["j", "jal", "jr"]
    for i in range(0, len(unfolded_list)):
        if unfolded_list[i].split()[-1] in j_command_dict.keys():
            if unfolded_list[i].split()[0].strip() in J:
                x = j_command_dict[unfolded_list[i].split()[-1]][1][0]
                for v in j_command_dict.values():
                    for num in v[-1]:
                        if num < x:
                            x -= 1
                code_str = str(x)
                ans.append(unfolded_list[i].split()[0] + " " + code_str)
                continue
            else:
                code_str = str(
                    j_command_dict[unfolded_list[i].split()[-1]][1][0] -
                    j_command_dict[unfolded_list[i].split()[-1]][0][
                        0] - 1 if j_command_dict[unfolded_list[i].split()[-1]][1][0] -
                                  j_command_dict[unfolded_list[i].split()[-1]][0][0] - 1 > 0 else
                    j_command_dict[unfolded_list[i].split()[-1]][1][0] -
                    j_command_dict[unfolded_list[i].split()[-1]][0][
                        0])

            # print("Here")
            # print(j_command_dict[unfolded_list[i].split()[-1]][1][0])
            # print(j_command_dict[unfolded_list[i].split()[-1]][0][0])
            # print(code_str)
            cnt = 0
            # print(signal)
            for location in signal:
                # print("Now")
                # print(location)
                a = min([j_command_dict[unfolded_list[i].split()[-1]][1][0],
                         j_command_dict[unfolded_list[i].split()[-1]][0][0]])
                b = max([j_command_dict[unfolded_list[i].split()[-1]][1][0],
                         j_command_dict[unfolded_list[i].split()[-1]][0][0]])
                # print(a)
                # print(b)
                # print(a < location < b)
                if a < location < b:
                    cnt += 1
            # print(cnt)
            code = int(code_str)
            code = code - cnt if code > 0 else code + cnt
            # print("vrwv")
            # print(cnt)
            code_str = str(code)
            # print(code_str)
            # print(signal)
            new_command = unfolded_list[i].replace(unfolded_list[i].split()[-1], code_str)
            j_command_dict[unfolded_list[i].split()[-1]][0].pop(0)
            ans.append(new_command)
        else:
            ans.append(unfolded_list[i])
    return ans


# ans1 = read()
# process(ans1[:])
# j_command_dict = copy.deepcopy(tmp)
# p = unfold(ans1)
# a = translate(p)
# print(a)


def bin_to_hex(src: str) -> str:
    return str(hex(int(eval("0b" + src))))[2:].rjust(8, '0')


cnt = 0


def getBinaryCodeList(src_list) -> list:
    ans = []
    global cnt
    for i in src_list:
        if i == 'error':
            ans.append("The label must be a valid identifier")
            continue
        command_name = i.replace(',', ' ').split()[0]
        if command_name in command_dict.keys():
            command_opt = command_dict[command_name]['type']
        else:
            ans.append("Key Error!")
            continue
        # print(i)
        if command_opt == 'R':
            tmp = RType_transfer(i)
            print(tmp)
            print(i)
            if tmp.startswith('0') or tmp.startswith('1'):
                print(bin_to_hex(tmp))
                ans.append(bin_to_hex(tmp))
                cnt += 1
            else:
                ans.append(tmp)
        elif command_opt == 'I':
            tmp = IType_transfer(i)
            if tmp.startswith('0') or tmp.startswith('1'):
                print(bin_to_hex(tmp))
                ans.append(bin_to_hex(tmp))
                cnt += 1
            else:
                ans.append(tmp)
        elif command_opt == 'J':
            tmp = JType_transfer(i)
            if tmp.startswith('0') or tmp.startswith('1'):
                print(bin_to_hex(tmp))
                ans.append(bin_to_hex(tmp))
                cnt += 1
            else:
                ans.append(tmp)
    return ans


def work(src_list):
    head_str = f"""; This .COE file specifies the contents for a block memory of depth={cnt}, and width=32.
    memory_initialization_radix={cnt};
    memory_initialization_vector=\n"""
    with open(output_location, mode='w') as fp:
        fp.write(head_str)
        for i in src_list:
            fp.write(i)
            fp.write(',\n')


if __name__ == '__main__':
    ans1 = read()
    print(ans1)
    process(ans1[:])
    j_command_dict = copy.deepcopy(tmp)
    print(j_command_dict)
    for i in list(j_command_dict.values()):
        signal += i[1]
    p = f(ans1)
    print(p)
    src_list = translate(p)
    print(src_list)
    bin_code_list = getBinaryCodeList(src_list)
    work(bin_code_list)

更新于2024/01/21

染汐_
关注
mips汇编器的设计与实现。_处理器设计第二步：学习组成原理
weixin_39638086的博客
12-15 190
前提：这是一个系列文章，你是否通过了前面的关卡？风雨携晴：处理器设计第一步：学习数字电路​zhuanlan.zhihu.com即使你自信已经掌握了以上内容，我还是建议你看看前面的文章，因为这个系列思想是贯通的，只看一篇彷佛只看电影的一部分，精彩也会不过瘾。闲话休说，进入正题。什么是组成原理？为什么要学习组成原理？前面提到：“我们现在所使用的计算机系统是基于数字电路的，组成处理器的各个部件都是或复杂...
毕业设计-汇编器设计与实现
03-29
毕业设计-汇编器设计与实现 毕业设计-汇编器设计与实现 毕业设计-汇编器设计与实现 毕业设计-汇编器设计与实现
汇编器构造
shenghua
05-07 999
汇编器构造   一、             汇编器简介 前面介绍了编译器构造和静态链接器构造的具体方法，而且我们实现了一个将高级语言转化为汇编语言的编译器，同时又实现了一个将多个目标文件链接为一个可执行文件的链接器。现在需要一个连接这两个模块的功能模块——汇编器，它能将一个单独的汇编文件转换为一个可重定位目标文件，如图1-1反映出汇编器在整个编译系统中的地位和功能。   图 1-1
数字逻辑设计实验-MIPS汇编器设计(Python)
weixin_60738001的博客
11-28 785
数字逻辑设计实验-MIPS汇编器设计(Python)
数字逻辑大作业：MIPS汇编器设计
Lane的小屋
01-30 569
数字逻辑与计算机体系结构大作业MIPS汇编器设计的详细解决方案
MIPS指令集：汇编源程序（.S文件）编写
海棠花的博客
03-29 6962
我们学会了MIPS汇编语言后，编写汇编程序还需要一个“框架”,用“框架”的目的是让我们更加容易的编写汇编程序，把更复杂的任务，比如符号解析、地址重定向、对齐等工作交给工具链去完成。这个框架有2种方式，汇编源代码文件(以.S为后缀)和内嵌汇编（在.c文件中嵌入汇编语言的方式）。本篇介绍.S为后缀的汇编源程序的编写格式。 我们可能经常遇到以.S后缀结尾和.s后缀结尾的...
杭电计组实验6-MIPS汇编器与模拟器实验.pdf
07-11
《MIPS汇编器与模拟器实验详解》 在计算机科学领域，理解底层硬件与软件交互至关重要，MIPS（Microprocessor without Interlocked Pipeline Stages，无互锁流水级微处理器）架构是教学中广泛使用的处理器模型，其...
杭电计算机组成原理MIPS汇编器模拟器实验6.pdf
07-06
《杭电计算机组成原理MIPS汇编器模拟器实验6》是杭州电子科技大学计算机学院针对计算机组成原理课程设计的一项实验，旨在让学生深入理解和掌握MIPS架构的指令系统、汇编程序设计以及使用模拟器进行程序执行的方法。...
杭电计算机组成原理MIPS汇编器模拟器实验6 (2).pdf
07-06
《杭电计算机组成原理MIPS汇编器模拟器实验6》是杭州电子科技大学计算机学院针对计算机组成原理课程设计的一项实验，旨在让学生深入理解和掌握MIPS（Microprocessor without Interlocked Pipeline Stages，无锁管道...
MIPS-Assembler-c.zip_MIPS 进制转换_MIPS 汇编器_YEMK_assembler.c_mips汇编
07-15
MIPS汇编器,C语言，可以将指令转换为二进制代码
c++实现的mips汇编器
05-06
本项目是用C++语言实现的MIPS汇编器，能够将MIPS汇编代码转化为机器码，同时还可能包含反汇编功能，将机器码还原为汇编代码。以下是基于标题和描述中提到的知识点的详细解析： 1. MIPS汇编语言： MIPS汇编语言是一...
c++编写的简单的汇编器
03-18
汇编指令-->机器码101010…… 在cmd中命令格式：ns 输入文件例： add $1,$2,$3 X1: sub $3,4,$3 cmp $3,$1 blet X1 sysint 1 寄存器格式为：$x 立即数支持十进制 支持行标号 可以检测错误的指令字和行标号
一个简洁小巧的汇编器 hasm
01-03
学习intel指令集时实现的一个实验性质的汇编器，参考了nasm的一些内容，结构非常之简单，适合用于单片机汇编器的二次开发
最简单的汇编器与反汇编器的设计文档
红孩儿编程大师
11-11 320
在程序员视角的计算机系统这本书的第四章中，有一个Y86的指令集架构。 这个架构有满足功能的最小的指令集。指令与机器码的对应关系见下图 这个设计的图中，有一个隐藏给出的信息，还缺少一个重要的设计信息，它们都是什么呢？欢迎留言回复。 根据如上的设计文档，开发的汇编器，可以实现如下的功能： irmovl $15,%ebx/p> rrmovl %ebx,%ecx rmmovl %ecx,-3(%ebx) addl %ebx,%ecx jmp loop 上述的汇编指令，经过汇编器的汇编生成
010.汇编语言基于x86处理器教材习题4.2.8：①-⑤程序
dosdiosas_的博客
05-17 681
.386 .model flat,stdcall .stack 4096 ExitProcess proto,dwExitCode:dword .data val1 byte 10h val2 word 8000h val3 dword 8000h val4 word 7FFFh .code main PROC ;① inc val2 ;② sub eax,val3 ;③ mov bx,val2 sub bx,val4 mov val2,bx ;④
RISC-V （二）汇编语言编程
最新发布
weixin_44194690的博客
07-28 1548
汇编语言是一种“低级”语言。汇编语言的缺点：-难度-难写-难移植汇编语言的优点：-灵活-强大汇编语言的应用场景-需要直接访问底层硬件的地方-需要对性能执行极致优化的地方汇编文件一般后缀为.S或.s，.S包含了预处理的语句，.s就是纯粹的汇编语句。一个完整的RISC-V汇编程序有多条语句（statement）组成。打方括号表示可选。-label表示一个标号，必须以":"结尾。label相当于一个地址，给这个地址起了个名字。是这条指令存放在内存的地址。
汇编程序编译连接过程
qq_44418229的博客
04-26 4153
这章开始，我们将编写完整的汇编语言程序，用编译和连接程序将它们连接成可执行文件（如.exe文件）在DOS中运行。
实验一：MIPS指令系统和MIPS体系结构
sylviiiiiia的博客
12-06 3679
MIPS架构（英语：MIPS architecture，为Microprocessor without interlocked piped stages architecture的缩写，亦为Millions of Instructions Per Second的双关语），是一种采取精简指令集（RISC）的处理器架构，1981年出现，由MIPS科技公司开发并授权，广泛被使用在许多电子产品、网络设备、个人娱乐装置与商业装置上。最早的MIPS架构是32位，最新的版本已经变成64位。
自己动手写一个编译器
热门推荐
weixin_55229531的博客
07-25 2万+
Pcode 是 TinyC 编译器的中间代码，是本人参考 pascal 编译器的中间代码 pcode 、并结合逆波兰表达式（后缀表达式）的逻辑后，设计出的一种非常简单的、基于栈和符号表的虚拟代码。Pcode 虚拟机是一个用来运行 Pcode 命令的、假想的机器，它包括：一个代码区（code）、一个指令指针（eip）、一个栈（stack）、一个变量表（var_table)、一个函数表（func_table）以及一个标签表（label_table）。
MIPS汇编语言程序设计与图灵机解析
"该资源是关于微机原理和...总结来说，这个资源深入浅出地介绍了MIPS汇编语言的基本操作，程序设计思路，以及与之相关的编译器和解释器的概念，对于理解和编写MIPS汇编程序以及理解计算机系统的底层运作机制大有裨益。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值