计算机组成原理实验报告（硬设）-2016

《计算机组成原理》

课程设计报告

年级专业班级： 完成日期：

小组成员、组内分工及各成员成绩 学号 姓名 分工 工作量比例 成绩

1. 引言

1.1 实验目的

1. 在掌握传统的、顺序执行的CPU工作原理基础上，理解掌握流水CPU的工作原理；

2. 掌握流水线的设计思路和方法，尤其是对结构相关、数据相关和控制相关的解决思路；

3. 理解硬件设计流程，熟悉掌握指令系统的设计方法，并设计简单的指令系统； 4. 理解和掌握基于VHDL语言和TEC-CA硬件平台设计模型机的方法，并藉此掌握工程设计的思路和方法。

1.2 实验要求 1. 基本设计要求

参考《16位5级流水无cache实验CPU课程设计实验要求》文档及其VHDL代码，在理解其思想和方法的基础上，将其改造成8位的5级流水无cache的实验CPU，包括对指令系统、数据通路、各流水段模块、内存模块等方面的改造。利用VHDL语言编程实现，并在TEC-CA平台上进行仿真测试。为方便起见，后续16位5级流水无cache实验CPU简记为ExpCPU-16，而8位的则记为ExpCPU-8。

对于内存模块的改造，参考《计算机组成原理》课程综合实验的方法，独立设计一块8位的RAM。

要求测试减法的溢出标志位，如测试127-(-96)或者-127-96的溢出标志位。 2. 额外设计要求

时间允许的情况下，进行一些额外的、探索性的改造，可用于加分。例如， （1） 利用TEC-CA平台上的16位RAM来存放8位的指令和数据；

（2） 实现一条JRS指令，以便在符号标志位S=1时跳转。需要改写ID段的控

制信息，并改写IF段； （3） 实现一条CMPJ DR,SR,offset指令，当比较的两个数相等时，跳转到目标

地址PC+1+offset；

（4） 可以探索从外部输入指令，而不是初始化时将指令“写死”在RAM中； （5） 此5段流水模块之间，并没有明显地加上流水寄存器，可以考虑在不同模

块间加上流水寄存器；

（6） 探索5段流水带cache的CPU的设计。

各组亦可根据实际情况来做一些创新性的探索，酌情加分。

1.3 实验设备

本课程综合设计中，需要用到的实验设备如下： 1. PC两台；

2. TEC-CA硬件实验箱一个； 3. Quartus II软件平台一个； 4. DebugController软件一个； 5. JTAG连接线。

1

1.4 主要成果

实现5级流水无cache的8位实验CPU,16条简单的命令执行，输出确认无误。

2. 8位无Cache的5段流水CPU总体设计

2.1 指令系统的设计（注：要给出指令功能、指令格式、指令列表） constant ADD : std_logic_vector(3 downto 0):=\加法 constant SUBB : std_logic_vector(3 downto 0):=\减法 constant ANDins : std_logic_vector(3 downto 0):=\与 constant MOV : std_logic_vector(3 downto 0):=\赋值

constant LOAD : std_logic_vector(3 downto 0):=\指令

constant STORE : std_logic_vector(3 downto 0):=\指令

constant LOADH : std_logic_vector(3 downto 0):=\//高位load指令

constant LOADL : std_logic_vector(3 downto 0):=\//低位load指令

constant JR : std_logic_vector(3 downto 0):=\跳转 constant JRZ : std_logic_vector(3 downto 0):=\跳转 constant NOP : std_logic_vector(3 downto 0):=\//空操作 constant MOVI : std_logic_vector(3 downto 0):=\ constant NOPIns : std_logic_vector(7 downto 0):=\

2.2 数据通路的设计（注：可参考16位CPU，然后指出变为8位时，作了哪些修改）

一、数据通路图

2

五级流水CPU结构图IRFlushHazadrDetectUnitPCFlushtFlag Flag OperatorPCnextMUX1＋IF_IDRegID_EXRege_ALUSrc, e_ALUOpr, e_SetFlagEX_MEMRegm_wrMemMEM_WBRegw_wrMem＋offsetIMMNOPPCOuterDB1MUX0指令寄存器IRRegArrayAoutSASBBoutw_wRegEnw_SBWrite dataRegSelRegOutREGISTERSMUXALUaIntFlagALUMUXALUbInflagALUOutREGISTERSm_ALUOutOuterDBREGISTERSw_MemToRegw_ALUOutw_MemOut0MUX1m_RBdataforwardAm_wRegEnm_SAw_wRegEnforwardBForwarding Unite_SAe_SBw_SAPCm_ALUOutw_wrMem“zzzz”MemOuterDBRead dataWrite datawrMem_addr MUX wrMAUnit1 MUX 0图1 无cache五级流水线数据通路示意图

整个CPU由下边几个模块组成：

控制器：在每个时钟周期给出cpu其它部件的控制信号。 运算器：本运算器包括寄存器堆。 Bus MUX：通过控制信号BusSel数据的来源，通过Wr来控制送往外部数据总线上的数据内容。

AR（地址寄存器）：驱动地址总线。

IR（指令寄存器）：存放根据当前PC值取得的指令。

2.3 控制信号的设计（注：要分析控制信号有哪些，最后总结一个控制信号

列表，可参考上个学期综合实验参考文档中控制信号的列表方法）

3

wrMem 信号 w_memToReg wRegEn 含义 ‘1’: 内存数据到寄存器 ‘0’: ALU输出到寄存器 ‘1’: 允许写寄存器 ‘0’: 禁止写寄存器

wRegEn & MemToReg 信号 w_memToReg wRegEn 含义 ‘0’: 内存数据到寄存器 ‘1’: ALU输出到寄存器 ‘1’: 允许写寄存器 ‘0’: 禁止写寄存器

ALUSrc ALUSrc 000 001 010 011 100 101

ALUOpr ALUOpr 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

4

R A A A 0 A A S 0 B 1 B FFFF 立即数 功能 R + S S – R R AND S R OR S R XOR S SHL S SHR S SAR S LOADH R LOADL R MOVI R

setFlag（3位：###） 信号 000 001 010 011 100 101 其它 含义 Flag_hold Flag_update Flag_innerDB Flag_C0 Flag_C1 Flag_clear 未定义

2.4 结构相关的处理

由于我们的设计中不包含缓存，因此会有取指和访存的冲突，即结构相关（见下图）。

执行访存取指译码取指译码

当冲突发生时，必须先“访存”，将“取指”延后一个时钟周期，这样才能保证指令的正确执行。处理结构相关需要做两项工作：1）冲突检测 2）取指延后。 1) 冲突检测

只有执行访存指令(LOAD/STORE)时，才会出现冲突。因此，我们在译码时产生一个标志是否访存的信号wrMem。含义如下： wMem 意义 00 写内存（STORE） 01 读内存（LOAD） 1× 不占用内存

通过检查“访存阶段”的m_wrMem就可确定是否冲突。 2）取指延后

在每次取指时，若有冲突，则往IR中写入空指令(NOP)，并保持PC不变，使取指延后一个节拍。

2.5 数据相关的处理

数据相关是指在执行本条指令的过程中，如果用到的操作数是前面指令的执行结果，则必须等待前面的指令执行完成，并把结果写回寄存器或主存之后，本条指令才能继续执行[3]。我们采用设置专用数据通路（即傍路技术）来解决数据相关问题。但旁路技术并非一劳永逸。

5

若前一指令为LOAD，而后一指令和它数据相关，如下图所示，当下一指令的执行阶段需要数据时，上一指令尚未给出，这种情况是无法用旁路技术来解决的。

ALUIMRegMemRegIMRegALUMemReg

图 五级流水LOAD数据相关示意图

针对上述情况的一般处理方法是通过插入bubble使LOAD之后的两条指令拖后一个节拍执行[4]。但我们感觉这种处理过于繁琐。我们发现，如果在LOAD译码时，后面自动加一条空指令，即增加冗余，就可以避免上述情况的出现。在这种简化处理后，我们将数据相关划分为以下三种情况。 1． 相邻指令数据相关 举例: INC R0

INC R0

在此情形下，将上一指令的ALU输出经缓存后直接送回，作为ALU多路选择器的入口

之一，如下图所示。

ALUIMRegMemRegIMRegALUMemReg 图 五级流水相邻指令数据相关示意图

具体代码片段为(forwardingentity.vhd)： if m_wRegEn='1' and m_SA=e_SA then forwardA <= \ 其中m_SA为当前处于访问内存(MEM)中寄存器输出结果的索引，e_SA为处于当前执行阶段中ALU的输入寄存器A的索引，倘若两个索引值相等，则产生相邻指令数据相关

6

2． 中间隔1条指令的两指令数据相关 举例: INC R0 INC R1 INC R0

在此情形下，将第1条指令的回写数据送回作为ALU多路选择器的入口之一供第3条指令使用，如下图所示。

IMRegALUMemRegIMRegALUMemRegIMRegALUMemReg

图 五级流水相隔1条指令的两指令数据相关示意图

具体代码片段如下(forwardingentity.vhd)： elsif w_wRegEn='1' and w_SA=e_SA then forwardA <= \ 其中w_SA为当前处于回写阶段(WB)中寄存器输出结果的索引，e_SA为处于当前执行阶段中ALU的输入寄存器A的索引，倘若两个索引值相等，则产生中间隔1条指令的两指令数据相关

3． 中间隔2条指令的两指令数据相关 举例: INC R0

INC R1 INC R2 INC R0

第1和第4条指令数据相关，有两种处理方法。

方法1：在第4条指令的译码阶段作旁路处理,将第1条指令的回写数据作为

运算器的输入送入下一级，如下图所示。

方法2：考虑到读写寄存器的时间较短，因此将写寄存器的时机改在时钟下

降沿。这样1、4指令就没有数据相关了。

7

IMRegALUMemRegIMRegALUMemRegIMRegALUMemRegIMRegALUMemReg 图 五级流水相隔2条指令的两指令数据相关示意图

由于方法2处理较简洁，因此我们在实现时使用了后者。

具体部分代码如下(ifentity.vhd)：

process(reset,clk,PCStall) begin if reset = '0' then PC <= x\ elsif FALLING_EDGE(clk) and (PCStall='0') then PC <= PCnext; end if; end process; 可以看到更新PC的时机为FALLING_EDGE。

2.6 控制相关的处理

控制相关是指因为程序的执行方向可能改变而引起的相关。当执行跳转指令时，就会发生这种情况。除JR外，JRZ等条件跳转需要根据当前状态位来决定是否跳转，而当前状态位是由前面最近的会影响状态位的指令（如算术指令）决定。常规的也是比较简单的做法是在碰到JRX之类的跳转指令时，延迟后边流水线的进入。但我们通过分析，认为可以一点都不必延迟，通过旁路处理把控制相关转为数据相关来处理。这样处理，不必延迟，可以提高流水线的性能。按我们的方式解决控制相关需要做两项工作： 1）通过旁路，提供状态寄存器的值和临时状态位的值，为判断是否跳转作准备； 2）选择PC更新的时机

3. 结构级设计

8

指关键模块的功能、输入输出信号的框图示意，并说明主要信号的功能及取值。可以分为如下几个关键模块：IF段、ID段、EX段、Mem段、WB段、冲突检测模块、定向处理模块等。可以参考之前给出的《实践报告》文档的写法，但要注意修改其中信号的位数。

1. 总体逻辑结构计

五级流水CPU结构图IRFlushHazadrDetectUnitPCFlushtFlag Flag OperatorPCnextMUX1＋IF_IDRegID_EXRege_ALUSrc, e_ALUOpr, e_SetFlagEX_MEMRegm_wrMemMEM_WBRegw_wrMem＋offsetIMMNOPPCOuterDB1MUX0指令寄存器IRSARegArrayAoutBoutSBw_wRegEnw_SBWrite dataRegSelRegOutREGISTERSMUXALUaIntFlagAflagLALUOutUMUXALUbInREGISTERSm_ALUOutOuterDBREGISTERSw_MemToRegw_ALUOutw_MemOut0MUX1m_RBdataforwardAm_wRegEnm_SAw_wRegEnforwardBForwarding Unite_SAe_SBw_SAPCm_ALUOutw_wrMem“zzzz”MemOuterDBRead data MUX wrMAUnit1 MUX 0Write datawrMem_addr

图 五级流水整体结构图

整个CPU由以下几个模块组成：

(1)取指模块（IF）：给出内存地址，读取指令并送入指令寄存器，为下一级准备数据。

由于PC控制模块处于取指模块中，因此控制相关的检测也置于取指模块。 (2)译码模块（ID）：读取寄存器值和指令译码。我们采取一次译码，逐级传递的方式，译出后几级流水所需的控制信号和数据（如立即数等），在每次时钟上升沿到来时送入下一级。实际上，结构相关、控制相关、数据相关的检测都可归入译码部分。考虑到“相关检测”涉及到的信号分属不同阶段以

9

及整体结构的清晰性，我们将“相关检测”独立出来。

(3)执行模块（Ex）：完成算术逻辑运算、计算有效地址和提供数据通道。 (4)访存模块（Ma）：选择地址线的数据来源和数据线的流向。访存和取指在功能上是独立的，但CPU对外只有一条地址线和数据线的事实决定了访存和取指是相互联系的。当执行LOAD/STORE指令时，地址线由ALU送入“访存段”的值提供；取指时，则由PC提供。当写内存时，CPU内部数据送数据线；当需要读内存时，CPU往数据线送高阻。

(5)回写模块（Wb）：选择回写数据源和根据写使能信号wRegEn将数据回写到寄存器堆；

(6)HazardDetectEntity模块：检测结构相关； (7)ForwardingEntity模块：检测数据相关。

2. 关键分模块结构设计

(1)执行模块(Ex)

执行模块的主要工作是完成算术逻辑运算、计算有效地址和提供数据通道。执行模块的主体部分是运算器，其总体结构和两级流水是相似的。主要不同之处在于增加了旁路模块，这是由于五级流水存在数据相关需要旁路处理。

五级流水CPU运算器结构图傍路模块e_RAoutforwardAMUXMUXw_RBdatam_ALUOute_RBoutforwardBALUaIn 010xFFFFIMMALUbInALUSrcMUXExtTo17bitsExtTo17bitsOperation MuxALUOpr－与门或门异或SHLSHRSARCXSetFlag(2)HazardDetectEntity模块

该模块通过检查“访存阶段”的m_wrMem来确定是否发生结构相关。具体请参阅上文中处理结构相关的部分。

10

＋CXC,Z,V,StFlagFLAGClkALUOut 图 五级执行模块结构图

结构图：

d_IRm_wrMemw_wrMemHazardDetectUnitPCStallIFFlush

图 五级HazardDetectEntity模块结构图 信号说明 端口 输入 输出 表 HazardDetectEntity信号说明

(3)回写模块（WB）

回写是一条指令执行过程中的最后一步。它的工作是选择回写数据源和根据写使能信号wRegEn将数据回写到寄存器堆。需要选择的数据源共有两项：运算器输出和内存输出。在执行算术逻辑、移位等指令时选择运算器输出；执行LOAD指令时选择内存输出。 结构图：

w_ALUOutw_memToRegw_MemOut信号 m_wrMem d_IR PCStall 含义 wrMem处于访存阶段的值 指令寄存器 ‘1’ : 保持PC不变 ‘0’: PC更新 信号 w_wrMem IFFlush 含义 wrMem处于回写阶段的值 ‘1’: NOP写入IR ‘0’: 内存输出写入IR 0 MUX 1w_WBdata写使能目的寄存器号Write datawRegEndestRegCLKRegArray 图 五级回写模块结构图 信号说明： 信号 含义 w_memToR‘1’: 内存数据到寄存器 eg ‘0’: ALU输出到寄存器 wRegEn ‘1’: 允许写寄存器 ‘0’: 禁止写寄存器 表 五级回写模块信号说明

2.2.4 ForwaringEntity模块

在“时序设计”部分，我们已对“如何检测数据相关”作了详细叙述。具体

11

实现由

ForwardingEntity模块完成。 结构图

e_SAe_SBm_SAw_SAm_wRegEnw_wRegEnForwarding UnitforwardAforwardB

图 五级ForwardinEntity模块结构图 信号说明 端口 信号 含义 信号 含义 e_SA 寄存器A口选择信号e_SB 寄存器B口选择信号 处于执行阶段的值 处于执行阶段的值 输入 m_SA 寄存器A口选择信号w_SA 寄存器A口选择信号处于访存阶段的值 处于回写阶段的值 m_wRegE寄存器写使能处于w_wRegEn 寄存器写使能处于回n 访存阶段的值 写阶段的值 输出 forwradA 选择ALU的A口数据 forwradB 选择ALU的B口数据 表 五级FowardingEntity模块信号说明

4. VHDL 源代码

用黑色外的其它明显的颜色标注对16位参考代码所作的修改，这个作为评分时的一个主要参考因素。此外，需有适当的注释，说明关键代码的功能与作用，注释亦用黑色外的其它颜色进行标注。

-UnitPack.vhd- 常量定义文件 --2004-09-04 library ieee;

use ieee.std_logic_1164.all; PACKAGE unitPack IS

constant ZERO8 : STD_LOGIC_VECTOR(7 DOWNTO 0) := \ constant ZERO9 : STD_LOGIC_VECTOR(8 DOWNTO 0) := \ constant Z8 : STD_LOGIC_VECTOR(7 DOWNTO 0) := \ -- ALU: select data source

12

constant selA0 : std_logic_vector(2 downto 0) := \ constant selAB : std_logic_vector(2 downto 0) := \ constant selA1 : std_logic_vector(2 downto 0) := \ constant sel0B : std_logic_vector(2 downto 0) := \ constant selAF : std_logic_vector(2 downto 0) := \ constant selAD : std_logic_vector(2 downto 0) := \ -- ALU: Select operation

constant aluAdd : std_logic_vector(3 downto 0) := \ constant aluSub : std_logic_vector(3 downto 0) := \ constant aluAnd : std_logic_vector(3 downto 0) := \ constant aluOr : std_logic_vector(3 downto 0) := \ constant aluXor : std_logic_vector(3 downto 0) := \ constant aluShl : std_logic_vector(3 downto 0) := \ constant aluShr : std_logic_vector(3 downto 0) := \ constant aluSar : std_logic_vector(3 downto 0) := \ constant aluLOADH : std_logic_vector(3 downto 0) := \ constant aluLOADL : std_logic_vector(3 downto 0) := \ constant aluMOVI : std_logic_vector(3 downto 0) := \ -- 状态位的控制信号

constant flag_hold : std_logic_vector(2 downto 0) := \ constant flag_update : std_logic_vector(2 downto 0) := \ constant flag_InnerDB : std_logic_vector(2 downto 0) := \ constant flag_C0 : std_logic_vector(2 downto 0) := \ constant flag_C1 : std_logic_vector(2 downto 0) := \ constant flag_clear : std_logic_vector(2 downto 0) := \ -- 指令操作码

constant ADD : std_logic_vector(3 downto 0):=\ constant SUBB : std_logic_vector(3 downto 0):=\ constant ANDins : std_logic_vector(3 downto 0):=\ constant MOV : std_logic_vector(3 downto 0):=\ constant LOAD : std_logic_vector(3 downto 0):=\ constant STORE : std_logic_vector(3 downto 0):=\ constant LOADH : std_logic_vector(3 downto 0):=\ constant LOADL : std_logic_vector(3 downto 0):=\ constant JR : std_logic_vector(3 downto 0):=\ constant JRZ : std_logic_vector(3 downto 0):=\ constant NOP : std_logic_vector(3 downto 0):=\ constant MOVI : std_logic_vector(3 downto 0):=\

constant NOPIns : std_logic_vector(7 downto 0):=\ constant DoNothing :std_logic_vector(17 downto 0):=\ subtype INDEXTYPE is INTEGER range 0 to 3; subtype WORD is std_logic_vector(15 downto 0); subtype BYTE is std_logic_vector(7 downto 0);

13

type REGISTERARRAY is array ( 0 to 3 ) of BYTE; END unitPack;

--MemAccessEntity.vhd- 访存模块

library IEEE;

use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; use work.unitpack.all;

entity MemAccessEntity is

port( reset,clk : in std_logic; m_wrMem : in std_logic_vector(1 downto 0); w_wrMem : out std_logic_vector(1 downto 0); m_ALUOut : in byte; m_RBdata : in byte; wr : out std_logic; OuterDB : inout byte; w_ALUOut : out byte; w_MemOut : out byte; m_flag : in std_logic_vector(3 downto 0); w_flag : out std_logic_vector(3 downto 0); PC : in byte; addr : out byte; m_SA : in std_logic_vector(1 downto 0); w_SA : out std_logic_vector(1 downto 0); m_wRegEn : in std_logic; m_destReg : in std_logic_vector(1 downto 0); m_memToReg : in std_logic; w_wRegEn : out std_logic; w_destReg : out std_logic_vector(1 downto 0); w_memToReg : out std_logic ); end entity ;

architecture MemAccessArch of MemAccessEntity is begin

process(clk,m_wrMem,m_ALUOut,m_RBdata,PC) begin case m_wrMem is when \=> addr <= m_ALUout; wr <= '0'; -- write Memory

14

OuterDB <= m_RBdata; when \ => wr <= '1'; addr <= m_ALUout; OuterDB <= Z8; when others => wr <= '1'; addr <= PC; OuterDB <= Z8; end case; end process; process(reset,clk) begin

if reset='0' then w_wRegEn <= '0'; w_wrMem <= \ elsif RISING_EDGE(clk) then w_flag <= m_flag; w_ALUOut <= m_ALUOut; w_SA <= m_SA; w_wRegEn <= m_wRegEn; w_destReg<= m_destReg; w_memToReg<= m_memToReg; w_memOut <= OuterDB; w_wrMem <= m_wrMem; end if; end process; end architecture ;

--IFEntity.vhd- 取指模块 library IEEE;

use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; use work.unitpack.all;

entity IFEntity is port ( reset : in STD_LOGIC; clk : in STD_LOGIC; Z,C : in std_logic; tempZ,tempC : in std_logic; e_setFlag : in std_logic_vector(2 downto 0); PCPlusOffset: in byte; PCStall : in std_logic; IFFlush : in std_logic; OuterDB : in byte;

15

PC_addr : out byte; d_PCInc1 : out byte; d_IR : out byte --指令寄存器输出 );

end IFEntity;

architecture IFArch of IFEntity is signal PC,IR : std_logic_vector(7 downto 0); signal PCIncSel : std_logic;

signal s_PCInc1,PCnext : std_logic_vector(7 downto 0); signal op : std_logic_vector(3 downto 0); signal s_flag : std_logic_vector(3 downto 0); signal s_selZ,s_selC : std_logic; signal ZZ,CC : std_logic; begin

op <= IR(7 downto 4); with e_setFlag select ZZ <= Z when flag_hold, tempZ when others; with e_setFlag select CC <= C when flag_hold, tempC when others;

s_selZ <= '1' WHEN( op=JRZ AND ZZ='1') OR op=JR else '0';

s_selC <= '1' WHEN( op=JRC AND CC='1') else '0';

PCIncSel <= '1' WHEN s_selZ='1' or s_selC='1' ELSE '0';

s_PCInc1 <= PC + x\ WITH PCIncSel SELECT PCnext <= s_PCInc1 WHEN '0', PCPlusOffset WHEN '1', s_PCInc1 when others;

process(reset,clk,PCStall) begin if reset = '0' then PC <= x\ elsif FALLING_EDGE(clk) and (PCStall='0') then PC <= PCnext;

16

end if; end process;

PC_addr <= PC; --PC作为内存地址 d_IR <= IR;

process(reset,clk,OuterDB,IFFlush) begin if reset='0' then IR <= NopIns; -- NULL operation elsif RISING_EDGE(clk) then case IFFlush is when '0' => IR <= OuterDB; when others => IR <= NOPIns; end case; d_PCInc1 <= s_PCInc1; end if; end process; end IFArch;

--IDEntity.vhd- 译码模块 library IEEE;

use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; use work.unitpack.all;

entity IDEntity is port( reset : in std_logic; clk : in std_logic; d_IR : in byte; d_PCInc1 : in byte; w_WBData : in byte; w_destReg : in std_logic_vector(1 downto 0); w_wRegEn : in std_logic; e_SA,e_SB : out std_logic_vector(1 downto 0); i_PCPlusOffset : out byte; e_RAOut,e_RBOut : out byte; e_IMM : out byte; e_ALUSrc : out std_logic_vector(2 downto 0); e_ALUOpr : out std_logic_vector(3 downto 0); e_SetFlag : out std_logic_vector(2 downto 0); e_wrMem : out std_logic_vector(1 downto 0); e_wRegEn : out std_logic; e_destReg : out std_logic_vector(1 downto 0); e_MemToReg : out std_logic; RegSel : in std_logic_vector(1 downto 0);

17

RegOut : out byte ); end entity ;

architecture IDArch of IDEntity is SIGNAL RegArray : REGISTERARRAY; signal wRegIndex,ia,ib : INDEXTYPE; signal SA,SB : std_logic_vector(1 downto 0); signal wrMem : std_logic_vector(1 downto 0); signal wRegEn : std_logic; signal memToReg : std_logic; signal offset : byte; signal RA,RB : byte; signal ALUSrc : std_logic_vector(2 downto 0); signal ALUOpr : std_logic_vector(3 downto 0); signal SetFlag : std_logic_vector(2 downto 0); signal imm : byte; begin

ia <= conv_integer(SA); ib <= conv_integer(SB); RA <= RegArray(ia); RB <= RegArray(ib);

wRegIndex <= conv_integer(w_destReg); WriteBack:process(reset,clk) begin

if reset='0' then RegArray(0) <= x\--初始化寄存器 RegArray(1) <= x\ RegArray(2) <= x\--初始化寄存器 RegArray(3) <= x\ elsif FALLING_EDGE(clk) and w_wRegEn='1' then RegArray(wRegIndex) <= w_WBData; end if; end process;

Decode_Pro:process(d_IR)

variable op : std_logic_vector(3 downto 0); variable ctrl:std_logic_vector(17 downto 0); begin op := d_IR(7 downto 4); - case op is when ADD => ctrl:=d_IR(3 downto 0)&\ when SUBB => ctrl:=d_IR(3 downto 0)&\

18

when ANDins => ctrl:=d_IR(3 downto 0)&\ when MOV => ctrl:=d_IR(3 downto 0)&\ when LOADH =>

ctrl:=\1111\ imm <= \3 downto 0); when LOADL =>

ctrl:=\1111\ imm <= \3 downto 0); when LOAD => ctrl:=d_IR(3 downto 0)&\ when STORE => ctrl:=d_IR(3 downto 0)&\ when JR|JRZ|JRC => ctrl:=DoNothing; offset <= d_IR(3)&d_IR(3)&d_IR(3)&d_IR(3)&d_IR(3 downto 0); when MOVI => ctrl:=d_IR(3 downto 0)&\ imm <= \1 downto 0); when ORins => ctrl:=d_IR(3 downto 0)&\ when SHLIns => ctrl:=d_IR(3 downto 0)&\ when SHRIns => ctrl:=d_IR(3 downto 0)&\ when others => ctrl:=DoNothing; end case; SA <= ctrl(17 downto 16); SB <= ctrl(15 downto 14); WrMem <= ctrl(13 downto 12); wRegEn <= ctrl(11); MemToReg<= ctrl(10); ALUSrc <= ctrl(9 downto 7); ALUOpr <= ctrl(6 downto 3); SetFlag <= ctrl(2 downto 0); end process;

i_PCPlusOffset <= d_PCInc1 + offset; process(reset,clk) begin if reset = '0' then e_wrMem <= \ e_wRegEn <= '0'; elsif RISING_EDGE(clk) then e_SA <= SA;

19

e_SB <= SB; e_RAOut <= RA; e_RBOut <= RB; e_IMM <= imm; e_ALUSrc <= ALUSrc; e_ALUOpr <= ALUOpr; e_SetFlag <= SetFlag; e_wrMem <= wrMem; e_wRegEn <= wRegEn; e_destReg <= SA; e_MemToReg <= memToReg; end if; end process;

RegOut <= RegArray(conv_integer(RegSel)); end architecture;

--HazardDetectEntity.vhd- 结构相关处理模块 library IEEE;

use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; use work.unitpack.all;

entity HazardDetectEntity is

port( m_wrMem : in std_logic_vector(1 downto 0); w_wrMem : in std_logic_vector(1 downto 0); d_IR : in byte; IFFlush : out std_logic; PCStall : out std_logic ); end entity ;

architecture HazardDetectArch of HazardDetectEntity is begin

process(m_wrMem,d_IR)

variable d_op : std_logic_vector(3 downto 0); begin d_op := d_IR(7 downto 4); case m_wrmem is when \ if w_wrMem=\ PCStall <= '1'; else PCStall <= '0'; end if;

20

when others => case d_op is when LOAD => IFFlush <= '1'; PCStall <= '0'; when NOP => PCStall <='1'; IFFlush <= '0'; when others=> IFFlush <= '0'; PCStall <= '0'; end case; end case; end process; end architecture ;

--ForwardingEntity.vhd- 傍路处理模块 library IEEE;

use IEEE.std_logic_1164.all;

entity ForwardingEntity is port( m_wRegEn : in std_logic; w_wRegEn : in std_logic; m_SA : in std_logic_vector(1 downto 0); w_SA : in std_logic_vector(1 downto 0); e_SA : in std_logic_vector(1 downto 0); e_SB : in std_logic_vector(1 downto 0); forwardA : out std_logic_vector(1 downto 0); forwardB : out std_logic_vector(1 downto 0) ); end entity ;

architecture ForwardingArch of ForwardingEntity is begin

process(m_wRegEn,w_wRegEn,m_SA,w_sA,e_SA,e_SB) begin if m_wRegEn='1' and m_SA=e_SA then forwardA <= \ elsif w_wRegEn='1' and w_SA=e_SA then forwardA <= \ else forwardA <= \ end if; if m_wRegEn='1' and m_SA=e_SB then forwardB <= \ elsif w_wRegEn='1' and w_SA=e_SB then

21

forwardB <= \ else forwardB <= \ end if; end process; end architecture ;

--ExEntity.vhd- 执行模块 library ieee;

use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; use work.unitPack.all;

entity ExEntity is

port( reset,clk : in std_logic; e_RAOut,e_RBOut : in byte; e_ALUSrc : in std_logic_vector(2 downto 0); e_ALUOpr : in std_logic_vector(3 downto 0); e_SetFlag : in std_logic_vector(2 downto 0); e_IMM : in byte; forwardA,forwardB : in std_logic_vector(1 downto 0); e_SA : in std_logic_vector(1 downto 0); m_SA : out std_logic_vector(1 downto 0); e_ALUOut : in byte; w_WBdata : in byte; m_ALUOut : out byte; m_RBdata : out byte; i_tempZ : out std_logic; i_tempC : out std_logic; m_flag : out std_logic_vector(3 downto 0); e_wRegEn : IN std_logic; m_wRegEn : out std_logic; e_memToReg : in std_logic; m_memToReg : out std_logic; e_destReg : IN std_logic_vector(1 downto 0); m_destReg : out std_logic_vector(1 downto 0); e_wrMem : IN std_logic_vector(1 downto 0); m_wrMem : out std_logic_vector(1 downto 0) ); end entity ;

architecture ExArch of ExEntity is signal ALUaIn,ALUbIn : byte; signal dout : byte;

22

signal C,Z,V,S : STD_LOGIC; signal tempFlag : std_logic_vector(3 downto 0); begin

with forwardA select ALUaIn <= e_RAOut when \ e_ALUOut when \ w_WBdata when \ e_RAOut when others; with forwardB select ALUbIn <= e_RBOut when \ e_ALUOut when \ w_WBdata when \ e_RBOut when others;

ALUActivity:process(ALUaIn,ALUbIn,e_ALUSrc,e_ALUOpr,e_setFlag,e_IMM,tempFlag)

variable ALUResult,opR,opS : std_logic_vector(8 downto 0); variable cx,tempC,tempZ,tempV,tempS : std_logic; begin case e_ALUSrc is --选择ALU的两入口数据 when selA0 => opR := '0'&ALUaIn; opS := ZERO9; when selAB => opR := '0'&ALUaIn; opS := '0'&ALUbIn; when selA1 => opR := '0'&ALUaIn; opS := '0'&(X\01\ when sel0B => opR := ZERO9 ; opS := '0'&ALUbIn; when selAF => opR := '0'&ALUaIn; opS := '1'&(X\FF\ when selAD => opR := '0'&ALUaIn; opS := '0'&e_IMM; when others => opR := ZERO9; opS := ZERO9; end case;7 case e_ALUOpr is when aluAdd => ALUResult := opR + opS; tempV := ((not opR(7))and(not opS(7))and ALUResult(7)) or (opR(7)and opS(7)and (not ALUResult(7))); when aluSub => ALUResult := opR - opS; tempV := ( opS(7)and(not opR(7))and (not ALUResult(7))) or ((NOT opS(7))and opR(7)and ALUResult(7)); when aluAnd => ALUResult := opR and opS; when aluOr => ALUResult := opR or opS; when aluShl => ALUResult(7 downto 1) := opR(6 downto 0); ALUResult(0) := '0'; cx := opR(7); when aluShr => ALUResult(6 downto 0) := opR(7 downto 1); ALUResult(7) := '0'; cx := opR(0); when aluLOADH => ALUResult := opS(4 downto 0)&opR(3 downto 0); when aluLOADL => ALUResult := '0'&opR(7 downto 4)&opS(3 downto 0); when aluMOVI => ALUResult := \3 downto 0);

23

when others => null; end case; dout <= ALUResult(7 downto 0); case e_ALUOpr is when aluAdd|aluSub => tempC := ALUResult(8); when aluShl|aluShr => tempC := cx; when aluAnd|aluOr => tempC := '0'; tempV:= '0'; --逻辑运算,状态位C,Z置零 when others => null; end case; i_tempC <= tempC; if ALUResult = ZERO9 then tempZ := '1'; else tempZ := '0'; end if; i_tempZ <= tempZ; tempS := ALUResult(7); case e_setFlag is when flag_hold => (C,Z,V,S)<= tempFLAG; when flag_update => C<=tempC; Z <= tempZ; V <= tempV; <= tempS; when flag_InnerDB => (C,Z,V,S) <= e_IMM(3 downto 0); when flag_clear => C<='0'; Z<='0'; V<='0'; S<='0'; when others => (C,Z,V,S)<= tempFLAG; end case; end process;

WriteFlag:process(reset,clk) begin if reset = '0' then tempFlag <= \ elsif RISING_EDGE(clk) then tempFlag <= C&Z&V&S; end if; m_flag <= tempFlag; end process; process(reset,clk) begin if reset='0' then m_wrMem <= \ m_wRegEn <= '0'; elsif RISING_EDGE(clk) then m_SA <= e_SA; m_ALUOut <= dout; m_RBdata <= ALUbIn; m_wRegEn <= e_wRegEn; m_memToReg <= e_memToReg;

24

S

m_destReg <= e_destReg; m_wrMem <= e_wrMem; end if; end process; end architecture ;

--CPUEntity.vhd- CPU模块 library ieee;

use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; use work.unitPack.all;

entity CPUEntity is

port( reset :in std_logic; clk :in std_logic; OuterDB :INOUT std_logic_vector(7 downto 0); memAddr :out std_logic_vector(7 downto 0); wr :out std_logic; flag :out std_logic_vector(3 downto 0); RegSel :in std_logic_vector(2 downto 0); RegOut :out std_logic_vector(7 downto 0); );

end CPUEntity;

architecture CPUArch of CPUEntity is signal s_i_PCPlusOffset : byte; signal s_PCStall : std_logic; signal s_IFFlush : std_logic;

signal s_tempZ,s_tempC : std_logic; signal s_PCInc1 : byte; signal s_d_IR : byte; signal s_w_WBData : byte; signal s_w_destReg : std_logic_vector(1 downto 0); signal s_w_wRegEn : std_logic; signal s_RegSel : std_logic_vector(1 downto 0); signal s_RegOut : byte; signal s_e_SA : std_logic_vector(1 downto 0); signal s_e_SB : std_logic_vector(1 downto 0); signal s_e_RAOut : byte; signal s_e_RBOut : byte; signal s_e_IMM : byte;

signal s_e_ALUSrc : std_logic_vector(2 downto 0); signal s_e_ALUOpr : std_logic_vector(3 downto 0); signal s_e_SetFlag : std_logic_vector(2 downto 0);

25

signal s_e_wrMem : std_logic_vector(1 downto 0); signal s_e_wRegEn : std_logic; signal s_e_destReg : std_logic_vector(1 downto 0); signal s_e_MemToReg : std_logic; signal s_forwardA : std_logic_vector(1 downto 0); signal s_forwardB : std_logic_vector(1 downto 0); signal s_PCaddr : byte; signal s_m_ALUOut : byte; signal s_m_RBdata : byte; signal s_m_wrMem : std_logic_vector(1 downto 0); signal s_m_wRegEn : std_logic; signal s_m_memToReg : std_logic; signal s_m_destReg : std_logic_vector(1 downto 0); signal s_w_ALUOut : byte; signal s_m_SA : std_logic_vector(1 downto 0); signal s_w_SA : std_logic_vector(1 downto 0); signal s_w_memToReg : std_logic;

signal s_m_flag : std_logic_vector(3 downto 0); signal s_w_flag : std_logic_vector(3 downto 0); signal s_w_MemOut : byte; signal s_w_wrMem : std_logic_vector(1 downto 0); component IFEntity is --取指模块 port ( reset : in STD_LOGIC; clk : in STD_LOGIC; Z : in std_logic; --状态位 C : in std_logic; tempZ : in std_logic; --临时状态位,傍路处理 tempC : in std_logic; e_setFlag : in std_logic_vector(2 downto 0); PCPlusOffset: in byte; PCStall : in std_logic; --'1' : PC 保持不变 IFFlush : in std_logic; --'1' : NOP->IR OuterDB : in byte; PC_addr : out byte; d_PCInc1 : out byte; d_IR : out byte; );

end component IFEntity;

component IDEntity is --译码模块 port( reset : in std_logic; clk : in std_logic; d_IR : in byte; d_PCInc1 : in byte;

26

w_WBData : in byte; w_destReg : in std_logic_vector(1 downto 0); w_wRegEn : in std_logic; e_SA,e_SB : out std_logic_vector(1 downto 0); i_PCPlusOffset : out byte; e_RAOut,e_RBOut : out byte; e_IMM : out byte; e_ALUSrc : out std_logic_vector(2 downto 0); e_ALUOpr : out std_logic_vector(3 downto 0); e_SetFlag : out std_logic_vector(2 downto 0); e_wrMem : out std_logic_vector(1 downto 0); e_wRegEn : out std_logic; e_destReg : out std_logic_vector(1 downto 0); e_MemToReg : out std_logic; RegSel : in std_logic_vector(1 downto 0); RegOut : out byte );

end component ;

component ExEntity is --执行模块 port( reset,clk : in std_logic; e_RAOut,e_RBOut : in byte; e_ALUSrc : in std_logic_vector(2 downto 0); e_ALUOpr : in std_logic_vector(3 downto 0); e_SetFlag : in std_logic_vector(2 downto 0); e_IMM : in byte; forwardA,forwardB : in std_logic_vector(1 downto 0); e_SA : in std_logic_vector(1 downto 0); m_SA : out std_logic_vector(1 downto 0);

e_ALUOut : in byte; w_WBdata : in byte; m_ALUOut : out byte;

m_RBdata : out byte; i_tempZ : out std_logic; i_tempC : out std_logic; m_flag : out std_logic_vector(3 downto 0); e_wRegEn : IN std_logic; m_wRegEn : out std_logic; e_memToReg : in std_logic; m_memToReg : out std_logic;

e_destReg : IN std_logic_vector(1 downto 0); m_destReg : out std_logic_vector(1 downto 0); e_wrMem : IN std_logic_vector(1 downto 0);

27

m_wrMem : out std_logic_vector(1 downto 0) end component;

component MemAccessEntity is --访存模块 port( reset,clk : in std_logic; m_wrMem : in std_logic_vector(1 downto 0); w_wrMem : out std_logic_vector(1 downto 0); m_ALUOut : in byte; m_RBdata : in byte; wr : out std_logic; OuterDB : inout byte; w_ALUOut : out byte; w_MemOut : out byte; m_flag : in std_logic_vector(3 downto 0); w_flag : out std_logic_vector(3 downto 0); PC : in byte; addr : out byte; m_SA : in std_logic_vector(1 downto 0); w_SA : out std_logic_vector(1 downto 0); m_wRegEn : in std_logic; m_destReg : in std_logic_vector(1 downto 0); m_memToReg : in std_logic; w_wRegEn : out std_logic; w_destReg : out std_logic_vector(1 downto 0); w_memToReg : out std_logic );

end component;

component ForwardingEntity is --数据相关检测及傍路处理模块 port( m_wRegEn : in std_logic; w_wRegEn : in std_logic; m_SA : in std_logic_vector(1 downto 0); w_SA : in std_logic_vector(1 downto 0); e_SA : in std_logic_vector(1 downto 0); e_SB : in std_logic_vector(1 downto 0); forwardA : out std_logic_vector(1 downto 0); forwardB : out std_logic_vector(1 downto 0) );

end component ;

component HazardDetectEntity is --控制相关检测及处理模块 port( m_wrMem : in std_logic_vector(1 downto 0); w_wrMem : in std_logic_vector(1 downto 0); d_IR : in byte;--取址寄存器IR

28

-- d_IR : in word; IFFlush : out std_logic; PCStall : out std_logic );

end component; begin

IFUnit: IFEntity port map (reset=>reset, ); --二级流水,译码

IDUnit: IDEntity port map ( d_IR=>s_d_IR,

clk=>clk,

Z=>s_m_flag(2), C=>s_m_flag(3), tempZ=>s_tempZ, tempC=>s_tempC, e_setFlag=>s_e_SetFlag, PCPlusOffset=>s_i_PCPlusOffset, PCStall=>s_PCStall, IFFlush=>s_IFFlush, OuterDB=>OuterDB, PC_addr=>s_PCaddr, d_PCInc1=>s_PCInc1, d_IR=>s_d_IR

reset=>reset, clk=>clk, d_PCInc1=>s_PCInc1, w_WBData=>s_w_WBData, w_destReg=>s_w_destReg, w_wRegEn=>s_w_wRegEn, i_PCPlusOffset=>s_i_PCPlusOffset, e_SA=>s_e_SA, e_SB=>s_e_SB, e_RAOut=>s_e_RAOut, e_RBOut=>s_e_RBOut, e_IMM =>s_e_IMM, e_ALUSrc=>s_e_ALUSrc, e_ALUOpr=>s_e_ALUOpr, e_SetFlag=>s_e_SetFlag, e_wrMem=>s_e_wrMem, e_wRegEn=>s_e_wRegEn, e_destReg=>s_e_destReg, e_MemToReg=>s_e_MemToReg,

RegSel=>s_RegSel,

29

RegOut=>s_RegOut );

--三级流水,执行/计算有效地址 ExUnit: ExEntity port map( reset=>reset, clk=>clk, e_RAOut=>s_e_RAOut, e_RBOut=>s_e_RBOut, e_ALUSrc=>s_e_ALUSrc, e_ALUOpr=>s_e_ALUOpr, e_SetFlag=>s_e_SetFlag, e_IMM =>s_e_IMM, e_wrMem=>s_e_wrMem, e_wRegEn=>s_e_wRegEn, e_destReg=>s_e_destReg, e_MemToReg=>s_e_MemToReg, forwardA=>s_forwardA, forwardB=>s_forwardB, e_ALUOut=>s_m_ALUOut, e_SA=>s_e_SA, m_SA=>s_m_SA, m_ALUOut=>s_m_ALUOut, w_WBData=>s_w_WBData, m_flag=>s_m_flag, i_tempZ=>s_tempZ, i_tempC=>s_tempC, m_RBdata=>s_m_RBdata, m_wrMem =>s_m_wrMem, m_wRegEn=>s_m_wRegEn, m_memToReg=>s_m_memToReg, m_destReg=>s_m_destReg ); --四级流水,访问内存

MemAccessUnit: MemAccessEntity port map (reset=>reset, clk=>clk, m_wrMem=>s_m_wrMem, w_wrMem=>s_w_wrMem, m_ALUOut=>s_m_ALUOut, m_RBdata=>s_m_RBdata, wr=>wr, OuterDB=>OuterDB, w_ALUOut=>s_w_ALUOut, w_MemOut=>s_w_Memout, m_flag=>s_m_flag, w_flag=>s_w_flag,

30

-- PC=>s_PCaddr, addr=>memAddr, -- m_SA=>s_m_SA, w_SA=>s_w_SA, m_wRegEn=>s_m_wRegEn, m_destReg=>s_m_destReg, m_memToReg=>s_m_memToReg, w_wRegEn=>s_w_wRegEn, w_destReg=>s_w_destReg, w_memToReg=>s_w_memToReg ); \\ --五级流水,回写寄存器

with s_w_memToReg select s_w_WBData <= s_w_ALUOut when '1', s_w_MemOut when others; process(clk) begin if FALLING_EDGE(clk) then flag <= s_w_flag; end if; end process; --傍路处理

ForwardUnit: ForwardingEntity port map( m_wRegEn=>s_m_wRegEn, w_wRegEn=>s_w_wRegEn, m_SA=>s_m_SA, w_SA=>s_w_SA, e_SA=>s_e_SA, e_SB=>s_e_SB, forwardA=>s_forwardA, forwardB=>s_forwardB ); --结构、控制相关的处理

HDUnit: HazardDetectEntity port map ( m_wrMem=>s_m_wrMem, w_wrMem=>s_w_wrMem, d_IR=>s_d_IR, IFFlush=>s_IFFlush, PCStall=>s_PCStall ); -- debug

process(RegSel,s_d_IR,s_PCAddr,s_RegOut)

31

begin case RegSel is when \ when \ when others => s_RegSel <= RegSel(1 downto 0); RegOut <= s_RegOut; end case; end process; end architecture ;

--实验 RAM存储器

library ieee;

use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; library my_lib;

use my_lib.unitPack.all;

ENTITY asynram IS

PORT ( dinout : INOUT STD_LOGIC_VECTOR(7 DOWNTO 0); adr : IN STD_LOGIC_VECTOR(7 DOWNTO 0); rw : IN STD_LOGIC; reset: IN STD_LOGIC );

END asynram;

ARCHITECTURE rtl OF asynram IS

SIGNAL ram:ram_type; BEGIN

PROCESS(adr,rw,ram,dinout,reset) BEGIN IF reset='0' THEN ram(0) <= LOADH &\ --send \ ram(1) <= LOADL &\ --send \ R0=0, R1=0, R2=0, R3=1; ram(2) <= MOV & R0 & R3; --R0=3 send \R0( mov R3 to R0); R0=1, R1=0, R2=0, R3=1;

32

ram(3) <= MOV & R1 & R3; --R1=3 ram(4) <= SHRins & R0 &\ --R0=1 ram(5) <= ADD & R1 & R0; --R1=4 ram(6) <= JRC &\ --IF C=1,PC JUMP ram(7) <= SHLins & R0 &\ --R0=2 ram(8) <= ORins & R1 & R0; --R1=6 ram(9) <= SUBB & R1 & R0; --R1=4 ram(10) <= JRZ &\ --IF Z=1,PC JUMP ram(11) <= ANDins & R1 & R0; --R1=0 ram(12) <= STORE & R1 & R1; ram(13) <= LOAD & R3 & R0; --R3=[R0]=0 ram(14) <= NOPins; --NOP ram(15) <= JR &\ --pc jump back to ram(14) END IF; IF rw='0' THEN dinout <= Z8; ram(conv_integer(adr)) <= dinout; END IF;

IF rw='1' THEN

dinout <= ram(conv_integer(adr)); END IF;

END PROCESS; END rtl;

--Addr_muxEntity 地址选择MUX library IEEE;

use IEEE.std_logic_1164.all; use IEEE.std_logic_unsigned.all; use work.unitpack.all;

entity Addr_muxEntity is port( PC : in word; ALUOut : in word; addrSel: in std_logic; addr : out word ); end entity ;

architecture Addr_muxArch of Addr_muxEntity is begin

with addrSel select

33

addr <= PC when '0', ALUOut when others; end architecture;

5. 测试用汇编程序及汇编规则 ram(0) <= LOADH &\

寄存器: R0 00 R1 01 R2 10 R3 11 指令:

constant ADD : std_logic_vector(3 downto 0):=\ constant SUBB : std_logic_vector(3 downto 0):=\

constant ANDins : std_logic_vector(3 downto 0):=\ constant MOV : std_logic_vector(3 downto 0):=\ constant LOAD : std_logic_vector(3 downto 0):=\ constant STORE : std_logic_vector(3 downto 0):=\ constant LOADH : std_logic_vector(3 downto 0):=\ constant LOADL : std_logic_vector(3 downto 0):=\ constant JR : std_logic_vector(3 downto 0):=\ constant JRZ : std_logic_vector(3 downto 0):=\ constant NOP : std_logic_vector(3 downto 0):=\ constant MOVI : std_logic_vector(3 downto 0):=\

constant NOPIns : std_logic_vector(7 downto 0):=\

ram(1) <= LOADL &\ ram(2) <= MOV & R0 & R3; ram(3) <= MOV & R1 & R3; ram(4) <= SHRins & R0 &\ ram(5) <= ADD & R1 & R0; ram(6) <= JRC &\ ram(7) <= SHLins & R0 &\ ram(8) <= ORins & R1 & R0; ram(9) <= SUBB & R1 & R0; ram(10) <= JRZ &\ ram(11) <= ANDins & R1 & R0; ram(12) <= STORE & R1 & R1; ram(13) <= LOAD & R3 & R0; ram(14) <= NOPins; ram(15) <= JR &\

6. 管脚分配与测试结果

34

根据测试用汇编程序相应地给出结果，并说明原因 7. 实验总结

小组的每一个人都要写做了哪些工作、有何心得体会、注意事项等，最后评分的时候还会考虑各人的情况来给出综合实验最后的成绩评定。

对于有想法且作了尝试，但未成功的情况，也可以进行说明。

三、设计报告提交材料

提交设计报告的时候，每个小组建立一个文件夹，并按“专业+班级+组号”方式命名，如“网工2班陈xx、张xx”等。文件夹内部包括如下的两份资料：

1. 课程设计的VHDL源代码，放在一个文件夹内，文件夹命名为“VHDL源代码”。里面放

实验检查时可以正常使用的那一份源代码。如若在完成实验的过程中，有些实验内容进行了尝试但不能真正运行，也请提交这一份代码。为了区分这两份代码，请在“VHDL源代码”文件下下分别建立两个文件夹，名字各组自己定，并在每个文件夹下用readme.txt说明一下是否可用；若属于不可用的情形，简要说明原因在哪里。虽然另一份代码不可用，但在给出综合实验成绩会考虑进去；

2. 课程设计文档。此文档必须包含封面页和内容页，封面页见下一页，内容项见前面的说

明。文档的名字按“组号：小组成员姓名”方式命名。例如，“第1组：张三、李四、王某”。

四、注意事项

1. 每组撰写一份课程设计报告，于12月20日晚上12点前，提交给学委， briskw@126.com的邮箱；

2. 课程设计报告必须按照封面及内容提纲要求进行撰写，否则将扣20%的分。此外，课程设计报告必须各组自己撰写，如果发现抄袭他组的情况，两个组皆记0分，请各组自己注意管好自己的文档，学委也要注意各组上交的文档不能外泄；如果发现完全抄袭其他材料，则该组记0分；

3. 如果没有收到课程设计报告，不能给出课程成绩。

35

根据测试用汇编程序相应地给出结果，并说明原因 7. 实验总结

小组的每一个人都要写做了哪些工作、有何心得体会、注意事项等，最后评分的时候还会考虑各人的情况来给出综合实验最后的成绩评定。

对于有想法且作了尝试，但未成功的情况，也可以进行说明。

三、设计报告提交材料

提交设计报告的时候，每个小组建立一个文件夹，并按“专业+班级+组号”方式命名，如“网工2班陈xx、张xx”等。文件夹内部包括如下的两份资料：

1. 课程设计的VHDL源代码，放在一个文件夹内，文件夹命名为“VHDL源代码”。里面放

实验检查时可以正常使用的那一份源代码。如若在完成实验的过程中，有些实验内容进行了尝试但不能真正运行，也请提交这一份代码。为了区分这两份代码，请在“VHDL源代码”文件下下分别建立两个文件夹，名字各组自己定，并在每个文件夹下用readme.txt说明一下是否可用；若属于不可用的情形，简要说明原因在哪里。虽然另一份代码不可用，但在给出综合实验成绩会考虑进去；

2. 课程设计文档。此文档必须包含封面页和内容页，封面页见下一页，内容项见前面的说

明。文档的名字按“组号：小组成员姓名”方式命名。例如，“第1组：张三、李四、王某”。

四、注意事项

1. 每组撰写一份课程设计报告，于12月20日晚上12点前，提交给学委， briskw@126.com的邮箱；

2. 课程设计报告必须按照封面及内容提纲要求进行撰写，否则将扣20%的分。此外，课程设计报告必须各组自己撰写，如果发现抄袭他组的情况，两个组皆记0分，请各组自己注意管好自己的文档，学委也要注意各组上交的文档不能外泄；如果发现完全抄袭其他材料，则该组记0分；

3. 如果没有收到课程设计报告，不能给出课程成绩。

35

本文来源：https://www.bwwdw.com/article/ct1r.html