MIPS汇编基础：理解RISC架构与程序设计

需积分: 11 99 浏览量更新于2024-07-31 收藏 628KB PDF 举报

"MIPS汇编语言程序设计"是一本专为初级计算机科学课程设计的教材，旨在引导学生理解和掌握精简指令集计算机(RISC)架构，特别是MIPS架构的基本原理。作者是Robert Britton，他来自加州州立大学奇科分校计算机科学系，这本书旨在作为入门级别的低阶汇编语言编程或计算机组织课程的基础教材。该书的核心内容围绕MIPS架构展开，它强调了当代RISC设计的核心原则。通过本书的学习，读者可以建立起对现代计算机体系结构的基本认知，了解如何将计算机的各个功能组件整合在一起，并深入理解计算机在机器语言层面上的工作原理。作者特别提到，本书采用了一种教学策略，使得学习者能够相对轻松地掌握MIPS汇编语言，相比于复杂的Intel x86汇编代码，MIPS提供了更易于理解和操作的环境。课程内容覆盖广泛，包括但不限于算法开发、数字系统、函数调用与可重入函数、内存映射输入/输出(I/O)、异常处理和中断管理，以及浮点指令的使用。作者假设学生已经具备一定的计算机基础知识，这样可以确保他们能在后续的学习中顺利衔接进高级计算机组织课程，如Patterson和Hennessy所著的《计算机组织与设计》。在本书中，读者不仅能学到编程技能，还能培养抽象思维和底层操作的实战能力，这对于任何希望从事IT行业的人来说都是至关重要的基础。无论是为了学术研究还是准备职业发展，"MIPS汇编语言程序设计"都是一本不可或缺的参考书籍，它不仅提供理论知识，还注重实践操作，使学生能够在实践中逐渐精通这一领域的技术。

CHAPTER 2

Pseudocode

Where does satisfaction come from?

A satisfactory.

2.1 Introduction

Experienced programmers develop their algorithms using high-level programming

constructs such as:

• If (condition) do {this block of code} else do {that block of code};

• While (condition) do {this block of code};

• For ( t0=1, t0 < s0, t0++) do {this block of code};

The key to making MIPS assembly language programming easy, is to initially develop

the algorithm using a high level pseudocode notation with which we are already familiar.

Then in the final phase translate these high level pseudocode expressions into MIPS

assembly language. In other words in the final phase we are performing the same

function that a compiler performs, which is to translate high-level code into the

equivalent assembly language code.

2.2 Develop the Algorithm in Pseudocode

When documenting an algorithm in a language such as Pascal, C, C++, or JAVA,

programmers use descriptive variable names such as: speed, volume, size, count, amount,

etc. After the program is compiled, these variable names correspond to memory

locations, and the values stored in these memory locations correspond to the values of

these variables. A compiler will attempt to develop code in such a way as to keep the

variables that are referenced most often in processor registers, because access to a

variable in a processor register is faster than access to random access memory (RAM).

MIPS has 32 processor registers whose names were defined in Table 1.1. In the case of

the MIPS architecture, all of the data manipulation instructions and the control

instructions require that their operands be in the register file.

A MIPS assembly language programmer must specify within each instruction which

processor registers are going to be utilized. For example, we may have a value in register

$t0 corresponding to speed, a value in register $t1 corresponding to volume, a value in

When using pseudocode to document an assembly language program, we must use the

names of the registers we intend to use in the assembly language code. It is advisable to

create a cross-reference table that defines what each processor register is being used for

within the algorithm. (For example $t0: Sum, $v0: Count) We use register names in

pseudocode so that the translation to assembly language code will be an easy process to

perform and because we want documentation that describes how the features of the MIPS

architecture were used to implement the algorithm. Unless we identify the registers being

used, the pseudocode is quite limited in terms of deriving the assembly language program

or having any correspondence to the assembly language code.

Pseudocode for assembly language programs will have the appearance of Pascal or C in

terms of control structures and arithmetic expressions. Descriptive variable names will

usually appear only in the Load Address (la) instruction where there is a reference to a

symbolic memory address. In assembly language we define and allocate space for

variables in the data segment of memory using assembler directives such as “.word” and

“.space”. Strings are allocated space in memory using the assembler directive “.asciiz”.

See Appendix A, for a list of the most commonly used assembler directives.

Now, for an example, let us suppose we want to write an assembly language program to

find the sum of the integers from one to N, where N is a value read in from the keyboard.

In other words do the following: 1 + 2 + 3 + 4 + 5 + 6 + 7 + .........+ N

Below you will find a pseudocode description of the algorithm and the corresponding

assembly language program, where processor register $t0 is used to accumulate the sum,

and processor register $v0 is used as a loop counter that starts with the value N and

counts down to 0.

Using a text editor create the following program file and experiment with the different

features of the MIPS simulator. All MIPS assembly language source code files must be

saved as text only. Chapter 4 provides a description of how to download the MIPS

simulator. Note that the algorithm used here sums the integers in reverse order.

# Program Name: Sum of Integers

# Programmer: YOUR NAME

# Date last modified:

# Functional Description:

# A program to find the Sum of the Integers from 1 to N, where N is a value

# input from the keyboard.

##################################################################

# Pseudocode description of algorithm:

# main: cout << “Please input a value for N”

# cin >> v0

# If ( v0 <= 0 ) stop

# t0 = 0;

# While (v0 > 0 ) do

# {

# t0 = t0 + v0;

# v0 = v0 - 1;

# }

# cout << t0;

# go to main

2.3 Register Usage Convention

Within the register file different sets of registers have been given names to remind the

programmer of a convention, which all MIPS assembly language programmers are

expected to abide by. If all the members of a programming team do not adhere to the

same convention, the entire effort will result in disaster. To simulate this situation

everyone using this book is expected to adhere to the same convention. Programs should

run correctly, even if the class members randomly exchange their functions.

Programs of any complexity typically involve a main program that calls functions. Any

important variables in the main program that must be maintained across function calls

should be assigned to registers $s0 through $s7. As programs become more complex,

functions will call other functions. This is referred to as nested function calls. A function

that does not call another function is referred to as a “leaf function.” When writing a

function, the programmer may utilize registers $t0 through $t9 with the understanding

that no other code modules expect values in these registers will be maintained. If

additional registers are needed within the function, the programmer may use only

registers $s0 through $s7 if he/she first saves their current values on the stack and

restores their values before exiting the function. Registers $s0 through $s7 are referred to

as callee-saved registers. Registers $t0 through $t9 are referred to as caller-saved

registers. This means that if the code module requires that the contents of certain “t”

registers must be maintained upon return from a call to another function, then it is the

responsibility of the calling module to save these values on the stack and restore the

values upon returning from the function call. Registers $a0 through $a3 are used to pass

arguments to functions, and registers $v0 and $v1 are used to return values from

functions. These conventions are covered in more detail in Chapter 6.

2.4 The MIPS Instruction Set

When the MIPS architecture was defined, the designers decided that the machine would

have instructions to perform the operations listed in Appendix C. At that time, the

designers also decided on a binary operation code for each instruction, and the specific

instruction format in binary. Given the requirement of the different instructions it was

necessary to define three different formats. Some instructions are encoded in R format,

some in I format and a few in J format. The list of instructions in Appendix C is not a

complete list. The other instructions not in Appendix C involve floating point

instructions, coprocessor instructions, cache instructions, instructions to manage virtual

memory, and instructions concerned with the pipeline execution.

The designers of the MIPS assembler, the program that translates MIPS assembly

language code to MIPS binary machine language code, also made some decisions to

simplify the task of writing MIPS assembly language code. The MIPS assembler

provides a set of macro (also called synthetic or pseudo) instructions. Every time a

programmer specifies a macro instruction, the assembler replaces it with a set of actual

MIPS instructions to accomplish the task. Appendix D provides a list of macro

剩余108页未读，继续阅读

callightman

粉丝: 0
资源: 1

MIPS汇编基础：理解RISC架构与程序设计

MIPS汇编语言程序设计与图灵机解析

MIPS汇编语言程序设计：冒泡排序实现

MIPS汇编语言开发的战区游戏设计源码分享

实验一：MIPS汇编语言程序设计1

毕业设计设计源码-mips-battlezone:Battlezone-MIPS汇编语言程序设计

MIPS汇编语言程序设计].MIPS.Assembly.Language.Programming.(2003)

[MIPS汇编语言程序设计].MIPS.Assembly.Language.Programming.(2003)

MIPS汇编语言程序设

MIPS的汇编语言程序设计教程

MIPS 汇编语言

最新资源