下载文档原格式
IntelSSE:SSE是指令集的简称，它包括70条指令，其中包含单指令多数据浮点计算、以及额外的SIMD整数和高速缓存控制指令。
其优势包括：更高分辨率的图像浏览和处理、高质量音频、MPEG2视频、同时MPEG2加解密；语音识别占用更少CPU资源；更高精度和更快响应速度。
SSE(Streaming SIMD Extensions)是英特尔在AMD的3D Now!发布一年之后，在其计算机芯片Pentium III中引入的指令集，是MMX的超集。
AMD后来在Athlon XP中加入了对这个指令集的支持。
这个指令集增加了对8个128位寄存器XMM0-XMM7的支持，每个寄存器可以存储4个单精度浮点数。
使用这些寄存器的程序必须使用FXSAVE和FXRSTR指令来保持和恢复状态。
但是在Pentium III对SSE的实现中，浮点数寄存器又一次被新的指令集占用了，但是这一次切换运算模式不是必要的了，只是SSE和浮点数指令不能同时进入CPU的处理线而已。
SSE2是Intel在P4的最初版本中引入的，但是AMD后来在Opteron 和Athlon 64中也加入了对它的支持。
这个指令集添加了对64位双精度浮点数的支持，以及对整型数据的支持，也就是说这个指令集中所有的MMX指令都是多余的了，同时也避免了占用浮点数寄存器。
这个指令集还增加了对CPU的缓存的控制指令。
AMD对它的扩展增加了8个XMM寄存器，但是需要切换到64位模式(AMD64)才可以使用这些寄存器。
Intel后来在其EM64T架构中也增加了对AMD64的支持。
SSE3是Intel在P4的Prescott版中引入的指令集，AMD在Athlon 64的第五个版本中也添加了对它的支持。
这个指令集扩展的指令包含寄存器的局部位之间的运算，例如高位和低位之间的加减运算；浮点数到整数的转换，以及对超线程技术的支持。
SSE4指令集将给英特尔下一代平台带来“相当大的视频性能提升”。
电脑指令代码大全电脑指令代码是计算机程序设计中的重要组成部分，它是计算机能够理解和执行的命令集合。
在计算机编程中，了解和掌握各种指令代码是非常重要的，它可以帮助程序员更好地编写程序，实现各种功能。
本文将为大家介绍一些常见的电脑指令代码，希望能够帮助大家更好地理解和应用这些指令代码。
1. 数据处理指令代码。
数据处理指令代码是用来对数据进行处理和计算的指令。
比如，加法指令、减法指令、乘法指令、除法指令等，它们可以帮助程序员对数据进行各种运算操作。
在编写程序时，程序员可以根据实际需求选择合适的数据处理指令代码，从而实现各种复杂的计算。
2. 逻辑控制指令代码。
逻辑控制指令代码用于控制程序的执行流程。
比如，条件判断指令、循环指令、跳转指令等，它们可以帮助程序员实现程序的分支和循环执行。
在实际编程中，逻辑控制指令代码可以帮助程序员编写出更加灵活和高效的程序。
3. 存储访问指令代码。
存储访问指令代码用于对内存和外部存储器进行读写操作。
比如，读取指令、写入指令、加载指令、存储指令等，它们可以帮助程序员实现对数据的读取和存储。
在程序设计中，存储访问指令代码是非常重要的，它直接影响到程序对数据的操作和存储。
4. 输入输出指令代码。
输入输出指令代码用于实现程序与外部设备的交互。
比如，输入指令、输出指令、中断指令等，它们可以帮助程序员实现程序与键盘、鼠标、显示器、打印机等设备的交互。
在实际应用中，输入输出指令代码是非常重要的，它直接影响到程序与用户和外部设备的交互。
5. 系统调用指令代码。
系统调用指令代码用于程序与操作系统进行交互。
比如，系统调用指令、中断指令等，它们可以帮助程序员实现对操作系统的调用和利用。
在实际编程中，系统调用指令代码是非常重要的，它可以帮助程序员实现对操作系统各种功能的调用和利用。
总结。
电脑指令代码是计算机程序设计中的重要组成部分，它直接影响到程序的执行和功能实现。
了解和掌握各种指令代码对于程序员来说是非常重要的，它可以帮助程序员编写出更加灵活和高效的程序。
CPU指令集详细介绍所谓指令集，就是CPU中用来计算和控制计算机系统的一套指令的*，而每一种新型的CPU在设计时就规定了一系列与其他硬件电路相配合的指令系统。
而指令集的先进与否，也关系到CPU的*能发挥，它也是CPU*能体现的一个重要标志。
SSE指令集由于MMX指令并没有带来3D游戏*能的显著提升，1999年Intel 公司在PentiumIIICPU产品中推出了数据流单指令序列扩展指令(SSE)。
SSE兼容MMX指令，它可以通过SIMD(单指令多数据技术)和单时钟周期并行处理多个浮点来有效地提高浮点运算速度。
SSE2指令集在Pentium4CPU中，Intel公司开发了新指令集SSE2。
这一次新开发的SSE2指令一共144条，包括浮点SIMD指令、整形SIMD指令、SIMD浮点和整形数据之间转换、数据在MMX寄存器中转换等几大部分。
SSE3指令集相对于SSE2，SSE3又新增加了13条新指令，此前它们被统称为pni(prescottnewinstructions)。
13条指令中，一条用于视频解码，两条用于线程同步，其余用于复杂的数学运算、浮点到整数转换和SIMD浮点运算。
SSE4指令集SSE4又增加了50条新的增加*能的指令，这些指令有助于编译、媒体、字符/文本处理和程序指向加速。
3DNow!扩展指令集3DNow!指令集是AMD公司1998年开发的多媒体扩展指令集，共有21条指令。
针对MMX指令集没有加强浮点处理能力的弱点，重点提高了AMD公司K6系列CPU对3D图形的处理能力。
X86指令集要知道什么是指令集还要从当今的X86架构的CPU说起。
X86指令集是Intel为其第一块16位CPU(i8086)专门开发的，IBM1981年推出的世界第一台PC机中的CPU—i8088(i8086简化版)使用的也是X86指令，同时电脑中为提高浮点数据处理能力而增加的X87芯片系列数学协处理器则另外使用X87指令，以后就将X86指令集和X87指令集统称为X86指令集。
CPU常用操作指令CPU常用操作指令是指在汇编语言中使用的一些常见的指令，用于完成各种任务和操作。
这些指令可以用于数据传输、算术运算、逻辑运算、条件分支等各种操作。
下面我将列举一些常见的CPU操作指令，并介绍它们的用途和示例。
1.MOV指令：用于将数据从一个地方移动到另一个地方。
例如，将一个寄存器中的值移动到另一个寄存器中，或将一个内存单元中的值移动到一个寄存器中。
示例：MOVAX,BX;将BX中的值移动到AX中MOV[BX],10;将值10存储到BX所指向的内存单元中2.ADD指令：用于执行整数的加法操作。
可以将两个寄存器中的值相加，或将一个寄存器中的值与一个立即数相加。
示例：ADDAX,BX;将AX和BX中的值相加，并将结果存储到AX中ADDAX,10;将AX中的值与10相加，并将结果存储到AX中3.SUB指令：用于执行整数的减法操作。
可以将两个寄存器中的值相减，或将一个寄存器中的值与一个立即数相减。
示例：SUBAX,BX;将AX和BX中的值相减，并将结果存储到AX中SUBAX,10;将AX中的值减去10，并将结果存储到AX中4.MUL指令：用于执行无符号整数的乘法操作。
可以将一个寄存器中的值与另一个寄存器中的值相乘，并将结果存储到两个乘积寄存器中。
示例：MOVAX,10;将值10存储到AX中MOVBX,5;将值5存储到BX中MULBX;将AX中的值与BX中的值相乘，并将结果存储到AX和DX中5.DIV指令：用于执行无符号整数的除法操作。
可以将一个寄存器中的值与另一个寄存器中的值相除，并将商存储到一个寄存器中，余数存储到另一个寄存器中。
示例：MOVAX,20;将值20存储到AX中MOVBX,5;将值5存储到BX中DIVBX;将AX中的值除以BX中的值，并将商存储到AX中，余数存储到DX中6.AND指令：用于执行逻辑与操作。
可以将一个寄存器中的值与另一个寄存器中的值进行逻辑与运算，并将结果存储到一个寄存器中。
c语言指令大全表解释C语言指令是计算机科学领域中的基础知识，掌握好它们意味着能够进行高效的编码工作。
正因如此，这篇文章将会针对C语言指令大全表进行解释性阐述。
首先，我们需要了解表中不同的分类，包括：控制流、数据类型、函数库、编译指令和预处理指令。
这些分类代表了不同的操作方式和目的，我们需要根据需求选择不同的指令来使用。
接下来，让我们详细介绍一下C语言指令分类的不同之处和应用场景。
控制流指令：包括条件和循环等语句，它们是一些用来控制代码执行流程的代码片段。
例如：· if语句：用于条件判断，如果满足条件，则执行特定代码块。
· while循环语句：重复执行某一段代码，直到满足条件才退出。
· for循环语句：用于迭代一些操作，通常会有一个计数器来控制循环次数。
数据类型指令：C语言支持多种数据类型，我们需要根据实际需求来选择不同的数据类型。
例如：· int类型：用于表示整数值。
· float类型：用于表示浮点数值。
· char类型：用于表示单个字符。
· double类型：用于表示双精度浮点数。
函数库指令：函数库是预先编写好的一些代码片段，方便我们在程序中调用。
例如：· printf()函数：用于输出文字。
· scanf()函数：用于输入数据。
· pow()函数：用于数学运算，求一个数的n次方。
编译指令：用于告诉程序如何编译代码，之后我们可以在程序中使用它们。
例如：· #include指令：用于载入头文件。
· #define指令：用于定义宏。
预处理指令：是在编译代码之前执行的一系列操作。
例如：· #if指令：用于条件编译，根据条件判断是否编译。
· #ifdef指令：用于检查是否定义了某个宏。
在学习和理解这些指令的过程中，我们不仅需要了解每个指令的具体语法和用法，更要深入思考其潜在的含义和应用场景，学会如何灵活选择和使用它们。
cpu指令由什么组成中央处理器称为CPU(Control Processing Unit)，它主要由控制器和运算器组成，是计算机的核心部件。
下面是店铺给大家整理的一些有关cpu指令的组成，希望对大家有帮助!cpu指令的组成简单介绍CPU指令集：MMX SSE SSE2 SSE3 3DNow! AMD64 EM64TMMX：MMX(Multi Media eXtension 多媒体扩展指令)指令集是Intel公司在1996年为旗下的Pentium系列处理器所开发的一项多媒体指令增强技术。
MMX指令集中包括了57条多媒体指令，通过这些指令可以一次性处理多个数据，在处理结果超过实际处理能力的时候仍能够进行正常处理，如果在软件的配合下，可以得到更强的处理性能。
使用MMX指令集的好处就是当时所使用的操作系统可以在不做任何改变的情况下执行MMX指令。
但是，MMX指令集的问题也是比较明显的，MMX指令集不能与X86的浮点运算指令同时执行，必须做密集式的交错切换才可以正常执行，但是这样一来，就会造成整个系统运行速度的下降。
SSE：SSE是Streaming SIMD Extension(SIMD扩展指令集)的缩写，而其中SIMD的为含意为Single Istruction Multiple Data(单指令多数据)，所以SSE指令集也叫单指令多数据流扩展。
该指令集最先运用于Intel的Pentium III系列处理器，其实在Pentium III推出之前，Intel方面就已经泄漏过关于KNI(Katmai New Instruction)指令集的消息。
这个KNI指令集也就是SSE指令集的前身，当时也有不少的媒体将该指令集称之为MMX2指令集，但是Intel方面却从没有发布有关MMX2指令集的消息。
最后在Intel推出Pentium III处理器的时候，SSE指令集也终于水落石出。
SSE指令集是为提高处理器浮点性能而开发的扩展指令集，它共有70条指令，其中包含提高3D图形运算效率的50条SIMD浮点运算指令、12条MMX 整数运算增强指令、8条优化内存中的连续数据块传输指令。
电脑指令代码大全在计算机编程领域，指令代码是一种用于控制计算机硬件执行特定操作的命令集合。
它可以用于实现各种功能，从简单的数学运算到复杂的图形处理。
本文将为大家介绍一些常见的电脑指令代码，帮助大家更好地理解和应用这些代码。
首先，我们来介绍一些常见的数学运算指令代码。
在计算机编程中，我们经常需要对数字进行加减乘除等运算。
比如，加法运算可以使用“add”指令，减法运算可以使用“sub”指令，乘法运算可以使用“mul”指令，除法运算可以使用“div”指令。
这些指令可以帮助我们实现各种复杂的数学运算，从而完成各种计算任务。
除了数学运算，我们还经常需要对数据进行逻辑操作。
比如，我们可能需要对数据进行比较、逻辑与或非运算。
这时，我们可以使用一些逻辑操作指令代码来实现。
比如，比较操作可以使用“cmp”指令，逻辑与操作可以使用“and”指令，逻辑或操作可以使用“or”指令，逻辑非操作可以使用“not”指令。
这些指令可以帮助我们实现各种复杂的逻辑操作，从而完成各种逻辑判断和控制任务。
此外，我们还需要对内存进行读写操作。
在计算机编程中，我们经常需要从内存中读取数据，或者将数据写入内存。
这时，我们可以使用一些内存操作指令代码来实现。
比如，读操作可以使用“load”指令，写操作可以使用“store”指令。
这些指令可以帮助我们实现对内存的读写操作，从而完成各种数据存取任务。
除了上述常见的指令代码，还有一些其他类型的指令代码，比如跳转指令、函数调用指令、IO操作指令等。
这些指令代码可以帮助我们实现各种复杂的控制和交互操作，从而完成各种实际的应用任务。
总的来说，电脑指令代码是计算机编程中非常重要的一部分，它可以帮助我们实现各种复杂的功能和任务。
通过学习和掌握各种指令代码，我们可以更好地理解和应用计算机编程，从而提高自己的编程能力，实现更加丰富和复杂的应用。
希望本文介绍的一些常见的指令代码对大家有所帮助，也希望大家能够进一步深入学习和掌握更多的指令代码，从而在编程领域取得更大的成就。
看编号识CPU：教你识别处理器编号CPU上面的编号代表了该CPU的主要性能指标。
如产品系列、主频、缓存容量、使用电压、封装方式、产地、生产日期，通过识别CPU编号，你可以初步认定CPU的工作频率、外频、属于何系列的，防止一些非法商家用超频的CPU冒充高频率产品。
PIII Confidential编号格式：xxxEBkkkMMM2.0VS1 abcde abcdefgh-0123Xxx: ：代表CPU工作频率EB ：E=采用0.18微米制造工艺；B=133MHZ FSB前端总线Kkk ：代表二级缓存的容量MMM：代表CPU的外部频2.0V ：代表核心电压S1 ：代表CPU的架构，S1=Slot 1Abcde：规格号abcdefgh-0123 ：序列号,其中第一位代表产地.0=Costa Rica(哥斯达黎加),1=Philippines(菲律宾),9=Malaysia(马来西亚),Y=Ireland(爱尔兰)）接下来两位是代表第多少周生产。
PIII Coppermine的编号格式：RaaaaaHZmmmkkkEC abcde abcdefgh-0123R ：R=Socket 370架构Aaaaa ：代表采用的核心。
80525=Katmai核心,80526=Coppermine核心HZ ：代表CPU的外频Mmm ：代表CPU的工作频率HzKkk ：代表CPU二级缓存容量EC ：代表ECC纠错Abcde：规格号abcdefgh-0123 ：同PIII ConfidentialCeleron编号格式：FV524RX mmmkkk ABCDE XXXXX L01234567-1234FV524RX：保留Mmm ：代表CPU工作频率Kkk ：代表二级缓存的容量ABCDE ：规格号XXXXX：产地，MALAY=马来西亚，COSTA RICA=哥斯达黎加L01234567-1234 ：其中第一个L代表产地（0=Costa Rica(哥斯达黎加)，1和9= Malaysia(马来西亚)）；接下来的123代表第多少周生产Celeron II编号的识别方法与PIII Coppermine相同Intel PII编号格式：W8065xhzmmmkkkEC ABCDE abcdefgh-0123W ：代表出售对象,x=零售商,空项=OEM厂商8065 ：保留x ：代表采用的核心,2=Klamath核心即0.35微米制造工艺,3= Deschutes核心即0.25微米制造工艺hz ：代表采用的外频mmm：表处理器的工作频率kkk ：代表二级缓存的容量EC ：代表ECC纠错ABCDE ：规格号abcdefgh-0123 ：其中第一位代表产地，0=Costa Rica(哥斯达黎加)，1=Philippines(菲律宾)，9=Malaysia(马来西亚)，Y=Ireland(爱尔兰)）；接下来的两位代表第多少周生产。
计算机学院计算机科学与技术专业《计算机组成原理课程设计》报告（2008/2009学年第一学期）学生姓名：闫全胜学生班级：计算机062202H学生学号： 200620030227指导教师：康葆荣2009年1月3日目录1 关于此次课程设计 (2)1.1 设计的目的： (2)1.2 设计内容及要求： (2)2 分析阶段 (3)2.1指令译码电路分析 (3)2.2 寄存器译码电路分析 (4)2.3 微指令格式分析 (5)2.4 时序分析 (6)3 初步设计阶段 (7)3.1 数据格式 (7)3.2指令描述 (7)3.3 存储器分区 (9)3.4 控制台微程序流程： (10)3.5 运行微程序 (11)4 详细设计阶段 (12)4.1控制台流程分解 (12)4.2 运行微程序子流程 (15)4.3 微程序总流程图 (24)5 实现阶段 (25)5.1 所用模型机数据通路的介绍 (25)5.2 微程序代码设计与编写 (26)微程序二进制代码表 (26)5.3 机器指令的输入及运行 (28)心得体会 (30)参考资料 (31)1 关于此次课程设计1.1 设计的目的：本课程设计是计算机科学与技术专业重要的实践性教学环节之一，是在学生学习完《计算机组成原理》课程后进行的一次全面的综合设计。
目的是通过一个完整的8位指令系统结构（ISA）的设计和实现，加深对计算机组成原理课程内容的理解，建立起整机系统的概念，掌握计算机设计的基本方法，培养学生科学的工作作风和分析、解决实际问题的工作能力。
1.2 设计内容及要求：基于TDN-CM++计算机组成原理实验教学系统，设计和实现一个8位指令系统结构（ISA），通过调试和运行，使设计的计算机系统能够完成指定的功能。
设计过程中要求考虑到以下各方面的问题：1、指令系统风格（寄存器-寄存器，寄存器-存储器，存储器-存储器）；2、数据类型（无符号数，有符号数，整型，浮点型）；3、存储器划分（指令，数据）；4、寻址方式（立即数寻址，寄存器寻址，直接寻址等）；5、指令格式（单字节，双字节，多字节）；6、指令功能类别（算术／逻辑运算，存储器访问，寄存器操作，程序流控制，输入／输出）；7、依据CPI值对指令系统进行性能分析。
CPU实验报告一.设计概况本次试验要完成的工作主要包括：指令系统的设计，CPU的整体结构设计及其细化，逻辑设计的具体实现，软件模拟，硬件调试。
试验的主要流程如下图所示：二.指令设计1.指令格式设计①单操作数指令OPCODE 000 X包括：JMP,JZ,JC②寄存器-寄存器指令OPCODE REG1 00000 REG2 包括：MOV,ADC,SBB,OR,AND③寄存器-立即数（地址）指令OPCODE REG DA TA包括：LDA,STA,MOV, ADC,SBB,OR,AND④其他类型指令OPCODE 00000000000包括：CLC,STC2.指令编码三.CPU逻辑设计1.CPU整体框图2.节拍设计一个周期采用四个节拍。
一个节拍完成取指。
第二个节拍完成运算。
第三个节拍访存。
第四个节拍回写。
3.数据流说明第一个节拍内，取指模块向访存控制发出访存信号，得到指令后，将指令保存在指令寄存器IR中，并将指令送往后面的运算模块，存储管理模块，回写模块。
同时将PC送入运算模块和回写模块。
第二个节拍内，运算管理模块将指令译码。
如果是存数指令，则将地址存入ADDR寄存器，数据存入DATA存储器，等待下一个节拍访存。
如果是取数指令，则将地址存入ADDR寄存器，等待下一个节拍访存。
如果是其他非访存指令，则将计算结果存入ALUOUT寄存器，送往存储管理模块的Rtemp寄存器。
第三个节拍内，存储管理模块将指令译码。
如果是存数指令，则向访存控制模块发出访存信号，则将第二个节拍内存好的ADDR寄存器的内容作为地址，把DATA寄存器里面的数据存入存储器对应的位置。
如果是取数指令，则将第二个节拍内存好的ADDR寄存器的内容作为地址，从存储器对应的位置取出数据，存入Rtemp存储器，并送往回写模块。
如果是其他非访存指令，则将Rtemp寄存器里的内容直接送往回写模块。
第四个节拍内，回写模块先将指令译码。
根据指令将需要回写的数据回写近响应的寄存器，并将PC+1后回写至取指模块的PC寄存器。
【基础知识】CPU指令集计算机指令就是指挥机器⼯作的指⽰和命令，程序就是⼀系列按⼀定顺序排列的指令，执⾏程序的过程就是计算机的⼯作过程。
指令集，就是CPU中⽤来计算和控制计算机系统的⼀套指令的集合，⽽每⼀种新型的CPU在设计时就规定了⼀系列与其他硬件电路相配合的指令系统。
⽽指令集的先进与否，也关系到CPU的性能发挥，它也是CPU性能体现的⼀个重要标志。
每款CPU在设计时就规定了⼀系列与其硬件电路相配合的指令系统。
指令的强弱也是CPU的重要指标，指令集是提⾼微处理器效率的最有效的⼯具之⼀。
从现阶段的主流体系结构讲，指令集可分为和两部分 [1]。
简介在计算机中，指⽰计算机硬件执⾏某种运算、处理功能的命令称为指令。
指令是计算机运⾏的最⼩的功能单位，⽽硬件的作⽤是完成每条指令规定的功能。
⼀台计算机上全部指令的集合，就是这台计算机的指令系统。
指令系统也称指令集，是这台计算机全部功能的体现。
⽽⼈们设计计算机⾸要考虑的是它拥有的功能，也就是⾸先要按功能档次设计指令集，然后按指令集的要求在硬件上实现。
指令系统不仅仅是指令的集合，还包括全部指令的指令格式、寻址⽅式和数据形式。
所以，各计算机执⾏的指令系统不仅决定了机器所要求的能⼒，⽽且也决定了指令的格式和机器的结构。
反过来说，不同结构的机器和不同的指令格式应该具有与之相匹配的指令系统。
为此，设计指令系统时，要对指令格式、类型及操作功能给予应有的重视。
软件是为了使⽤计算机⽽编写的各种系统和⽤户的程序，程序由⼀个序列的计算机指令组成。
从这个⾓度上说，指令是⽤于设计程序的⼀种计算机语⾔单位 [2]。
计算机的指令系统是指⼀台计算机上全部指令的集合，也称计算机的指令集。
指令系统包括指令格式、寻址⽅式和数据形式。
⼀台计算机的指令系统反映了该计算机的全部功能，机器类型不同，其指令系统也不同，因⽽功能也不同。
指令系统的设置和机器的硬件结构密切相关，⼀台计算机要有较好的性能，必须设计功能齐全、通⽤性强、内含丰富的指令系统，这就需要复杂的硬件结构来⽀持 [2]。
CPU指令集cpu作为一台电脑中的核心，它的作用是无法替代的。
而cpu本身只是在块硅晶片上所集成的超大规模的集成电路，集成的晶体管数量可达到上亿个，是由非常先进复杂的制造工艺制造出来的，拥有相当高的科技含量。
CPU依靠指令来计算和控制系统，每款CPU在设计时就规定了一系列与其硬件电路相配合的指令系统。
指令的强弱也是CPU的重要指标，指令集是提高微处理器效率的最有效工具之一。
从现阶段的主流体系结构讲，指令集可分为复杂指令集和精简指令集两部分，而从具体运用看，如Intel的MMX（Multi Media Extended）、SSE、SSE2（Streaming-Single inst ruction multiple data-Extensions 2）和AMD的3DNow!等都是CPU的扩展指令集，分别增强了CPU的多媒体、图形图象和Internet等的处理能力。
我们通常会把CPU的扩展指令集称为"CPU的指令集"。
然而如此一颗精密的芯片为什么能够控制一个庞大而复杂的电脑系统呢？这就是cpu中所集成的指令集。
所谓指令集，就是cpu中用来计算和控制计算机系统的一套指令的集合，而每一种新型的cpu在设计时就规定了一系列与其他硬件电路相配合的指令系统。
而指令集的先进与否，也关系到cpu的性能发挥，它也是cpu性能体现的一个重要标志。
再强大的处理器也需要指令集的配合才行cpu的指令集从主流的体系结构上分为精简指令集和复杂指令集，而在普通的计算机处理器基本上是使用的复杂指令集。
在计算机早期的发展过程中，cpu中的指令集是没有划分类型的，而是都将各种程序需要相配合的指令集成到cpu中，但是随着科技的进步，计算机的功能也越来越强大，计算机内部的元件也越来越多，而且越来越复杂，cpu的指令也相应的变得十分复杂，而在使用过程中，并不是每一条指令都要完全被执行，在技术人员的研究过程中发现，约有80％的程序只用到了20％的指令，而一些过于冗余的指令严重影响到了计算机的工作效率，就这一现象，精简指令集的概念就被提了出来。
代码一．顶层模块module MIPS_C(clk,rst,MIPS_out);input clk,rst;output [7:0]MIPS_out;wire [31:0]ALU_DC;wire [31:0]Pc_out;wire [5:0]op;wire [5:0]func;wire ALUSrcA;wire ALUSrcB;//wire Load_Mem;wire MemtoReg;wire RegDst;wire ExtOp;//wire MemWr;wire RegWr;wire [31:0]instruct;wire PcWrite;wire [31:0]imm32;wire [15:0]imm16;wire [25:0]target;wire [31:0]rdata2;wire [31:0]rdata1;wire [31:0]rdata3;wire ALU_CLK;wire [31:0]Mem_Dout;wire [4:0]rt;wire [4:0]rd;wire [4:0]rs;wire [31:0]ALU_DB;wire [31:0]ALU_DA;wire [31:0]wdata;wire [4:0]waddr;wire Branch;wire Jump;wire [31:0]Mem_Din;wire ALU_OverFlow;wire ALU_ZERO;wire [4:0]shamt;wire [4:0]ALU_SHIFT;assign MIPS_out=rdata3[7:0];Main_control main_control(.rst(rst),.op(op),.ALUSrcA(ALUSrcA),.ALUSrcB(ALUSrcB),.MemtoReg(MemtoReg),.RegDst(RegDst),.ExtOp(ExtOp),.PcWrite(PcWrite),.RegWr(RegWr),.clk(clk));Fetch_top fetch_top(.clk(clk),.rst(rst),.instruct(instruct),.ALU_DA(ALU_DA),.Jump(Jump),.Branch(Branch),.PcWrite(PcWrite),.ALU_DB(ALU_DB),.Pc_out(Pc_out));decode Decode(.instruct(instruct),.op(op),.rs(rs),.rt(rt),.rd(rd),.func(func),.shamt(shamt),.imm16(imm16),.target(target));regfile Regfile (.clk(clk),.rst(rst),.RegWr(RegWr),.waddr(waddr),.wdata(wdata),.raddr1(rs),.rdata1(rdata1),.raddr2(rt),.rdata2(rdata2) ,.rdata3(rdata3));/*Memory mem ( .Mem_Adr(Mem_Adr),.MemWr(MemWr),.rst(rst),.clk(clk),.Mem_Din(rdata2),.Mem_Dout(Mem_Dout));*/Imm imm( .rst(rst),.imm16(imm16),.ExtOp(ExtOp),.imm32(imm32));flag Flag(.ALU_DA(ALU_DA),.ALU_DB(ALU_DB),.op(op),.func(func),.Jump(Jump),.Branch(Branch));ALU_top alu_top ( .ALU_CLK(clk),.rst(rst),.func(func),.op(op),.ALU_DA(ALU_DA),.ALU_DB(ALU_DB),.ALU_SHIFT(shamt),.ALU_ZERO(ALU_ZERO),.ALU_OverFlow(ALU_OverFlow),.ALU_DC(ALU_DC));data_select DATA_select(.ALUSrcA(ALUSrcA),.ALUSrcB(ALUSrcB),.MemtoReg(MemtoReg),.RegDst(RegDst),.imm32(imm32),.target(target),.rdata2(rdata2),.rdata1(rdata1),.ALU_DC(ALU_DC),.Mem_Dout(Mem_Dout),.rt(rt),.rd(rd),.ALU_DB(ALU_DB),.ALU_DA(ALU_DA),.wdata(wdata),.waddr(waddr));endmodule二．主控模块module Main_control(clk,rst,op,ALUSrcA,ALUSrcB,MemtoReg,RegDst,ExtOp,PcWrite,RegWr);input clk,rst;input [5:0]op;output reg ALUSrcA;output reg ALUSrcB;output reg MemtoReg;output reg RegDst;output reg ExtOp;output reg RegWr;output reg PcWrite;reg [3:0]state;reg [3:0]next_state;parameterState_IR = 4'b0000,//fetch adderState_decode = 4'b0001, //decodeState_MemCalc= 4'b0010,//store calculate adderState_MemRD = 4'b0011 , //read MemState_MemRDend= 4'b0100 , //read Mem finishState_MemWr = 4'b0101 ,//write MEmState_R = 4'b0110,//RzhixingState_Rend = 4'b0111,//RfinishState_B = 4'b1000,//BzhixingState_J = 4'b1001;//jzhilingalways@(posedge clk or posedge rst)beginif(rst)state <= 4'b0000;elsestate <=next_state;endalways@(*)begincase(state)4'b0000: beginnext_state<=4'b0001;end4'b0001: beginnext_state[3]<=((~op[5])&(~op[4])&(~op[3])&op[2]&(~op[1])&op[0]) |(op[5])&(~op[4])&(op[3])&(~op[2])&(~op[1])&(~op[0]);next_state[2]<=(~op[5])&(~op[4])&(~op[3])&(~op[2])&(~op[1])&(~op[0]);next_state[1]<=(~op[5])&(~op[4])&(~op[3])&(~op[2])&(~op[1])&(~op[0]) |(op[5])&(~op[4])&(~op[3])&(~op[2])&(op[1])&(op[0])|(op[5])&(~op[4])&(op[3])&(~op[2])&(op[1])&(op[0]);next_state[0]<=(op[5]&(~op[4])&op[3]&(~op[2])&(~op[1])&(~op[0]));end/*4'b0010:beginnext_state<=4'b0011;end*/4'b0010:beginnext_state[3]<=1'b0;next_state[2]<=op[5]&(~op[4])&(~op[3])&(~op[2])&op[1]&op[0];next_state[1]<=(op[5])&(~op[4])&(op[3])&(~op[2])&(op[1])&(op[0]);next_state[0]<=1'b1;end4'b0011:beginnext_state<=4'b0100;end4'b0100:beginnext_state<=4'b0000;end4'b0101:beginnext_state<=4'b0000;end4'b0110:beginnext_state<=4'b0111;end4'b0111:beginnext_state<=4'b0000;end4'b1000:beginnext_state<=4'b0000;end4'b1001:beginnext_state<=4'b0000;endendcaseendalways@(posedge clk)begincase(state)4'b0000: beginALUSrcA<=0;ALUSrcB<=1;//Load_Mem<=0;MemtoReg<=0;RegDst<=0;ExtOp<=1;//MemWr<=0;RegWr<=0;PcWrite<=1;end4'b0001: beginALUSrcA<=0;ALUSrcB<=1;//Load_Mem<=0;MemtoReg<=0;RegDst<=0;ExtOp<=0;//MemWr<=0;RegWr<=0;PcWrite<=0;end4'b0010: beginALUSrcA<=0;ALUSrcB<=1;//Load_Mem<=1;MemtoReg<=1;RegDst<=0;ExtOp<=1;//MemWr<=0;RegWr<=0;PcWrite<=0;end4'b0011: beginALUSrcA<=0;ALUSrcB<=0;//Load_Mem<=1;MemtoReg<=1;RegDst<=0;ExtOp<=0;//MemWr<=0;RegWr<=0;PcWrite<=0;end4'b0100: beginALUSrcA<=0;ALUSrcB<=0;//Load_Mem<=0;MemtoReg<=0;RegDst<=0;ExtOp<=0;//MemWr<=0;RegWr<=1;PcWrite<=0;end4'b0101:beginALUSrcA<=0;ALUSrcB<=1;//Load_Mem<=1;MemtoReg<=0;RegDst<=0;ExtOp<=0;//MemWr<=1;RegWr<=1;PcWrite<=0;end4'b0110: beginALUSrcA<=0;ALUSrcB<=0;//Load_Mem<=0;MemtoReg<=0;RegDst<=1;ExtOp<=0;//MemWr<=0;RegWr<=0;PcWrite<=0;end4'b0111: beginALUSrcA<=0;ALUSrcB<=0;//Load_Mem<=0;MemtoReg<=1;RegDst<=1;ExtOp<=0;//MemWr<=0;RegWr<=1;PcWrite<=0;end4'b1000: beginALUSrcA<=0;ALUSrcB<=1;//Load_Mem<=0;MemtoReg<=0;RegDst<=0;ExtOp<=1;//MemWr<=0;RegWr<=0;PcWrite<=1;end4'b1001: beginALUSrcA<=1;ALUSrcB<=0;//Load_Mem<=0;MemtoReg<=0;RegDst<=0;ExtOp<=0;//MemWr<=0;RegWr<=0;PcWrite<=0;endendcaseendendmodule三．取指模块（1）顶层module Fetch_top(clk,rst,instruct,ALU_DA,Jump,Branch,PcWrite,ALU_DB,Pc_out );input clk,rst;input [31:0]ALU_DA;input Jump,Branch,PcWrite;input [31:0]ALU_DB;output[31:0] instruct;output [31:0]Pc_out;fetch FETCH(.Pc_out(Pc_out),.instruct(instruct));pc PC(.rst(rst),.ALU_DA(ALU_DA),.Jump(Jump),.Branch(Branch),.Pc_out(Pc_out),.ALU_DB(ALU_DB),.PcWrite(PcWrite));endmodule(2)取指module fetch(Pc_out,instruct);input[31:0]Pc_out;output [31:0]instruct;wire [31:0]store[0:31];assign store[32'h00] = 32'b000000_00001_00000_00011_00000_100000;//jiaassign store[32'h01] = 32'b000000_00001_00000_00011_00000_100000;//jiaassign store[32'h02] = 32'b000000_00111_00110_00111_00000_100010; //减一assign store[32'h03] = 32'b000101_00111_00000_00000_00000_000001;//不等跳转assign store[32'h04] = 32'b000000_00011_00100_00011_00000_100000;//jiaassign store[32'h05] = 32'b000000_01000_00110_00111_00000_100010; //减一assign store[32'h06] = 32'b000101_00111_00000_00000_00000_000001;//不等跳转assign store[32'h07] = 32'b000000_00101_00010_00011_00000_100000;//jiaassign store[32'h08] = 32'b000000_00111_00110_00111_00000_100010; //减一assign store[32'h09] = 32'b000101_00111_00000_00000_00000_000001;//不等跳转assign store[32'hA] = 32'b000000_00011_00010_00011_00000_100101; // huofei assign store[32'h0B] = 32'b000000_01000_00110_00111_00000_100010; //减一assign store[32'h0C] = 32'b000101_00111_00000_00000_00000_000001;//不等跳转assign store[32'h0D] = 32'b101000_00000_00000_00000_00000_000000;// assign instruct = store[Pc_out];endmodule（3）程序计数器module pc(rst,Jump,Branch,Pc_out,ALU_DA,PcWrite,ALU_DB);input [31:0]ALU_DA;input [31:0]ALU_DB;input Jump,Branch,rst,PcWrite;output reg [31:0]Pc_out;always@(posedge PcWrite)beginif(rst)Pc_out<=32'h00;elseif(PcWrite)beginif (Jump)Pc_out<=ALU_DA;else if (Branch)Pc_out<=Pc_out-ALU_DB;elsePc_out<=Pc_out+1;endelsePc_out<=Pc_out;endendmodule四．译码模块module decode(instruct,op,rs,rt,rd,func,shamt,imm16,target);input [31:0]instruct;output reg [5:0]op;output reg[4:0]rs,rt,rd;output reg[4:0]shamt;output reg[5:0]func;output reg[15:0]imm16;output reg [25:0]target;always@(*)beginop[5:0]=instruct[31:26];rs[4:0]=instruct[25:21];rt[4:0]=instruct[20:16];rd[4:0]=instruct[15:11];shamt[4:0]=instruct[10:6];func[5:0]=instruct[5:0];imm16[15:0]=instruct[15:0];target[25:0]=instruct[25:0];endendmodule五．寄存器模块module regfile(input clk,input rst,input RegWr,input[4:0]waddr,input[31:0]wdata,input[4:0]raddr1,output[31:0] rdata1,input[4:0]raddr2,output[31:0] rdata2,output[31:0] rdata3);reg[31:0] regs[0:8];//Write operationalways @ (posedge clk or posedge rst) beginif(rst)beginregs[0]<=32'b0;regs[1]<=32'b00000000_00000000_00000000_00001100;regs[2]<=32'b00000000_00000000_00000000_00000000;regs[3]<=32'b0;regs[4]<=32'b00000000_00000000_00000000_11000000;regs[5]<=32'b00000000_00000000_00000000_11100111;//regs[6]<=32'b00000000_00000000_00000000_00000010;regs[6]<=32'b00000000_01011111_01111000_01000000;//0.5 //regs[7]<=32'b00000000_00000000_00000000_00000001;regs[7]<=32'b00000010_11111010_11110000_10000000;//1 //regs[8]<=32'b00000000_00000000_00000000_00000011;regs[8]<=32'b00011111_01001010_11011101_01000000;//10.5endelse beginif((RegWr== 1'b1) && (waddr != 5'h0)) beginregs[waddr] <= wdata;endendend//Read port1 operationassign rdata1 = (raddr1 == 5'd0) ? 32'd0 : regs[raddr1];//Read port2 operationassign rdata2 = (raddr2 == 5'd0) ? 32'd0 : regs[raddr2];assign rdata3 = regs[3];endmodule六．立即数扩展块module Imm(rst,imm16,ExtOp,imm32);input rst;input ExtOp;input [15:0]imm16;output [31:0]imm32;reg[31:0] bus1;always@(*)if(rst)bus1<=32'b0;elseif(imm16[15]==0)beginbus1[31:16]<=16'b0000_0000_0000_0000;bus1[15:0]<=imm16[15:0];endelse if(imm16[15]==1)beginbus1[31:16]<=16'b1111_1111_1111_1111;bus1[15:0]<=imm16[15:0];endassign imm32 = (ExtOp==1)?bus1:imm32;endmodule七．部分控制信号产生块module flag(ALU_DA,ALU_DB,op,func,Jump,Branch);input [31:0]ALU_DB;input [31:0]ALU_DA;input [5:0]op;input [5:0]func;output reg Jump;output reg Branch;always@(*)beginif(op==6'b101000)Jump<=1;elseJump<=0;endalways@(*)case(op)6'b000100:beginif(ALU_DA==ALU_DB)Branch<=1;elseBranch<=0;end6'b000101:beginif(ALU_DA==ALU_DB)Branch<=0;elseBranch<=1;enddefault Branch<=0;endcaseendmodule八．逻辑运算模块（1）顶层模块moduleALU_top(ALU_CLK,rst,func,op,ALU_DA,ALU_DB,ALU_SHIFT,ALU_ZERO,ALU_OverFlow,ALU_DC );input ALU_CLK;input rst;input [5:0]func;input[5:0]op;input [31:0]ALU_DA;input [31:0]ALU_DB;input [4:0]ALU_SHIFT;output ALU_ZERO;output ALU_OverFlow;output [31:0] ALU_DC;wire[3:0] ALU_ctr;wire [3:0]alu_clt;ALU_control alu_control(.ALU_CLK(ALU_CLK),.rst(rst),.func(func),.op(op),.ALU_ctr(ALU_ctr));ALU alu (.ALU_DA(ALU_DA),.ALU_DB(ALU_DB),.alu_clt(ALU_ctr),.alu_shift(ALU_SHIFT),.ALU_Zero(ALU_ZERO),.Alu_Overflow(ALU_OverFlow),.ALU_Dout(ALU_DC));endmodule(2)运算控制块module ALU_control(ALU_CLK,rst,func,op,ALU_ctr);input rst,ALU_CLK;input [5:0]op;input [5:0]func;output reg[3:0]ALU_ctr;reg [3:0]ins;always@(*)if(op==6'b0)case(func)6'b000010:ins[3:0]<=4'b0000;6'b100000:ins[3:0]<=4'b0001;6'b000111:ins[3:0]<=4'b0010;6'b100101:ins[3:0]<=4'b0011;6'b000100:ins[3:0]<=4'b0100;6'b000001:ins[3:0]<=4'b0101;6'b000110:ins[3:0]<=4'b0110;6'b001000:ins[3:0]<=4'b0111;6'b001001:ins[3:0]<=4'b1111;6'b000101:ins[3:0]<=4'b1101;6'b001010:ins[3:0]<=4'b1110;endcaseelse case(op)6'b001000:ins[3:0]<=4'b0001;6'b001001:ins[3:0]<=4'b0000;6'b001100:ins[3:0]<=4'b0101;6'b001101:ins[3:0]<=4'b0100;6'b100011:ins[3:0]<=4'b0001;6'b101011:ins[3:0]<=4'b0001;6'b001010:ins[3:0]<=4'b0111;6'b001011:ins[3:0]<=4'b0110;6'b000100:ins[3:0]<=4'b0100;6'b000101:ins[3:0]<=4'b0100;endcasealways@(posedge ALU_CLK)if(rst)ALU_ctr<=4'b0;elseALU_ctr[3:0]<=ins[3:0];endmodule(3)运算模块module ALU(ALU_DA,ALU_DB,alu_clt,alu_shift,ALU_Zero,Alu_Overflow,ALU_Dout);input [31:0] ALU_DA;input [31:0] ALU_DB;input [3:0] alu_clt;input [4:0] alu_shift;output ALU_Zero;output Alu_Overflow;output [31:0] ALU_Dout;reg [31:0] ALU_Dout;wire [1:0] OPctr;wire SUBctr;wire ANDctr;wire OVctr;wire SIGctr;reg [31:0] SLL_M,SRL_M,SRA_M;assign SUBctr = alu_clt[2];assign ANDctr = alu_clt[0];assign OVctr = !alu_clt[1]&alu_clt[0];assign SIGctr = alu_clt[0];assign OPctr[1] = alu_clt[2]&alu_clt[1]|alu_clt[3];assign OPctr[0] = alu_clt[1];always@(*)begincase(alu_shift)5'b00000:SRL_M[31:0]=ALU_DB[31:0];5'b00001:SRL_M[31:0]={1'b0,ALU_DB[31:1]};5'b00010:SRL_M[31:0]={2'b0,ALU_DB[31:2]};5'b00011:SRL_M[31:0]={3'b0,ALU_DB[31:3]};5'b00100:SRL_M[31:0]={4'b0,ALU_DB[31:4]};5'b00101:SRL_M[31:0]={5'b0,ALU_DB[31:5]};5'b00110:SRL_M[31:0]={6'b0,ALU_DB[31:6]};5'b00111:SRL_M[31:0]={7'b0,ALU_DB[31:7]};5'b01000:SRL_M[31:0]={8'b0,ALU_DB[31:8]};5'b01010:SRL_M[31:0]={10'b0,ALU_DB[31:10]};5'b01011:SRL_M[31:0]={11'b0,ALU_DB[31:11]};5'b01100:SRL_M[31:0]={12'b0,ALU_DB[31:12]};5'b01101:SRL_M[31:0]={13'b0,ALU_DB[31:13]};5'b01110:SRL_M[31:0]={14'b0,ALU_DB[31:14]};5'b01111:SRL_M[31:0]={15'b0,ALU_DB[31:15]};5'b10000:SRL_M[31:0]={16'b0,ALU_DB[31:16]};5'b10001:SRL_M[31:0]={17'b0,ALU_DB[31:17]};5'b10010:SRL_M[31:0]={18'b0,ALU_DB[31:18]};5'b10011:SRL_M[31:0]={19'b0,ALU_DB[31:19]};5'b10100:SRL_M[31:0]={20'b0,ALU_DB[31:20]};5'b10101:SRL_M[31:0]={21'b0,ALU_DB[31:21]};5'b10110:SRL_M[31:0]={22'b0,ALU_DB[31:22]};5'b10111:SRL_M[31:0]={23'b0,ALU_DB[31:23]};5'b11000:SRL_M[31:0]={24'b0,ALU_DB[31:24]};5'b11001:SRL_M[31:0]={25'b0,ALU_DB[31:25]};5'b11010:SRL_M[31:0]={26'b0,ALU_DB[31:26]};5'b11011:SRL_M[31:0]={27'b0,ALU_DB[31:27]};5'b11100:SRL_M[31:0]={28'b0,ALU_DB[31:28]};5'b11101:SRL_M[31:0]={29'b0,ALU_DB[31:29]};5'b11110:SRL_M[31:0]={30'b0,ALU_DB[31:30]};5'b11111:SRL_M[31:0]={31'b0,ALU_DB[31]};default: SRL_M[31:0]=ALU_DB[31:0]; endcaseendalways@(*)begincase(alu_shift)5'b00000:SLL_M[31:0]=ALU_DB[31:0];5'b00001:SLL_M[31:0]={ALU_DB[30:0],1'b0};5'b00010:SLL_M[31:0]={ALU_DB[29:0],2'b0};5'b00011:SLL_M[31:0]={ALU_DB[31:3],3'b0};5'b00100:SLL_M[31:0]={ALU_DB[31:4],4'b0};5'b00101:SLL_M[31:0]={ALU_DB[31:5],5'b0};5'b00110:SLL_M[31:0]={ALU_DB[31:6],6'b0};5'b00111:SLL_M[31:0]={ALU_DB[31:7],7'b0};5'b01000:SLL_M[31:0]={ALU_DB[31:8],8'b0};5'b01001:SLL_M[31:0]={ALU_DB[31:9],9'b0};5'b01010:SLL_M[31:0]={ALU_DB[31:10],10'b0};5'b01011:SLL_M[31:0]={ALU_DB[31:11],11'b0};5'b01100:SLL_M[31:0]={ALU_DB[31:12],12'b0};5'b01110:SLL_M[31:0]={ALU_DB[31:14],14'b0};5'b01111:SLL_M[31:0]={ALU_DB[31:15],15'b0};5'b10000:SLL_M[31:0]={ALU_DB[31:16],16'b0};5'b10001:SLL_M[31:0]={ALU_DB[31:17],17'b0};5'b10010:SLL_M[31:0]={ALU_DB[31:18],18'b0};5'b10011:SLL_M[31:0]={ALU_DB[31:19],19'b0};5'b10100:SLL_M[31:0]={ALU_DB[31:20],20'b0};5'b10101:SLL_M[31:0]={ALU_DB[31:21],21'b0};5'b10110:SLL_M[31:0]={ALU_DB[31:22],22'b0};5'b10111:SLL_M[31:0]={ALU_DB[31:23],23'b0};5'b11000:SLL_M[31:0]={ALU_DB[31:24],24'b0};5'b11001:SLL_M[31:0]={ALU_DB[31:25],25'b0};5'b11010:SLL_M[31:0]={ALU_DB[31:26],26'b0};5'b11011:SLL_M[31:0]={ALU_DB[31:27],27'b0};5'b11100:SLL_M[31:0]={ALU_DB[31:28],28'b0};5'b11101:SLL_M[31:0]={ALU_DB[31:29],29'b0};5'b11110:SLL_M[31:0]={ALU_DB[31:30],30'b0};5'b11111:SLL_M[31:0]={ALU_DB[0],31'b0};default: SLL_M[31:0]=ALU_DB[31:0];endcaseendalways@(*)begincase(alu_shift)5'b00000:SRA_M[31:0]=ALU_DB[31:0];5'b00001:SRA_M[31:0]={{1{ALU_DB[31]}},ALU_DB[31:1]};5'b00010:SRA_M[31:0]={{2{ALU_DB[31]}},ALU_DB[31:2]};5'b00011:SRA_M[31:0]={{3{ALU_DB[31]}},ALU_DB[31:3]};5'b00100:SRA_M[31:0]={{4{ALU_DB[31]}},ALU_DB[31:4]};5'b00101:SRA_M[31:0]={{5{ALU_DB[31]}},ALU_DB[31:5]};5'b00110:SRA_M[31:0]={{6{ALU_DB[31]}},ALU_DB[31:6]};5'b00111:SRA_M[31:0]={{7{ALU_DB[31]}},ALU_DB[31:7]};5'b01000:SRA_M[31:0]={{8{ALU_DB[31]}},ALU_DB[31:8]};5'b01001:SRA_M[31:0]={{9{ALU_DB[31]}},ALU_DB[31:9]};5'b01010:SRA_M[31:0]={{10{ALU_DB[31]}},ALU_DB[31:10]};5'b01011:SRA_M[31:0]={{11{ALU_DB[31]}},ALU_DB[31:11]};5'b01100:SRA_M[31:0]={{12{ALU_DB[31]}},ALU_DB[31:12]};5'b01101:SRA_M[31:0]={{13{ALU_DB[31]}},ALU_DB[31:13]};5'b01110:SRA_M[31:0]={{14{ALU_DB[31]}},ALU_DB[31:14]};5'b01111:SRA_M[31:0]={{15{ALU_DB[31]}},ALU_DB[31:15]};5'b10000:SRA_M[31:0]={{16{ALU_DB[31]}},ALU_DB[31:16]};5'b10001:SRA_M[31:0]={{17{ALU_DB[31]}},ALU_DB[31:17]};5'b10010:SRA_M[31:0]={{18{ALU_DB[31]}},ALU_DB[31:18]};5'b10011:SRA_M[31:0]={{19{ALU_DB[31]}},ALU_DB[31:19]};5'b10100:SRA_M[31:0]={{20{ALU_DB[31]}},ALU_DB[31:20]};5'b10101:SRA_M[31:0]={{21{ALU_DB[31]}},ALU_DB[31:21]};5'b10110:SRA_M[31:0]={{22{ALU_DB[31]}},ALU_DB[31:22]};5'b10111:SRA_M[31:0]={{23{ALU_DB[31]}},ALU_DB[31:23]};5'b11000:SRA_M[31:0]={{24{ALU_DB[31]}},ALU_DB[31:24]};5'b11001:SRA_M[31:0]={{25{ALU_DB[31]}},ALU_DB[31:25]};5'b11010:SRA_M[31:0]={{26{ALU_DB[31]}},ALU_DB[31:26]};5'b11011:SRA_M[31:0]={{27{ALU_DB[31]}},ALU_DB[31:27]};5'b11100:SRA_M[31:0]={{28{ALU_DB[31]}},ALU_DB[31:28]};5'b11101:SRA_M[31:0]={{29{ALU_DB[31]}},ALU_DB[31:29]};5'b11110:SRA_M[31:0]={{30{ALU_DB[31]}},ALU_DB[31:30]};5'b11111:SRA_M[31:0]={{31{ALU_DB[31]}},ALU_DB[31]};default: SRA_M[31:0]=ALU_DB[31:0];endcaseendreg [31:0] Soutput;wire [1:0] Sctr;assign Sctr={alu_clt[2],alu_clt[0]};always@(*)begincase(Sctr)3'b00:Soutput=SLL_M;3'b01:Soutput=SRL_M;3'b10:Soutput=SRA_M;default: Soutput=ALU_DB;endcaseend//AND OR logicwire [31:0] OR_M,AND_M,AND_OR_output;assign OR_M=~(ALU_DA | ALU_DB);assign AND_M=ALU_DA & ALU_DB;assign AND_OR_output=(ANDctr==1'b0)?AND_M:OR_M;//ADDERwire [31:0] BIT_M,XOR_M;assign BIT_M={32{SUBctr}};assign XOR_M=BIT_M^ALU_DB;wire ADD_carry,ADD_OverFlow;wire [31:0] ADD_result;assign {ADD_carry,ADD_result}=ALU_DA+XOR_M+SUBctr;assign ALU_Zero=~(|ADD_result);assign ADD_OverFlow = ((alu_clt==4'b0001) && (ALU_DA[31]==1'b0) && (ALU_DB[31]==1'b0) && (ADD_result[31]==1'b1))|| ((alu_clt==4'b0001) && (ALU_DA[31]==1'b1) && (ALU_DB[31]==1'b1) && (ADD_result[31]==1'b0))|| ((alu_clt==4'b0101) && (ALU_DA[31]==1'b1) && (ALU_DB[31]==1'b0) && (ADD_result[31]==1'b0))|| ((alu_clt==4'b0101) && (ALU_DA[31]==1'b0) && (ALU_DB[31]==1'b1) && (ADD_result[31]==1'b1));assign Alu_Overflow=ADD_OverFlow & OVctr;//SLTwire LESS_M1,LESS_M2,LESS_S,SLT_M;assign LESS_M1= ADD_carry ^ SUBctr;assign LESS_M2= ADD_OverFlow ^ ADD_result[31];assign LESS_S= (SIGctr==1'b0)?LESS_M1:LESS_M2;assign SLT_M= (LESS_S==1'b1)?32'hffffffff:32'h00000000;//RESULTalways@(*)begincase(OPctr)2'b00:ALU_Dout=ADD_result;2'b01:ALU_Dout=AND_OR_output;2'b11:ALU_Dout=SLT_M;2'b10:ALU_Dout=Soutput;endcaseendendmodule九．数据选择模块module data_select(ALUSrcA,ALUSrcB,MemtoReg,RegDst,imm32,target,rdata2,rdata1,ALU_DC,Mem_Dout,rt,rd,ALU_DB,ALU_DA,wdata,waddr);input ALUSrcA;input ALUSrcB;input MemtoReg;input RegDst;input [31:0]imm32;input [25:0]target;input [31:0]rdata2;input [31:0]rdata1;input [31:0]ALU_DC;input [31:0]Mem_Dout;input [4:0]rt;input [4:0]rd;output [31:0]ALU_DB;output [31:0]ALU_DA;output [31:0]wdata ;output [4:0]waddr;assign ALU_DB=(ALUSrcB==1)?imm32:rdata2;assign ALU_DA=(ALUSrcA==1)?{6'b000000,target}:rdata1; assign wdata = (MemtoReg==1)?ALU_DC:Mem_Dout; assign waddr = (RegDst==1)?rd:rt;endmodule十．仿真激励代码module MISP_tb;// Inputsreg clk;reg rst;// Outputswire [7:0] MIPS_out;// Instantiate the Unit Under Test (UUT)MIPS_C uut (.clk(clk),.rst(rst),.MIPS_out(MIPS_out));initial begin// Initialize Inputsclk = 0;rst = 0;#4;rst = 1;#9;rst = 0;// Add stimulus hereendalways #3 clk = ~clk;endmodule。
电脑代码一览表(总9页)--本页仅作为文档封面，使用时请直接删除即可----内页可以根据需求调整合适字体及大小--代码一览表1 0×00000001 不正确的函数。
2 0×00000002 系统找不到指定的档案。
3 0×00000003 系统找不到指定的路径。
4 0×00000004 系统无法开启档案。
5 0×00000005 拒绝存取。
6 0×00000006 无效的代码。
7 0×00000007 储存体控制区块已毁。
8 0×00000008 储存体空间不足,无法处理这个指令。
9 0×00000009 储存体控制区块地址无效。
10 0×0000000A 环境不正确。
11 0×0000000B 尝试加载一个格式错误的程序。
12 0×0000000C 存取码错误。
13 0×0000000D 资料错误。
14 0×0000000E 储存体空间不够,无法完成这项作业。
15 0×0000000F 系统找不到指定的磁盘驱动器。
16 0×00000010 无法移除目录。
17 0×00000011 系统无法将档案移到其它的磁盘驱动器。
18 0×00000012 没有任何档案。
19 0×00000013 储存媒体为写保护状态。
20 0×00000014 系统找不到指定的装置。
21 0×00000015 装置尚未就绪。
22 0×00000016 装置无法识别指令。
23 0×00000017 资料错误 (cyclic redundancy check)24 0×00000018 程序发出一个长度错误的指令。
25 0×00000019 磁盘驱动器在磁盘找不到持定的扇区或磁道。
IntelCPU的CPUID指令（三）本⽂主要介绍CPUID指令返回扩展信息的部分8、EAX=80000001h：最⼤扩展功能号mov eax, 80000001hcpuid该功能除了能够向（⼀）中介绍的那样返回CPU⽀持的最⼤扩展功能号外，并没有其它作⽤，EBX、ECX、EDX都不返回有意义的信息。
9、EAX=80000002h：返回CPU⽀持的扩展功能mov eax, 80000002hcpuid执⾏CPUID指令后，扩展功能标志在EDX和ECX中返回，EDX中的定义如下：Bit Name Description-------------------------------------------------------------------10:00 Reserved11 SYSCALL SYSCALL/SYSRET19:12 Reserved20 XD Bit Execution Disable Bit28:21 Reserved29 Intel? 64 Intel? 64 Instruction Set Architecture31:30 Reserved返回在ECX中的位定义：Bit Name Description-------------------------------------------------------------------0 LAHF LAHF / SAHF31:01 Reserved10、EAX=80000002h、80000003h、80000004h：返回处理器名称/商标字符串mov eax, 80000002hcpuid......mov eax, 80000003hcpuid......mov eax, 80000004hcpuid每次调⽤CPUID分别在EAX、EBX、ECX、EDX中返回16个ASCII字符，处理器名称/商标字串最多48个字符，前导字符为空格，结束字符为NULL，在寄存器中的排列顺序为little-endian（即低字符在前），下⾯程序可以在DOS下显⽰处理器名称/商标字串(使⽤MASM 6编译)。
cpu的基本指令（实用版）目录1.CPU 的基本指令概述2.CPU 的基本指令的类型3.CPU 的基本指令的应用4.CPU 的基本指令的发展趋势正文【1.CPU 的基本指令概述】CPU 的基本指令，也被称为机器指令，是计算机硬件能够直接识别和执行的指令。
它们是计算机程序员与计算机硬件之间的桥梁，通过这些指令，程序员可以告诉计算机如何执行各种任务。
CPU 的基本指令可以完成各种基本的操作，如数据传输、算术运算、逻辑运算、跳转等。
【2.CPU 的基本指令的类型】CPU 的基本指令主要分为以下几种类型：（1）数据传输指令：这类指令主要用于在寄存器和内存之间传输数据。
例如，将一个数值从寄存器 A 传输到寄存器 B 的指令。
（2）算术运算指令：这类指令主要用于完成各种算术运算，如加法、减法、乘法、除法等。
例如，将寄存器 A 中的数值与寄存器 B 中的数值相加，并将结果存储在寄存器 C 中的指令。
（3）逻辑运算指令：这类指令主要用于完成各种逻辑运算，如与、或、非、异或等。
例如，对寄存器 A 和寄存器 B 中的数值进行“与”运算，并将结果存储在寄存器 C 中的指令。
（4）跳转指令：这类指令主要用于改变程序的执行顺序。
例如，根据某个条件决定是否跳转到指定地址继续执行程序的指令。
（5）循环指令：这类指令主要用于实现循环操作。
例如，重复执行一段指令直到满足某个条件为止的指令。
【3.CPU 的基本指令的应用】CPU 的基本指令在各种计算机程序中都有广泛的应用。
例如，在编写一个简单的计算器程序时，需要使用数据传输指令将用户输入的数字存储到寄存器中，使用算术运算指令完成加法、减法等运算，使用逻辑运算指令判断运算结果的正负，使用跳转指令根据用户输入的选项决定程序的执行流程等。
【4.CPU 的基本指令的发展趋势】随着计算机技术的发展，CPU 的基本指令也在不断演变。
未来的 CPU 指令集可能会更加简洁、高效，以适应更高性能、更低功耗的计算需求。
时钟管理模块entity clk_ctrl isport(Clk:in std_logic;Rst:in std_logic;k:out std_logic_vector(3 downto 0));end clk_ctrl;architecture Behavioral of clk_ctrl issignal tmp:std_logic_vector(3 downto 0);beginprocess(Clk,Rst,tmp)beginif Rst ='1' then --rst=1复位;--k<="0000";tmp<="0001";elsif Clk='1' and Clk'event thentmp(0)<=tmp(3);tmp(3 downto 1)<=tmp(2 downto 0);end if;end process; k<=tmp;end Behavioral;取指模块entity irget isPort (Rst : in STD_LOGIC;--复位；Pcback : in STD_LOGIC_VECTOR (15 downto 0);--PC回写；Pcbacka : in STD_LOGIC;--PC回写允许；k1 : in STD_LOGIC;--时钟控制；Order : in STD_LOGIC_VECTOR (15 downto 0);--指令Pcout : out STD_LOGIC_VECTOR (15 downto 0);--PC输出；Orderout : out STD_LOGIC_VECTOR (15 downto 0);--指令输出；AddrFlag : out STD_LOGIC);--访址标志end irget;architecture Behavioral of irget issignal tmpPC: std_logic_vector (15 downto 0); --指令地址；signal IR:std_logic_vector(15 downto 0);--指令寄存器；beginprocess(Rst,Pcback,Pcbacka,k1,order,tmpPc)beginif Rst='1' thentmpPc<="0000000000000000";elsif k1='1' thenPcout<=tmpPc;AddrFlag<='1';--第一个节拍高电平取指；elsif Pcbacka='1' thentmpPc<=Pcback;--pc回写允许---end if;--AddrFlag<='0';else AddrFlag<='0';end if ;Orderout<=Order;--指令存入指令寄存器；end process;--Orderout<=IR;--得到指令，准备送往后面的模块；end Behavioral;运算模块entity CPU_operation isPort ( k2 : in STD_LOGIC;--时钟控制；k3 : in STD_LOGIC;--时钟控制；第三个时钟高电平改变标志寄存器的值；order : in STD_LOGIC_VECTOR (15 downto 0);--命令输入；Pcin:in STD_LOGIC_VECTOR(15 downto 0);--pc输入；Rst:in STD_LOGIC;--复??；Rwb : in STD_LOGIC_VECTOR (7 downto 0);--回写数据；Rwba : in STD_LOGIC;--回?丛市???高电平有效Aluout : out STD_LOGIC_VECTOR (15 downto 0);--计算结果输出；addr : out STD_LOGIC_VECTOR (15 downto 0)--内存?刂??);end CPU_operation;architecture Behavioral of CPU_operation istype reg is array(0 to 7) of std_logic_vector(7 downto 0);signal sreg:reg;signal F9:std_logic_vector(8 downto 0);--判断结果是否进位、是否为零；signal sregflag:std_logic_vector(1 downto 0);--标志寄存器；beginprocess(Rwb,Rwba,k2,order,sreg,Pcin,sregflag,F9)beginif Rwba='1' thensreg(conv_integer(order(10 downto 8)))<=Rwb;--回写end if;if Rst='1' thensreg(7)<="00000000";sreg(6)<="00000000";F9(8)<='0';end if;if k2='1' thencase order(15 downto 11) iswhen "00000"=>--mov Ri,ImAluout(7 downto 0)<=order(7 downto 0);Aluout(15 downto 8)<="11111111";when "00001"=>--LDA Ri,Xaddr(15 downto 8)<=sreg(7);addr(7 downto 0)<= order(7 downto 0);Aluout(15 downto 8)<="11111111";when "00010"=>--STA Ri,XAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8)));Aluout(15 downto 8)<="11111111";addr(7 downto 0)<=order(7 downto 0);addr(15 downto 8)<=sreg(7);when "00011"=>--mov Ri,RjAluout(7 downto 0)<=sreg(conv_integer(order(2 downto 0)));Aluout(15 downto 8)<="11111111";when "00100"=>--mov Ri,(Rj)addr(7 downto 0)<=sreg(conv_integer(order(2 downto 0)));addr(15 downto 8)<=sreg(7);when "00101"=>--mov Ri,[R7//R6+x]addr<= sreg(7)&sreg(6)+order(7 downto 0);when "00110"=>--Adc,Ri,ImAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8)))+order(7 downto 0)+sregflag(1);F9<=('0'&sreg(conv_integer(order(10 downto 8))))+('0'&order(7 downto 0));Aluout(15 downto 8)<="11111111";when "00111"=>--Adc,Ri,Rj,Ri+Rj+Cy->RiAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8)))+sreg(conv_integer(order(2 downto 0)))+sregflag(1);F9<=('0'&sreg(conv_integer(order(10 downto 8))))+('0'&order(7 downto 0));Aluout(15 downto 8)<="11111111";when "01000"=>--SBB Ri,ImAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8)))-order(7 downto 0)-sregflag(1);F9<=('0'&sreg(conv_integer(order(10 downto 8))))-('0'&order(7 downto 0));Aluout(15 downto 8)<="11111111";when "01001"=>--SBB Ri,Rj,Ri-Rj-Cy->RiAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8)))-sreg(conv_integer(order(2 downto 0)))-sregflag(1);F9<=('0'&sreg(conv_integer(order(10 downto 8))))-('0'& order(7 downto 0));Aluout(15 downto 8)<="11111111";when "01010"=>--AND Ri,ImAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8))) and order(7 downto 0);F9(7 downto 0)<=(sreg(conv_integer(order(10 downto 8))))and(order(7 downto 0));Aluout(15 downto 8)<="11111111";when "01011"=>--AND Ri,RjAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8))) and sreg(conv_integer(order(2 downto 0)));F9(7 downto 0)<=sreg(conv_integer(order(10 downto 8))) and order(7 downto 0);Aluout(15 downto 8)<="11111111";when "01100"=>--OR Ri,ImAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8))) or order(7 downto 0);F9(7 downto 0)<=(sreg(conv_integer(order(10 downto 8)))) or (order(7 downto 0));Aluout(15 downto 8)<="11111111";when "01101"=>--OR Ri,RjAluout(7 downto 0)<=sreg(conv_integer(order(10 downto 8))) or sreg(conv_integer(order(2 downto 0)));F9(7 downto 0)<=(sreg(conv_integer(order(10 downto 8)))) or (order(7 downto 0));Aluout(15 downto 8)<="11111111";when "10000"=>--JMP AddrAluout<=sreg(7)&order(7 downto 0);when "10001"=>--JZ signif sregflag(0)='1' thenif order(7)='0' then Aluout<= Pcin+("00000000"&order(7 downto 0));else Aluout <= Pcin+("11111111" & order(7 downto 0));end if;elseAluout <= Pcin;end if;when "10010"=>--JC signif sregflag(1) = '1' thenif order(7)='0' then Aluout<= Pcin+("00000000"&order(7 downto 0));else Aluout <= Pcin+("11111111" & order(7 downto 0));end if;elseAluout <= Pcin;end if;when others=>NULL;end case;end if;end process;process(k3,F9,order)beginif rst = '1' thensregflag(0)<='0';sregflag(1)<='0';elsif k3 = '1' thencase order(15 downto 12) iswhen "0011" | "0101" | "0100" | "0110" =>sregflag(1) <= F9(8);if F9(7 downto 0) = "00000000" thensregflag(0) <= '1';else sregflag(0)<='0';end if;when "0111"=>sregflag(0) <= order(11);when others => null;end case;end if;end process;end Behavioral;存储管理模块entity CPU_Momery isPort (k3 : in STD_LOGIC;--时钟控制；order : in STD_LOGIC_VECTOR (15 downto 0);--命令输入；alu : in STD_LOGIC_VECTOR (15 downto 0);--计算结果输??；datain : in STD_LOGIC_VECTOR (7 downto 0);--从内存读入的??；dataout: out STD_LOGIC_VECTOR (7 downto 0);--存入内存的数；Rtmp:out STD_LOGIC_VECTOR (15 downto 0);--数据输出；送向回写模块；sta : out STD_LOGIC;--存数控制；高电平有效；lda : out STD_LOGIC);--取数控制；高电平有效??end CPU_Momery;architecture Behavioral of CPU_Momery isbeginprocess(k3,alu,order,datain)beginif k3='1' then --高电平操作；case order(15 downto 11) iswhen "00001"=>--取数；lda<='1';Rtmp(7 downto 0)<=datain;when "00100"=>--取数；lda<='1';Rtmp(7 downto 0)<=datain;when "00101"=>--取数；lda<='1';Rtmp(7 downto 0)<=datain;when "00010"=>--存数；sta<='1';dataout<=alu(7 downto 0);when others=>Rtmp<=alu;--不访存；运算结果直接送下一个模块；lda<='0';sta<='0';end case;elselda<='0';sta<='0';end if;end process;end Behavioral;访存模块entity CPU_ToMomery isPort (sta : in STD_LOGIC;--存数指令；lda : in STD_LOGIC;--取数指令；Addr: in STD_LOGIC_VECTOR(15 downto 0);--内存地址；flag: in STD_LOGIC;--取指标志；PCaddr: in STD_LOGIC_VECTOR(15 downto 0);--指令地址输入；orderout:out STD_LOGIC_VECTOR(15 downto 0);--指令输出；dataout : out STD_LOGIC_VECTOR (7 downto 0);--从内存中取出的数；datain : in STD_LOGIC_VECTOR (7 downto 0);--需要存入内存的数;ABUS : out STD_LOGIC_VECTOR(15 downto 0);--地址总线??DBUS : inout STD_LOGIC_VECTOR(15 downto 0);--数据总线；CS: out STD_LOGIC;--片选信号；低电平有效；RD: out STD_LOGIC;--读信号；低电平有效；WR: OUT STD_LOGIC; --写信号；低电平有????nBHE:out std_logic;nBLE:out std_logic);end CPU_ToMomery;architecture Behavioral of CPU_ToMomery is beginprocess(sta,lda,datain,DBUS,flag)beginif flag='1' then --取指令；CS<='0';RD<='0';WR<='1';nBHE<='0';nBLE<='0';ABUS<=PCaddr;orderout<=DBUS;DBUS<="ZZZZZZZZZZZZZZZZ";elsif sta='1' then --存数访存；CS<='0';RD<='1';WR<='0';nBHE<='0';nBLE<='0';ABUS<=Addr;DBUS(7 downto 0)<=datain;DBUS(15 downto 8)<="11111111";elsif lda='1' then --取数访存；CS<='0';RD<='0';WR<='1';nBHE<='0';nBLE<='0';ABUS<=Addr;dataout<=DBUS(7 downto 0);DBUS<="ZZZZZZZZZZZZZZZZ";elseCS<='1';RD<='1';WR<='1';nBHE<='1';nBLE<='1';DBUS<="ZZZZZZZZZZZZZZZZ";end if;end process;end Behavioral;回写模块entity WriteBack isport(k4: in std_logic;--时钟控制；order:in std_logic_vector(15 downto 0);--指令输入；Pcin:in std_logic_vector(15 downto 0);--pc输入；datain:in std_logic_vector(15 downto 0);--需要回写的数据，包括跳转指令的PC??Pcback:out std_logic_vector(15 downto 0);--pc回写；Pcbacka: out std_logic;--pc回写允许；dataout:out std_logic_vector(7 downto 0);--回写数据输出；dataA:out std_logic);--回写允许；end WriteBack;architecture Behavioral of WriteBack isbeginprocess(k4,order,Pcin,datain)beginif k4='1' thencase order(15 downto 11) iswhen "00000" =>--mov Ri,ImPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "00001" =>--LDAPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "00010"=>--STAPcbacka<='1';Pcback<=Pcin+1;dataA<='0';when "00011"=>--mov Ri,RjPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "00100"=>--mov Ri,(Rj)Pcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "00101"=>--mov Ri,[R7//R6+x] Pcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "00110"=>--Adc Ri,ImPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "00111"=>--Adc,Ri,RjPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "01000"=>--Sbb,Ri,RjPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "01001"=>--Sbb RI,ImPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "01010"=>--AND Ri,ImPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "01011"=>--And Ri,RjPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "01100"=>--Or Ri,ImPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "01101"=>--Or,Ri,RjPcbacka<='1';Pcback<=Pcin+1;dataA<='1';dataout<=datain(7 downto 0);when "01110"=>--ClcPcbacka<='1';Pcback<=Pcin+1;dataA<='0';when "01111"=>--STCPcbacka<='1';Pcback<=Pcin+1;dataA<='0';when "10000"=>--Jmp AddrPcbacka<='1';Pcback<=datain+1;dataA<='0';when "10001"=>--Jz signPcbacka<='1';Pcback<=datain+1;dataA<='0';when "10010"=>--Jc signPcbacka<='1';Pcback<=datain+1;dataA<='0';when others=>NULL;end case;elsePcbacka<='0';dataA<='0';end if;end process;end Behavioral;元件例化entity CPU_main isport(RST:in std_logic;CLK:in std_logic;ABUS:out std_logic_vector(15 downto 0);DBUS:inout std_logic_vector(15 downto 0);nMREQ:out std_logic;nRD:out std_logic;nWR:out std_logic;nBHE:out std_logic;nBLE:out std_logic;nABUS:out std_logic_vector(15 downto 0);nDBUS:out std_logic_vector(15 downto 0);IR:out std_logic_vector(15 downto 0);Ti:out std_logic_vector(3 downto 0);CS:OUT STD_LOGIC;WR:OUT STD_LOGIC;RD:OUT STD_LOGIC;BH:OUT STD_LOGIC;BL:OUT STD_LOGIC);end CPU_main;architecture Behavioral of CPU_main iscomponent CPU_Momery isport(k3 : in STD_LOGIC;--时钟控制；order : in STD_LOGIC_VECTOR (15 downto 0);--命令输入；alu : in STD_LOGIC_VECTOR (15 downto 0);--计算结果输??；datain : in STD_LOGIC_VECTOR (7 downto 0);--从内存读入的??；dataout: out STD_LOGIC_VECTOR (7 downto 0);--存入内存的数；Rtmp:out STD_LOGIC_VECTOR (15 downto 0);--数据输出；送向回写模块；sta : out STD_LOGIC;--存数控制；高电平有效；lda : out STD_LOGIC);--取数控制；高电平有效??end component;component CPU_ToMomer y isport(sta : in STD_LOGIC;--存数指令；lda : in STD_LOGIC;--取数指令；Addr: in STD_LOGIC_VECTOR(15 downto 0);--内存地址；flag: in STD_LOGIC;--取指标志；PCaddr: in STD_LOGIC_VECTOR(15 downto 0);--指令地址输入；orderout:out STD_LOGIC_VECTOR(15 downto 0);--指令输出；dataout : out STD_LOGIC_VECTOR (7 downto 0);--从内存中取出的数；datain : in STD_LOGIC_VECTOR (7 downto 0);--需要存入内存的数;ABUS : out STD_LOGIC_VECTOR(15 downto 0);--地址总线??DBUS : inout STD_LOGIC_VECTOR(15 downto 0);--数据总线；CS: out STD_LOGIC;--片选信号；低电平有效；RD: out STD_LOGIC;--读信号；低电平有效；WR: OUT STD_LOGIC; --写信号；低电平有????nBHE:out std_logic;nBLE:out std_logic);end component;component CPU_operation isport(k2 : in STD_LOGIC;--时钟控制；k3 : in STD_LOGIC;--时钟控制；第三个时钟高电平改变标志寄存器的值；order : in STD_LOGIC_VECTOR (15 downto 0);--命令输入；Pcin:in STD_LOGIC_VECTOR(15 downto 0);--pc输入；Rst:in STD_LOGIC;--复??；Rwb : in STD_LOGIC_VECTOR (7 downto 0);--回写数据；Rwba : in STD_LOGIC;--回?丛市???高电平有效Aluout : out STD_LOGIC_VECTOR (15 downto 0);--计算结果输出；addr : out STD_LOGIC_VECTOR (15 downto 0)--内存?刂???);end component;component WriteBack isport(k4: in std_logic;--时钟控制；order:in std_logic_vector(15 downto 0);--指令输入；Pcin:in std_logic_vector(15 downto 0);--pc输入；datain:in std_logic_vector(15 downto 0);--需要回写的数据，包括跳转指令的PC??Pcback:out std_logic_vector(15 downto 0);--pc回写；Pcbacka: out std_logic;--pc回写允许；dataout:out std_logic_vector(7 downto 0);--回写数据输出；dataA:out std_logic--回写允许；);end component;component irget isport(Rst : in STD_LOGIC;--复位；Pcback : in STD_LOGIC_VECTOR (15 downto 0);--PC回写；Pcbacka : in STD_LOGIC;--PC回写允许；k1 : in STD_LOGIC;--时钟控制；Order : in STD_LOGIC_VECTOR (15 downto 0);--指令Pcout : out STD_LOGIC_VECTOR (15 downto 0);--PC输出；Orderout : out STD_LOGIC_VECTOR (15 downto 0);--指令输出；AddrFlag : out STD_LOGIC--访址标志);end component;component clk_ctrl isport(Clk:in std_logic;Rst:in std_logic;k:out std_logic_vector(3 downto 0));end component;signal a,b,c,d,e:std_logic;signal t:std_logic_vector(3 downto 0);signal data7,data8,data9:std_logic_vector(7 downto 0);signal data1,data2,data3,data4,data5,data6,data10,data11,data12:std_logic_vector(15 downto 0); signal u,v,w,x,y:std_logic;begin--irget:--data1:回写的pc；--data2:指令输入；--data3: pc输出；--data4：指令输出??--a:PC回写允许；--b:访??标志；--operation:--data9:回写数据；--data5:Aluout--data6:Addr输出；--memory:--data7:从内存读入的数；--data8:存入内存??；--data10:送往回写模块的数；--c:存数控制--d:取数控制，送? 么???块--ToMemory:--ABUS，DBUS--CS RD WR;--writeback:--e回写数据允许；--a回写pc允许；u1: clk_ctrl port map(CLK, RST, t);u2: irget port map(RST, data1, a, t(0), data2, data3, data4, b);u3: CPU_operation port map(t(1),t(2),data4,data3,Rst,data9,e,data5,data6);u4: CPU_Momery port map(t(2),data4,data5,data7,data8,data10,c,d);u5: CPU_ToMomery port map(c,d,data6,b,data3,data2,data7,data8,data11,DBUS,u,v,w,x,y);u6: WriteBack port map(t(3),data4,data3,data10,data1,a,data9,e);IR<=data2;Ti<=t;nMREQ<=u;CS<=u;nRD<=v;RD<=v;WR<=w;nWR<=w;BH<=x;nBHE<=x;BL<=y;nBLE<=y;ABUS<=data11; nABUS<=data11;nDBUS<=DBUS;end Behavioral;。
