spim.tex

用汇编语言编程源代码

% Master File: spim.tex
% Document type: LaTeX
%
% Documentation for SPIM.  This is a latex file.
%
% Copyright (C) 1990--1997 by James R. Larus ([e-mail]).
%
%   SPIM is distributed under the following conditions:
%
%    You may make copies of SPIM for your own use and modify those copies.
%
%    All copies of SPIM must retain my name and copyright notice.
%
%    You may not sell SPIM or distributed SPIM in conjunction with a
%    commerical product or service without the expressed written consent of
%    James Larus.
%
%   THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
%   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
%   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
%   PURPOSE. */

% $Header: $

%
% You are free to make and distribute copies of this documentation as
% long as my name, address and copyright notices remain on both the
% source and printed versions.
%


\documentstyle[11pt]{article}

% This is necessary for LaTeX2e.  Comment it out for older versions.
\usepackage{psfig}

% Use this command for older versions of LaTeX.
%\input{psfig}


% Change margins:
\setlength{\oddsidemargin}{0.1 true in}
\setlength{\evensidemargin}{0.15 true in}
\setlength{\marginparwidth}{1 true in}
\setlength{\oddsidemargin}{0.125 true in}
\setlength{\evensidemargin}{0.125 true in}
\setlength{\marginparwidth}{0.75 true in}
\setlength{\topmargin}{-.50 true in}
\setlength{\textheight}{9.0 true in}
\setlength{\textwidth}{6.30 true in}

\begin{document}


\title{SPIM S20: A MIPS R2000 Simulator\thanks
{I grateful to the many students at UW who used SPIM in their courses
and happily found bugs in a professor's code.  In particular, the
students in CS536, Spring 1990, painfully found the last few bugs in
an ``already-debugged'' simulator.  I am grateful for their patience
and persistence.  Alan Yuen-wui Siow wrote the X-window interface.}
\\
{\small ``$\frac{1}{25}^{th}$ the performance at none of 	the
cost''}}

\author{{\normalsize James R. Larus} \\
	{\normalsize [e-mail]} \\
	{\normalsize Computer Sciences Department} \\
	{\normalsize University of Wisconsin--Madison} \\
	{\normalsize 1210 West Dayton Street} \\
	{\normalsize Madison, WI 53706, USA} \\
	{\normalsize 608-262-9519}}

\date{Copyright \copyright 1990--1997 by James R. Larus \\
      (This document may be copied without royalties, \\
	so long as this copyright notice remains on it.)}

\maketitle


\newcommand {\pinst} [2]%
	{\bigskip\noindent{\em{{\tt #1}\hfill#2 ${}^{\dagger}$\newline}}}
\newcommand {\inst} [2]%
	 {\bigskip\noindent{\em{{\tt #1}\hfill#2\newline}}}
\newcommand {\pinstX} [2]%
	{\noindent{\em{{\tt #1}\hfill#2 ${}^{\dagger}$\newline}}}
\newcommand {\instX} [2]%
	{\noindent{\em{{\tt #1}\hfill#2\newline}}}


\section{SPIM}

SPIM S20 is a simulator that runs programs for the MIPS R2000/R3000 RISC
computers.\footnote{For a description of the real machines, see Gerry Kane
and Joe Heinrich, {\em MIPS RISC Architecture,\/} Prentice Hall, 1992.} SPIM
can read and immediately execute files containing assembly language.  SPIM
is a self-contained system for running these programs and contains a
debugger and interface to a few operating system services.

The architecture of the MIPS computers is simple and regular, which
makes it easy to learn and understand.  The processor contains 32
general-purpose 32-bit registers and a well-designed instruction set that
make it a propitious target for generating code in a compiler.

However, the obvious question is: why use a simulator when many people
have workstations that contain a hardware, and hence significantly
faster, implementation of this computer?  One reason is that these
workstations are not generally available.  Another reason is that
these machine will not persist for many years because of the rapid
progress leading to new and faster computers.  Unfortunately, the
trend is to make computers faster by executing several instructions
concurrently, which makes their architecture more difficult to
understand and program.  The MIPS architecture may be the epitome of a
simple, clean RISC machine.

In addition, simulators can provide a better environment for low-level
programming than an actual machine because they can detect more errors
and provide more features than an actual computer.  For example, SPIM
has a X-window interface that is better than most debuggers for the
actual machines.

Finally, simulators are an useful tool for studying computers and the
programs that run on them.  Because they are implemented in software,
not silicon, they can be easily modified to add new instructions,
build new systems such as multiprocessors, or simply to collect data.

\subsection{Simulation of a Virtual Machine}

The MIPS architecture, like that of most RISC computers, is difficult
to program directly because of its delayed branches, delayed loads,
and restricted address modes.  This difficulty is tolerable since
these computers were designed to be programmed in high-level languages
and so present an interface designed for compilers, not programmers.
A good part of the complexity results from delayed instructions.  A
{\em delayed branch\/} takes two cycles to execute.  In the second
cycle, the instruction immediately following the branch executes.
This instruction can perform useful work that normally would have been
done before the branch or it can be a {\tt nop} (no operation).
Similarly, {\em delayed loads\/} take two cycles so the instruction
immediately following a load cannot use the value loaded from memory.

MIPS wisely choose to hide this complexity by implementing a {\em
virtual machine\/} with their assembler.  This virtual computer
appears to have non-delayed branches and loads and a richer
instruction set than the actual hardware.  The assembler {\em
reorganizes\/} (rearranges) instructions to fill the delay slots.  It
also simulates the additional, {\em pseudoinstructions\/} by
generating short sequences of actual instructions.

By default, SPIM simulates the richer, virtual machine.  It can also
simulate the actual hardware.  We will describe the virtual machine
and only mention in passing features that do not belong to the actual
hardware.  In doing so, we are following the convention of MIPS
assembly language programmers (and compilers), who routinely take
advantage of the extended machine.  Instructions marked with a dagger
($\dagger$) are pseudoinstructions.

\subsection{SPIM Interface}

SPIM provides a simple terminal and a X-window interface.  Both
provide equivalent functionality, but the X interface is generally
easier to use and more informative.

{\tt spim}, the terminal version, and {\tt xspim}, the X version, have
the following command-line options:
\begin{description}
  \item [] {\tt -bare}\newline Simulate a bare MIPS machine without
pseudoinstructions or the additional addressing modes provided by the
assembler.  Implies {\tt -quiet}.

  \item [] {\tt -asm}\newline Simulate the virtual MIPS machine
provided by the assembler.  This is the default.

  \item [] {\tt -pseudo} \newline Accept pseudoinstructions in assembly
code. 

  \item [] {\tt -nopseudo} \newline Do not accept pseudoinstructions in
assembly code. 

  \item [] {\tt -notrap} \newline Do not load the standard trap
handler.  This trap handler has two functions that must be assumed by
the user's program.  First, it handles traps.  When a trap occurs,
SPIM jumps to location 0x80000080, which should contain code to
service the exception.  Second, this file contains startup code that
invokes the routine {\tt main}.  Without the trap handler, execution
begins at the instruction labeled {\tt \_\_start}.

  \item [] {\tt -trap}\newline Load the standard trap handler.  This
is the default.

  \item [] {\tt -trap\_file}\newline Load the trap handler in the file.

  \item [] {\tt -noquiet}\newline Print a message when an exception
occurs.  This is the default.

  \item [] {\tt -quiet}\newline Do not print a message at an
exception.

  \item [] {\tt -nomapped\_io}\newline Disable the memory-mapped IO
facility (see Section~\ref{sec:IO}).

  \item [] {\tt -mapped\_io}\newline Enable the memory-mapped IO facility
(see Section~\ref{sec:IO}).  Programs that use SPIM syscalls (see
Section~\ref{sec:scall}) to read from the terminal should not also use
memory-mapped IO.

  \item [] {\tt -file}\newline Load and execute the assembly code in
the file.

  \item [] {\tt -s seg size} Sets the initial size of memory segment
{\em seg\/} to be {\em size\/} bytes.  The memory segments are named:
{\tt text}, {\tt data}, {\tt stack}, {\tt ktext}, and {\tt kdata}.
For example, the pair of arguments {\tt -sdata 2000000} starts the
user data segment at 2,000,000 bytes.

  \item [] {\tt -lseg size} Sets the limit on how large memory segment
{\em seg\/} can grow to be {\em size\/} bytes.  The memory segments
that can grow are: {\tt data}, {\tt stack}, and {\tt kdata}.
\end{description}

\subsubsection{Terminal Interface}

The terminal interface ({\tt spim}) provides the following commands:
\begin{description}
  \item [] {\tt exit}\newline Exit the simulator.

  \item [] {\tt read "file"}\newline Read {\em file\/} of assembly
language commands into SPIM's memory.  If the file has already been
read into SPIM, the system should be cleared (see {\tt reinitialize},
below) or global symbols will be multiply defined.

  \item [] {\tt load "file"}\newline Synonym for {\tt read}.

  \item [] {\tt run <addr>}\newline Start running a program.  If the
optional address {\em addr\/} is provided, the program starts at that
address.  Otherwise, the program starts at the global symbol {\tt
\_\_start}, which is defined by the default trap handler to call the
routine at the global symbol {\tt main} with the usual MIPS calling
convention.

  \item [] {\tt step <N>}\newline Step the program for {\em N\/}
(default: 1) instructions.  Print instructions as they execute.

  \item [] {\tt continue}\newline Continue program execution without
stepping.

  \item [] {\tt print \$N}\newline Print register {\em N\/}.

  \item [] {\tt print \$fN}\newline Print floating point register {\em
N\/}.

  \item [] {\tt print addr}\newline Print the contents of memory at
address {\em addr\/}.

  \item [] {\tt print\_sym}\newline Print the contents of the symbol
table, i.e., the addresses of the global (but not local) symbols.

  \item [] {\tt reinitialize}\newline Clear the memory and registers.

  \item [] {\tt breakpoint addr}\newline Set a breakpoint at address
{\em addr\/}.  {\em addr\/} can be either a memory address or symbolic
label.

  \item [] {\tt delete addr}\newline Delete all breakpoints at address
{\em addr\/}.

  \item [] {\tt list}\newline List all breakpoints.

  \item [] {\tt .}\newline Rest of line is an assembly instruction
that is stored in memory.

  \item [] {\tt <nl>}\newline A newline reexecutes previous command.

  \item [] {\tt ?}\newline Print a help message.
\end{description}

Most commands can be abbreviated to their unique prefix e.g., {\tt
ex}, {\tt re}, {\tt l}, {\tt ru}, {\tt s}, {\tt p}.  More dangerous
commands, such as {\tt reinitialize}, require a longer prefix.

\subsubsection{X-Window Interface}

\begin{figure}
  \centerline{\psfig{figure=xinterface.id,height=4.5in}}
  \caption{X-window interface to SPIM.}
  \label{fig:xinterface}
\end{figure}
The X version of SPIM, {\tt xspim}, looks different, but should
operate in the same manner as {\tt spim}.  The X window has five panes
(see Figure~\ref{fig:xinterface}).  The top pane displays the contents
of the registers.  It is continually updated, except while a program
is running.

The next pane contains the buttons that control the simulator:
\begin{itemize}
  \item [] {\bf quit}\newline Exit from the simulator.

  \item [] {\bf load}\newline Read a source file into memory.

  \item [] {\bf run}\newline Start the program running.

  \item [] {\bf step}\newline Single-step through a program.

  \item [] {\bf clear}\newline Reinitialize registers or memory.

  \item [] {\bf set value}\newline Set the value in a register or
memory location.

  \item [] {\bf print}\newline Print the value in a register or memory
location.

  \item [] {\bf breakpoint}\newline Set or delete a breakpoint or list
all breakpoints.

  \item [] {\bf help}\newline Print a help message.

  \item [] {\bf terminal}\newline Raise or hide the console window.

  \item [] {\bf mode}\newline Set SPIM operating modes.
\end{itemize}

The next two panes display the memory contents.  The top one shows
instructions from the user and kernel text segments.\footnote{These
instructions are real---not pseudo---MIPS instructions.  SPIM
translates assembler pseudoinstructions to 1--3 MIPS instructions
before storing the program in memory.  Each source instruction appears
as a comment on the first instruction to which it is translated.} The
first few instructions in the text segment are startup code ({\tt
\_\_start}) that loads {\tt argc} and {\tt argv} into registers and
invokes the {\tt main} routine.

The lower of these two panes displays the data and stack segments.
Both panes are updated as a program executes.

The bottom pane is used to display messages from the simulator.  It
does not display output from an executing program.  When a program
reads or writes, its IO appears in a separate window, called the
Console, which pops up when needed.

\subsection{Surprising Features}

Although SPIM faithfully simulates the MIPS computer, it is a
simulator and certain things are not identical to the actual computer.
The most obvious differences are that instruction timing and the
memory systems are not identical.  SPIM does not simulate caches or
memory latency, nor does it accurate reflect the delays for floating
point operations or multiplies and divides.

Another surprise (which occurs on the real machine as well) is that a
pseudoinstruction expands into several machine instructions.  When
single-stepping or examining memory, the instructions that you see are
slightly different from the source program.  The correspondence
between the two sets of instructions is fairly simple since SPIM does
not reorganize the instructions to fill delay slots.

\subsection{Assembler Syntax}
\label{sec:syntax}

Comments in assembler files begin with a sharp-sign ({\tt \#}).