1 |
<html> |
<html><head><title>GXemul documentation: Technical details</title> |
2 |
<head><title>GXemul documentation: Technical details</title> |
<meta name="robots" content="noarchive,nofollow,noindex"></head> |
|
</head> |
|
3 |
<body bgcolor="#f8f8f8" text="#000000" link="#4040f0" vlink="#404040" alink="#ff0000"> |
<body bgcolor="#f8f8f8" text="#000000" link="#4040f0" vlink="#404040" alink="#ff0000"> |
4 |
<table border=0 width=100% bgcolor="#d0d0d0"><tr> |
<table border=0 width=100% bgcolor="#d0d0d0"><tr> |
5 |
<td width=100% align=center valign=center><table border=0 width=100%><tr> |
<td width=100% align=center valign=center><table border=0 width=100%><tr> |
7 |
<b>GXemul documentation:</b></font> |
<b>GXemul documentation:</b></font> |
8 |
<font color="#000000" size="6"><b>Technical details</b> |
<font color="#000000" size="6"><b>Technical details</b> |
9 |
</font></td></tr></table></td></tr></table><p> |
</font></td></tr></table></td></tr></table><p> |
|
<!-- The first 10 lines are cut away by the homepage updating script. --> |
|
|
|
|
10 |
|
|
11 |
<!-- |
<!-- |
12 |
|
|
13 |
$Id: technical.html,v 1.49 2005/04/16 00:29:45 debug Exp $ |
$Id: technical.html,v 1.53 2005/06/27 17:31:50 debug Exp $ |
14 |
|
|
15 |
Copyright (C) 2004-2005 Anders Gavare. All rights reserved. |
Copyright (C) 2004-2005 Anders Gavare. All rights reserved. |
16 |
|
|
45 |
<p><br> |
<p><br> |
46 |
<h2>Technical details</h2> |
<h2>Technical details</h2> |
47 |
|
|
48 |
<p> |
<p>This page describes some of the internals of GXemul. |
|
This page describes some of the internals of GXemul. |
|
49 |
|
|
50 |
<p> |
<p> |
51 |
<ul> |
<ul> |
52 |
<li><a href="#overview">Overview</a> |
<li><a href="#speed">Speed and emulation modes</a> |
|
<li><a href="#speed">Speed</a> |
|
53 |
<li><a href="#net">Networking</a> |
<li><a href="#net">Networking</a> |
54 |
<li><a href="#devices">Emulation of hardware devices</a> |
<li><a href="#devices">Emulation of hardware devices</a> |
55 |
<li><a href="#regtest">Regression tests</a> |
<li><a href="#regtest">Regression tests</a> |
58 |
|
|
59 |
|
|
60 |
|
|
|
<p><br> |
|
|
<a name="overview"></a> |
|
|
<h3>Overview</h3> |
|
|
|
|
|
In simple terms, GXemul is just a simple fetch-and-execute |
|
|
loop; an instruction is fetched from memory, and executed. |
|
|
|
|
|
<p> |
|
|
In reality, a lot of things need to be handled. Before each instruction is |
|
|
executed, the emulator checks to see if any interrupts are asserted which |
|
|
are not masked away. If so, then an INT exception is generated. Exceptions |
|
|
cause the program counter to be set to a specific value, and some of the |
|
|
system coprocessor's registers to be set to values signifying what kind of |
|
|
exception it was (an interrupt exception in this case). |
|
|
|
|
|
<p> |
|
|
Reading instructions from memory is done through a TLB, a translation |
|
|
lookaside buffer. The TLB on MIPS is software controlled, which means that |
|
|
the program running inside the emulator (for example an operating system |
|
|
kernel) has to take care of manually updating the TLB. Some memory |
|
|
addresses are translated into physical addresses directly, some are |
|
|
translated into valid physical addresses via the TLB, and some memory |
|
|
references are not valid. Invalid memory references cause exceptions. |
|
|
|
|
|
<p> |
|
|
After an instruction has been read from memory, the emulator checks which |
|
|
opcode it contains and executes the instruction. Executing an instruction |
|
|
usually involves reading some register and writing some register, or perhaps a |
|
|
load from memory (or a store to memory). The program counter is increased |
|
|
for every instruction. |
|
|
|
|
|
<p> |
|
|
Some memory references point to physical addresses which are not in the |
|
|
normal RAM address space. They may point to hardware devices. If that is |
|
|
the case, then loads and stores are converted into calls to a device |
|
|
access function. The device access function is then responsible for |
|
|
handling these reads and writes. For example, a graphical framebuffer |
|
|
device may put a pixel on the screen when a value is written to it, or a |
|
|
serial controller device may output a character to stdout when written to. |
|
|
|
|
|
|
|
61 |
|
|
62 |
|
|
63 |
<p><br> |
<p><br> |
64 |
<a name="speed"></a> |
<a name="speed"></a> |
65 |
<h3>Speed</h3> |
<h3>Speed and emulation modes</h3> |
|
|
|
|
There are two modes in which the emulator can run, <b>a</b>) a straight forward |
|
|
loop which fetches one instruction from emulated RAM and executes it |
|
|
(described in the previous section), and <b>b</b>) |
|
|
using dynamic binary translation. |
|
|
|
|
|
<p> |
|
|
Mode <b>a</b> is very slow. On a 2.8 GHz Intel Xeon host the resulting |
|
|
emulated machine is rougly equal to a 7 MHz R3000 (or a 3.5 MHz R4000). |
|
|
The actual performance varies a lot, maybe between 5 and 10 million |
|
|
instructions per second, depending on workload. |
|
66 |
|
|
67 |
<p> |
So, how fast is GXemul? There is no good answer to this. There is |
68 |
Mode <b>b</b> ("bintrans") is still to be considered experimental, but |
especially no answer to the question <b>What is the slowdown factor?</b>, |
69 |
gives higher performance than mode <b>a</b>. It translates MIPS machine |
because the host architecture and emulated architecture can usually not be |
70 |
code into machine code that can be executed on the host machine |
compared just like that. |
71 |
on-the-fly. The translation itself obviously takes some time, but this is |
|
72 |
usually made up for by the fact that the translated code chunks are |
<p>Performance depends on several factors, including (but not limited to) |
73 |
executed multiple times. |
host architecture, host clock speed, which compiler and compiler flags |
74 |
To run the emulator with binary translation enabled, just add <b>-b</b> |
were used to build the emulator, what the workload is, and so on. For |
75 |
to the command line. |
example, if an emulated operating system tries to read a block from disk, |
76 |
|
from its point of view the read was instantaneous (no waiting). So 1 MIPS |
77 |
|
in an emulated OS might have taken more than one million instructions on a |
78 |
|
real machine. |
79 |
|
|
80 |
|
<p>Also, if the emulator says it has executed 1 million instructions, and |
81 |
|
the CPU family in question was capable of scalar execution (i.e. one cycle |
82 |
|
per instruction), it might still have taken more than 1 million cycles on |
83 |
|
a real machine because of cache misses and similar micro-architectural |
84 |
|
penalties that are not simulated by GXemul. |
85 |
|
|
86 |
|
<p>Because of these issues, it is in my opinion best to measure |
87 |
|
performance as the actual (real-world) time it takes to perform a task |
88 |
|
with the emulator. Typical examples would be "How long does it take to |
89 |
|
install NetBSD?", or "How long does it take to compile XYZ inside NetBSD |
90 |
|
in the emulator?". |
91 |
|
|
92 |
|
<p>The emulation technique used varies depending on which processor type |
93 |
|
is being emulated. (One of my main goals with GXemul is to experiment with |
94 |
|
different kinds of emulation, so these might change in the future.) |
95 |
|
|
96 |
<p> |
<ul> |
97 |
Only small pieces of MIPS machine code are translated, usually the size of |
<li><b>MIPS</b><br> |
98 |
a function, or less. There is no "intermediate representation" code, so |
There are two emulation modes. The most important one is an |
99 |
all translations are done directly from MIPS to host machine code. |
implementation of a <i>dynamic binary translator</i>. |
100 |
|
(Compared to real binary translators, though, GXemul's bintrans |
101 |
<p> |
subsystem is very simple and does not perform very well.) |
102 |
The default bintrans cache size is 16 MB, but you can change this by adding |
This mode can be used on Alpha and i386 host. The other emulation |
103 |
-DDEFAULT_BINTRANS_SIZE_IN_MB=<i>xx</i> to your CFLAGS environment variable |
mode is simple interpretation, where an instruction is read from |
104 |
before running the configure script, or by using the bintrans_size() |
emulated memory, and interpreted one-at-a-time. (Slow, but it |
105 |
configuration file option when running the emulator. |
works. It can be forcefully used by using the <tt>-B</tt> command |
106 |
|
line option.) |
107 |
|
<p> |
108 |
|
<li><b>ARM</b><br> |
109 |
|
This mode does not really work yet, but will use |
110 |
|
dynamic translation, but not binary translation. Stay tuned. :-) |
111 |
|
<p> |
112 |
|
<li><b>URISC</b><br> |
113 |
|
Simple interpretation, one instruction at a time. There is probably |
114 |
|
no other way to emulate URISC, because it relies too heavily |
115 |
|
on self-modifying code. |
116 |
|
<p> |
117 |
|
<li><b>POWER/PowerPC</b><br> |
118 |
|
This emulation mode is very much unfinished, but still enabled by |
119 |
|
default. So far it uses plain interpretation, where an instruction |
120 |
|
is read from emulated memory, and interpreted one at a time. |
121 |
|
Slow. Not very interesting. |
122 |
|
<p> |
123 |
|
<li><b>x86</b><br> |
124 |
|
Although too unstable and non-working to be enabled by default, |
125 |
|
there is some code for emulating x86 machines. It simply reads |
126 |
|
one instruction at a time from emulated memory, and executes it. |
127 |
|
This is as slow as it gets. Not very interesting. |
128 |
|
</ul> |
129 |
|
|
|
<p> |
|
|
By default, an emulated OS running under DECstation emulation which listens to |
|
|
interrupts from the mc146818 clock will get interrupts that are close to the |
|
|
host's clock. That is, if the emulated OS says it wants 100 interrupts per |
|
|
second, it will get approximately 100 interrupts per real second. |
|
130 |
|
|
|
<p> |
|
|
There is however a -I option, which sets the number of emulated cycles per |
|
|
seconds to a fixed value. Let's say you wish to make the emulated OS think it |
|
|
is running on a 40 MHz DECstation, and not a 7 MHz one, then you can add |
|
|
-I 40000000 to the command line. This will not make the emulation faster, of |
|
|
course. It might even make it seem slower; for example, if NetBSD/pmax waits |
|
|
2 seconds for SCSI devices to settle during bootup, those 2 seconds will take |
|
|
2*40000000 cycles (which will take more time than 2*7000000). |
|
131 |
|
|
|
<p> |
|
|
The -I option is also necessary if you want to run deterministic experiments, |
|
|
if a mc146818 device is present. |
|
|
|
|
|
<p> |
|
|
Some emulators make claims such as "x times slowdown," but in the case of |
|
|
GXemul, the host is often not a MIPS-based machine, and hence comparing |
|
|
one MIPS instruction to a host instruction doesn't work. Performance depends on |
|
|
a lot of factors, including (but not limited to) host architecture, host speed, |
|
|
which compiler and compiler flags were used to build GXemul, what the |
|
|
workload is, and so on. For example, if an emulated operating system tries |
|
|
to read a block from disk, from its point of view the read was instantaneous |
|
|
(no waiting). So 1 MIPS in an emulated OS might have taken more than one |
|
|
million instructions on a real machine. Because of this, imho it is best |
|
|
to measure performance as the actual (real-world) time it takes to perform |
|
|
a task with the emulator. |
|
132 |
|
|
133 |
|
|
134 |
|
|
137 |
<a name="net"></a> |
<a name="net"></a> |
138 |
<h3>Networking</h3> |
<h3>Networking</h3> |
139 |
|
|
140 |
Running an entire operating system under emulation is very interesting in |
<font color="#ff0000">NOTE/TODO: This section is very old and a bit |
141 |
itself, but for several reasons, running a modern OS without access to |
out of date.</font> |
142 |
TCP/IP networking is a bit akward. Hence, I feel the need to implement TCP/IP |
|
143 |
(networking) support in the emulator. |
<p>Running an entire operating system under emulation is very interesting |
144 |
|
in itself, but for several reasons, running a modern OS without access to |
145 |
|
TCP/IP networking is a bit akward. Hence, I feel the need to implement |
146 |
|
TCP/IP (networking) support in the emulator. |
147 |
|
|
148 |
<p> |
<p> |
149 |
As far as I have understood it, there seems to be two different ways to go: |
As far as I have understood it, there seems to be two different ways to go: |
164 |
connect from the emulated OS to the OS running on the |
connect from the emulated OS to the OS running on the |
165 |
host, as packets sent out on the host's NIC are not |
host, as packets sent out on the host's NIC are not |
166 |
received by itself. (?) |
received by itself. (?) |
167 |
|
<li>All specific networking protocols will be handled by the |
168 |
|
physical network. |
169 |
</ul> |
</ul> |
170 |
<p> |
<p> |
171 |
or |
or |
194 |
</ul> |
</ul> |
195 |
</ol> |
</ol> |
196 |
|
|
197 |
Other emulators that I have heard of seem to use the first one, if they |
<p> |
198 |
support networking. |
Some emulators/simulators use the first approach, while others use the |
199 |
|
second. I think that SIMH and QEMU are examples of emulators using the |
200 |
|
first and second approach, respectively. |
201 |
|
|
202 |
<p> |
<p> |
203 |
Since I have choosen the second kind of implementation, I have to write |
Since I have choosen the second kind of implementation, I have to write |
212 |
and converted to ARP responses. (This is used by the emulated OS |
and converted to ARP responses. (This is used by the emulated OS |
213 |
to find out the MAC address of the gateway.) |
to find out the MAC address of the gateway.) |
214 |
<li>ICMP echo requests (that is the kind of packet produced by the |
<li>ICMP echo requests (that is the kind of packet produced by the |
215 |
<b>ping</b> program) are interpreted and converted to ICMP echo |
<b><tt>ping</tt></b> program) are interpreted and converted to ICMP echo |
216 |
replies, <i>regardless of the IP address</i>. This means that |
replies, <i>regardless of the IP address</i>. This means that |
217 |
running ping from within the emulated OS will <i>always</i> |
running ping from within the emulated OS will <i>always</i> |
218 |
receive a response. The ping packets never leave the emulated |
receive a response. The ping packets never leave the emulated |
226 |
packets are handled (but more state is kept for each connection). |
packets are handled (but more state is kept for each connection). |
227 |
<font color="#ff0000">NOTE: Much of the TCP handling code is very |
<font color="#ff0000">NOTE: Much of the TCP handling code is very |
228 |
ugly and hardcoded.</font> |
ugly and hardcoded.</font> |
229 |
|
<!-- |
230 |
<li>RARP is not implemented yet. (I haven't needed it so far.) |
<li>RARP is not implemented yet. (I haven't needed it so far.) |
231 |
|
--> |
232 |
</ul> |
</ul> |
233 |
|
|
234 |
|
<p> |
235 |
The gateway machine, which is the only "other" machine that the emulated |
The gateway machine, which is the only "other" machine that the emulated |
236 |
OS sees on its emulated network, works as a NAT-style firewall/gateway. It |
OS sees on its emulated network, works as a NAT-style firewall/gateway. It |
237 |
has a fixed IPv4 address of 10.0.0.254. An OS running in the emulator |
usually has a fixed IPv4 address of <tt>10.0.0.254</tt>. An OS running in |
238 |
can thus have any 10.x.x.x address; a typical choice would be 10.0.0.1. |
the emulator would usually have an address of the form <tt>10.x.x.x</tt>; |
239 |
|
a typical choice would be <tt>10.0.0.1</tt>. |
240 |
|
|
241 |
<p> |
<p> |
242 |
Inside emulated NetBSD or OpenBSD, running the following commands should |
Inside emulated NetBSD/pmax or OpenBSD/pmax, running the following |
243 |
configure the emulated NIC: |
commands should configure the emulated NIC: |
244 |
<pre> |
<pre> |
245 |
# <b>ifconfig le0 10.0.0.1</b> |
# <b>ifconfig le0 10.0.0.1</b> |
246 |
# <b>route add default 10.0.0.254</b> |
# <b>route add default 10.0.0.254</b> |
247 |
add net default: gateway 10.0.0.254 |
add net default: gateway 10.0.0.254 |
248 |
</pre> |
</pre> |
249 |
|
|
250 |
|
<p> |
251 |
If you want nameserver lookups to work, you need a valid /etc/resolv.conf |
If you want nameserver lookups to work, you need a valid /etc/resolv.conf |
252 |
as well: |
as well: |
253 |
<pre> |
<pre> |
254 |
# <b>echo nameserver 129.16.1.3 > /etc/resolv.conf</b> |
# <b>echo nameserver 129.16.1.3 > /etc/resolv.conf</b> |
255 |
</pre> |
</pre> |
256 |
(But replace 129.16.1.3 with the actual real-world IP address of your |
(But replace <tt>129.16.1.3</tt> with the actual real-world IP address of |
257 |
nearest nameserver.) |
your nearest nameserver.) |
258 |
|
|
259 |
<p> |
<p> |
260 |
Now, host lookups should work: |
Now, host lookups should work: |
261 |
<pre> |
<pre> |
278 |
uucp-gw-2.pa.dec.com 172799 IN A 204.123.2.19 |
uucp-gw-2.pa.dec.com 172799 IN A 204.123.2.19 |
279 |
</pre> |
</pre> |
280 |
|
|
281 |
To transfer files via UDP, you can use the tftp program. |
<p> |
282 |
|
At this point, UDP and TCP should (mostly) work. |
|
<pre> |
|
|
# <b>tftp 12.34.56.78</b> |
|
|
tftp> <b>get filename</b> |
|
|
Received XXXXXX bytes in X.X seconds |
|
|
tftp> <b>quit</b> |
|
|
# |
|
|
</pre> |
|
|
|
|
|
or, to do it non-interactively (with ugly output): |
|
|
|
|
|
<pre> |
|
|
# <b>echo get filename | tftp 12.34.56.78</b> |
|
|
tftp> Received XXXXXX bytes in X.X seconds |
|
|
tftp> # |
|
|
</pre> |
|
283 |
|
|
284 |
This, of course, requires that you have put the file <i>filename</i> in |
<p> |
285 |
the root directory of the tftp server (12.34.56.78). |
Here is an example of how to configure a server machine and an emulated |
286 |
|
client machine for sharing files via NFS: |
287 |
|
|
288 |
<p> |
<p> |
289 |
It is also possible to run NFS via UDP. This is very useful if you want to |
(This is very useful if you want to share entire directory trees |
290 |
share entire directory trees between the emulated environment and another |
between the emulated environment and another machine. These instruction |
291 |
machine. These instruction will work for FreeBSD, if you are running |
will work for FreeBSD, if you are running something else, use your |
292 |
something else, use your imagination to modify them: |
imagination to modify them.) |
293 |
|
|
294 |
|
<p> |
295 |
<ul> |
<ul> |
296 |
<li>On the server, add a line to your /etc/exports file, exporting |
<li>On the server, add a line to your /etc/exports file, exporting |
297 |
the files you wish to use in the emulator:<pre> |
the files you wish to use in the emulator:<pre> |
330 |
files in both directions, but then you should be aware of the |
files in both directions, but then you should be aware of the |
331 |
fragmentation issue mentioned above. |
fragmentation issue mentioned above. |
332 |
|
|
333 |
<p> |
<p>TODO: Write a section on how to connect multiple emulator instances. |
334 |
TCP is implemented to some extent, but should not be considered to be |
(Using the <tt>local_port</tt> and <tt>add_remote</tt> configuration file |
335 |
stable yet. It is enough to let NetBSD/pmax and OpenBSD/pmax install via |
commands.) |
336 |
ftp, though. |
|
337 |
|
|
338 |
|
|
339 |
|
|
340 |
|
|
343 |
<a name="devices"></a> |
<a name="devices"></a> |
344 |
<h3>Emulation of hardware devices</h3> |
<h3>Emulation of hardware devices</h3> |
345 |
|
|
346 |
Each file in the device/ directory is responsible for one hardware device. |
Each file in the <tt>device/</tt> directory is responsible for one |
347 |
These are used from src/machine.c, when initializing which hardware a |
hardware device. These are used from <tt>src/machine.c</tt>, when |
348 |
particular machine model will be using, or when adding devices to a |
initializing which hardware a particular machine model will be using, or |
349 |
machine using the <b>device()</b> command in configuration files. |
when adding devices to a machine using the <tt>device()</tt> command in |
350 |
|
configuration files. |
351 |
|
|
352 |
<p> |
<p><font color="#ff0000">NOTE: The device registry subsystem is currently |
353 |
<font color="#ff0000">NOTE: 2005-02-26: I'm currently rewriting the |
in a state of flux, as it is being redesigned.</font> |
|
device registry subsystem.</font> |
|
354 |
|
|
355 |
<p> |
<p>(I'll be using the name "<tt>foo</tt>" as the name of the device in all |
356 |
(I'll be using the name 'foo' as the name of the device in all these |
these examples. This is pseudo code, it might need some modification to |
|
examples. This is pseudo code, it might need some modification to |
|
357 |
actually compile and run.) |
actually compile and run.) |
358 |
|
|
359 |
<p> |
<p>Each device should have the following: |
|
Each device should have the following: |
|
360 |
|
|
361 |
<p> |
<p> |
362 |
<ul> |
<ul> |
363 |
<li>A devinit function in dev_foo.c. It would typically look |
<li>A <tt>devinit</tt> function in <tt>src/devices/dev_foo.c</tt>. It |
364 |
something like this: |
would typically look something like this: |
365 |
<pre> |
<pre> |
366 |
/* |
/* |
367 |
* devinit_foo(): |
* devinit_foo(): |
398 |
} |
} |
399 |
</pre><br> |
</pre><br> |
400 |
|
|
401 |
<li>At the top of dev_foo.c, the foo_data struct should be defined. |
<li>At the top of <tt>dev_foo.c</tt>, the <tt>foo_data</tt> struct |
402 |
|
should be defined. |
403 |
<pre> |
<pre> |
404 |
struct foo_data { |
struct foo_data { |
405 |
int irq_nr; |
int irq_nr; |
407 |
} |
} |
408 |
</pre><br> |
</pre><br> |
409 |
|
|
410 |
<li>If foo has a tick function (that is, something that needs to be |
<li>If <tt>foo</tt> has a tick function (that is, something that needs to be |
411 |
run at regular intervals) then FOO_TICKSHIFT and a tick function |
run at regular intervals) then <tt>FOO_TICKSHIFT</tt> and a tick |
412 |
need to be defined as well: |
function need to be defined as well: |
413 |
<pre> |
<pre> |
414 |
#define FOO_TICKSHIFT 10 |
#define FOO_TICKSHIFT 10 |
415 |
|
|
454 |
</ul> |
</ul> |
455 |
|
|
456 |
<p> |
<p> |
457 |
The return value of the access function has until 20040702 been a |
The return value of the access function has until 2004-07-02 been a |
458 |
true/false value; 1 for success, or 0 for device access failure. A device |
true/false value; 1 for success, or 0 for device access failure. A device |
459 |
access failure (on MIPS) will result in a DBE exception. |
access failure (on MIPS) will result in a DBE exception. |
460 |
|
|
468 |
|
|
469 |
<p> |
<p> |
470 |
To be compatible with pre-20040702 devices, a return value of 0 is treated |
To be compatible with pre-20040702 devices, a return value of 0 is treated |
471 |
by the caller (in src/memory.c) as a value of -1. |
by the caller (in <tt>src/memory_rw.c</tt>) as a value of -1. |
472 |
|
|
473 |
|
|
474 |
|
|
480 |
|
|
481 |
In order to make sure that the emulator actually works like it is supposed |
In order to make sure that the emulator actually works like it is supposed |
482 |
to, it must be tested. For this purpose, there is a simple regression |
to, it must be tested. For this purpose, there is a simple regression |
483 |
testing framework in the <b>tests/</b> directory. |
testing framework in the <tt>tests/</tt> directory. |
484 |
|
|
485 |
<p> |
<p> |
486 |
<i>NOTE: The regression testing framework is basically just a skeleton so far. |
<i>NOTE: The regression testing framework is basically just a skeleton so far. |
490 |
regression tests.</i> |
regression tests.</i> |
491 |
|
|
492 |
<p> |
<p> |
493 |
To run all the regression tests, type <b>make regtest</b>. Each assembly |
To run all the regression tests, type <tt>make regtest</tt>. Each assembly |
494 |
language file matching the pattern <b>test_*.S</b> will be compiled and |
language file matching the pattern <tt>test_*.S</tt> will be compiled and |
495 |
linked into a 64-bit MIPS ELF (using a gcc cross compiler), and run in the |
linked into a 64-bit MIPS ELF (using a gcc cross compiler), and run in the |
496 |
emulator. If everything goes well, you should see something like this: |
emulator. If everything goes well, you should see something like this: |
497 |
|
|
534 |
</pre> |
</pre> |
535 |
|
|
536 |
<p> |
<p> |
537 |
Each test writes output to stdout, and there is a <b>test_*.good</b> for |
Each test writes output to stdout, and there is a <tt>test_*.good</tt> for |
538 |
each <b>.S</b> file which contains the wanted output. If the actual output |
each <tt>.S</tt> file which contains the wanted output. If the actual |
539 |
matches the <b>.good</b> file, then the test passes, otherwise it fails. |
output matches the <tt>.good</tt> file, then the test passes, otherwise it |
540 |
|
fails. |
541 |
|
|
542 |
<p> |
<p> |
543 |
Read <b>tests/README</b> for more information. |
Read <tt>tests/README</tt> for more information. |
544 |
|
|
545 |
|
|
546 |
|
|