/[gxemul]/trunk/src/emul.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /trunk/src/emul.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 34 - (hide annotations)
Mon Oct 8 16:21:17 2007 UTC (12 years ago) by dpavlin
File MIME type: text/plain
File size: 43320 byte(s)
++ trunk/HISTORY	(local)
$Id: HISTORY,v 1.1480 2007/02/19 01:34:42 debug Exp $
20061029	Changing usleep(1) calls in the debugger to usleep(10000)
20061107	Adding a new disk image option (-d o...) which sets the ISO9660
		filesystem base offset; also making some other hacks to allow
		NetBSD/dreamcast and homebrew demos/games to boot directly
		from a filesystem image.
		Moving Dreamcast-specific stuff in the documentation to its
		own page (dreamcast.html).
		Adding a border to the Dreamcast PVR framebuffer.
20061108	Adding a -T command line option (again?), for halting the
		emulator on unimplemented memory accesses.
20061109	Continuing on various SH4 and Dreamcast related things.
		The emulator should now halt on more unimplemented device
		accesses, instead of just printing a warning, forcing me to
		actually implement missing stuff :)
20061111	Continuing on SH4 and Dreamcast stuff.
		Adding a bogus Landisk (SH4) machine mode.
20061112	Implementing some parts of the Dreamcast GDROM device. With
		some ugly hacks, NetBSD can (barely) mount an ISO image.
20061113	NetBSD/dreamcast now starts booting from the Live CD image,
		but crashes randomly quite early on in the boot process.
20061122	Beginning on a skeleton interrupt.h and interrupt.c for the
		new interrupt subsystem.
20061124	Continuing on the new interrupt system; taking the first steps
		to attempt to connect CPUs (SuperH and MIPS) and devices
		(dev_cons and SH4 timer interrupts) to it. Many things will
		probably break from now on.
20061125	Converting dev_ns16550, dev_8253 to the new interrupt system.
		Attempting to begin to convert the ISA bus.
20061130	Incorporating a patch from Brian Foley for the configure
		script, which checks for X11 libs in /usr/X11R6/lib64 (which
		is used on some Linux systems).
20061227	Adding a note in the man page about booting from Dreamcast
		CDROM images (i.e. that no external kernel is needed).
20061229	Continuing on the interrupt system rewrite: beginning to
		convert more devices, adding abort() calls for legacy interrupt
		system calls so that everything now _has_ to be rewritten!
		Almost all machine modes are now completely broken.
20061230	More progress on removing old interrupt code, mostly related
		to the ISA bus + devices, the LCA bus (on AlphaBook1), and
		the Footbridge bus (for CATS). And some minor PCI stuff.
		Connecting the ARM cpu to the new interrupt system.
		The CATS, NetWinder, and QEMU_MIPS machine modes now work with
		the new interrupt system :)
20061231	Connecting PowerPC CPUs to the new interrupt system.
		Making PReP machines (IBM 6050) work again.
		Beginning to convert the GT PCI controller (for e.g. Malta
		and Cobalt emulation). Some things work, but not everything.
		Updating Copyright notices for 2007.
20070101	Converting dev_kn02 from legacy style to devinit; the 3max
		machine mode now works with the new interrupt system :-]
20070105	Beginning to convert the SGI O2 machine to the new interrupt
		system; finally converting O2 (IP32) devices to devinit, etc.
20070106	Continuing on the interrupt system redesign/rewrite; KN01
		(PMAX), KN230, and Dreamcast ASIC interrupts should work again,
		moving out stuff from machine.h and devices.h into the
		corresponding devices, beginning the rewrite of i80321
		interrupts, etc.
20070107	Beginning on the rewrite of Eagle interrupt stuff (PReP, etc).
20070117	Beginning the rewrite of Algor (V3) interrupts (finally
		changing dev_v3 into devinit style).
20070118	Removing the "bus" registry concept from machine.h, because
		it was practically meaningless.
		Continuing on the rewrite of Algor V3 ISA interrupts.
20070121	More work on Algor interrupts; they are now working again,
		well enough to run NetBSD/algor. :-)
20070122	Converting VR41xx (HPCmips) interrupts. NetBSD/hpcmips
		can be installed using the new interrupt system :-)
20070123	Making the testmips mode work with the new interrupt system.
20070127	Beginning to convert DEC5800 devices to devinit, and to the
		new interrupt system.
		Converting Playstation 2 devices to devinit, and converting
		the interrupt system. Also fixing a severe bug: the interrupt
		mask register on Playstation 2 is bitwise _toggled_ on writes.
20070128	Removing the dummy NetGear machine mode and the 8250 device
		(which was only used by the NetGear machine).
		Beginning to convert the MacPPC GC (Grand Central) interrupt
		controller to the new interrupt system.
		Converting Jazz interrupts (PICA61 etc.) to the new interrupt
		system. NetBSD/arc can be installed again :-)
		Fixing the JAZZ timer (hardcoding it at 100 Hz, works with
		NetBSD and it is better than a completely dummy timer as it
		was before).
		Converting dev_mp to the new interrupt system, although I
		haven't had time to actually test it yet.
		Completely removing src/machines/interrupts.c, cpu_interrupt
		and cpu_interrupt_ack in src/cpu.c, and
		src/include/machine_interrupts.h! Adding fatal error messages
		+ abort() in the few places that are left to fix.
		Converting dev_z8530 to the new interrupt system.
		FINALLY removing the md_int struct completely from the
		machine struct.
		SH4 fixes (adding a PADDR invalidation in the ITLB replacement
		code in memory_sh.c); the NetBSD/dreamcast LiveCD now runs
		all the way to the login prompt, and can be interacted with :-)
		Converting the CPC700 controller (PCI and interrupt controller
		for PM/PPC) to the new interrupt system.
20070129	Fixing MACE ISA interrupts (SGI IP32 emulation). Both NetBSD/
		sgimips' and OpenBSD/sgi's ramdisk kernels can now be
		interacted with again.
20070130	Moving out the MIPS multi_lw and _sw instruction combinations
		so that they are auto-generated at compile time instead.
20070131	Adding detection of amd64/x86_64 hosts in the configure script,
		for doing initial experiments (again :-) with native code
		generation.
		Adding a -k command line option to set the size of the dyntrans
		cache, and a -B command line option to disable native code
		generation, even if GXemul was compiled with support for
		native code generation for the specific host CPU architecture.
20070201	Experimenting with a skeleton for native code generation.
		Changing the default behaviour, so that native code generation
		is now disabled by default, and has to be enabled by using
		-b on the command line.
20070202	Continuing the native code generation experiments.
		Making PCI interrupts work for Footbridge again.
20070203	More native code generation experiments.
		Removing most of the native code generation experimental code,
		it does not make sense to include any quick hacks like this.
		Minor cleanup/removal of some more legacy MIPS interrupt code.
20070204	Making i80321 interrupts work again (for NetBSD/evbarm etc.),
		and fixing the timer at 100 Hz.
20070206	Experimenting with removing the wdc interrupt slowness hack.
20070207	Lowering the number of dyntrans TLB entries for MIPS from
		192 to 128, resulting in a minor speed improvement.
		Minor optimization to the code invalidation routine in
		cpu_dyntrans.c.
20070208	Increasing (experimentally) the nr of dyntrans instructions per
		loop from 60 to 120.
20070210	Commenting out (experimentally) the dyntrans_device_danger
		detection in memory_rw.c.
		Changing the testmips and baremips machines to use a revision 2
		MIPS64 CPU by default, instead of revision 1.
		Removing the dummy i960, IA64, x86, AVR32, and HP PA-RISC
		files, the PC bios emulation, and the Olivetti M700 (ARC) and
		db64360 emulation modes.
20070211	Adding an "mp" demo to the demos directory, which tests the
		SMP functionality of the testmips machine.
		Fixing PReP interrupts some more. NetBSD/prep now boots again.
20070216	Adding a "nop workaround" for booting Mach/PMAX to the
		documentation; thanks to Artur Bujdoso for the values.
		Converting more of the MacPPC interrupt stuff to the new
		system.
		Beginning to convert BeBox interrupts to the new system.
		PPC603e should NOT have the PPC_NO_DEC flag! Removing it.
		Correcting BeBox clock speed (it was set to 100 in the NetBSD
		bootinfo block, but should be 33000000/4), allowing NetBSD
		to start without using the (incorrect) PPC_NO_DEC hack.
20070217	Implementing (slow) AltiVec vector loads and stores, allowing
		NetBSD/macppc to finally boot using the GENERIC kernel :-)
		Updating the documentation with install instructions for
		NetBSD/macppc.
20070218-19	Regression testing for the release.

==============  RELEASE 0.4.4  ==============


1 dpavlin 2 /*
2 dpavlin 34 * Copyright (C) 2003-2007 Anders Gavare. All rights reserved.
3 dpavlin 2 *
4     * Redistribution and use in source and binary forms, with or without
5     * modification, are permitted provided that the following conditions are met:
6     *
7     * 1. Redistributions of source code must retain the above copyright
8     * notice, this list of conditions and the following disclaimer.
9     * 2. Redistributions in binary form must reproduce the above copyright
10     * notice, this list of conditions and the following disclaimer in the
11     * documentation and/or other materials provided with the distribution.
12     * 3. The name of the author may not be used to endorse or promote products
13     * derived from this software without specific prior written permission.
14     *
15     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16     * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18     * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21     * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22     * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23     * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24     * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25     * SUCH DAMAGE.
26     *
27     *
28 dpavlin 34 * $Id: emul.c,v 1.278 2007/02/10 14:37:38 debug Exp $
29 dpavlin 2 *
30     * Emulation startup and misc. routines.
31     */
32    
33     #include <signal.h>
34     #include <stdio.h>
35     #include <stdlib.h>
36     #include <limits.h>
37     #include <stdarg.h>
38     #include <string.h>
39     #include <unistd.h>
40    
41     #include "arcbios.h"
42     #include "cpu.h"
43     #include "emul.h"
44     #include "console.h"
45     #include "debugger.h"
46     #include "device.h"
47     #include "diskimage.h"
48 dpavlin 10 #include "exec_elf.h"
49 dpavlin 2 #include "machine.h"
50     #include "memory.h"
51     #include "mips_cpu_types.h"
52     #include "misc.h"
53     #include "net.h"
54 dpavlin 32 #include "settings.h"
55 dpavlin 2 #include "sgi_arcbios.h"
56 dpavlin 32 #include "timer.h"
57 dpavlin 2 #include "x11.h"
58    
59    
60 dpavlin 34 /* #define ISO_DEBUG */
61    
62    
63 dpavlin 2 extern int extra_argc;
64     extern char **extra_argv;
65    
66     extern int verbose;
67     extern int quiet_mode;
68 dpavlin 26 extern int force_debugger_at_exit;
69     extern int single_step;
70     extern int old_show_trace_tree;
71     extern int old_instruction_trace;
72     extern int old_quiet_mode;
73     extern int quiet_mode;
74 dpavlin 2
75     extern struct emul *debugger_emul;
76     extern struct diskimage *diskimages[];
77    
78 dpavlin 6 static char *diskimage_types[] = DISKIMAGE_TYPES;
79 dpavlin 2
80 dpavlin 6
81 dpavlin 22 static void print_separator(void)
82     {
83     int i = 79;
84     while (i-- > 0)
85     debug("-");
86     debug("\n");
87     }
88    
89    
90 dpavlin 2 /*
91     * add_dump_points():
92     *
93     * Take the strings breakpoint_string[] and convert to addresses
94     * (and store them in breakpoint_addr[]).
95     *
96     * TODO: This function should be moved elsewhere.
97     */
98     static void add_dump_points(struct machine *m)
99     {
100     int i;
101     int string_flag;
102     uint64_t dp;
103    
104     for (i=0; i<m->n_breakpoints; i++) {
105     string_flag = 0;
106     dp = strtoull(m->breakpoint_string[i], NULL, 0);
107    
108     /*
109     * If conversion resulted in 0, then perhaps it is a
110     * symbol:
111     */
112     if (dp == 0) {
113     uint64_t addr;
114     int res = get_symbol_addr(&m->symbol_context,
115     m->breakpoint_string[i], &addr);
116 dpavlin 24 if (!res) {
117 dpavlin 2 fprintf(stderr,
118 dpavlin 24 "ERROR! Breakpoint '%s' could not be"
119 dpavlin 2 " parsed\n",
120     m->breakpoint_string[i]);
121 dpavlin 24 } else {
122 dpavlin 2 dp = addr;
123     string_flag = 1;
124     }
125     }
126    
127     /*
128     * TODO: It would be nice if things like symbolname+0x1234
129     * were automatically converted into the correct address.
130     */
131    
132 dpavlin 20 if (m->arch == ARCH_MIPS) {
133     if ((dp >> 32) == 0 && ((dp >> 31) & 1))
134     dp |= 0xffffffff00000000ULL;
135     }
136    
137 dpavlin 2 m->breakpoint_addr[i] = dp;
138    
139 dpavlin 20 debug("breakpoint %i: 0x%llx", i, (long long)dp);
140 dpavlin 2 if (string_flag)
141     debug(" (%s)", m->breakpoint_string[i]);
142     debug("\n");
143     }
144     }
145    
146    
147     /*
148     * fix_console():
149     */
150     static void fix_console(void)
151     {
152 dpavlin 32 console_deinit_main();
153 dpavlin 2 }
154    
155    
156     /*
157 dpavlin 6 * iso_load_bootblock():
158     *
159     * Try to load a kernel from an ISO 9660 disk image. iso_type is 1 for
160     * "CD001" (standard), 2 for "CDW01" (ECMA), and 3 for "CDROM" (Sierra).
161     *
162     * TODO: This function uses too many magic offsets and so on; it should be
163     * cleaned up some day.
164     *
165     * Returns 1 on success, 0 on failure.
166     */
167     static int iso_load_bootblock(struct machine *m, struct cpu *cpu,
168     int disk_id, int disk_type, int iso_type, unsigned char *buf,
169     int *n_loadp, char ***load_namesp)
170     {
171     char str[35];
172 dpavlin 22 int filenr, i, ofs, dirlen, res = 0, res2, iadd = DEBUG_INDENTATION;
173 dpavlin 6 int found_dir;
174     uint64_t dirofs;
175     uint64_t fileofs, filelen;
176     unsigned char *dirbuf = NULL, *dp;
177     unsigned char *match_entry = NULL;
178     char *p, *filename_orig;
179     char *filename = strdup(cpu->machine->boot_kernel_filename);
180     unsigned char *filebuf = NULL;
181 dpavlin 22 char *tmpfname = NULL;
182 dpavlin 6 char **new_array;
183     int tmpfile_handle;
184    
185     if (filename == NULL) {
186     fatal("out of memory\n");
187     exit(1);
188     }
189     filename_orig = filename;
190    
191     debug("ISO9660 boot:\n");
192     debug_indentation(iadd);
193    
194     /* Volume ID: */
195     ofs = iso_type == 3? 48 : 40;
196     memcpy(str, buf + ofs, sizeof(str));
197     str[32] = '\0'; i = 31;
198     while (i >= 0 && str[i]==' ')
199     str[i--] = '\0';
200     if (str[0])
201     debug("\"%s\"", str);
202     else {
203     /* System ID: */
204     ofs = iso_type == 3? 16 : 8;
205     memcpy(str, buf + ofs, sizeof(str));
206     str[32] = '\0'; i = 31;
207     while (i >= 0 && str[i]==' ')
208     str[i--] = '\0';
209     if (str[0])
210     debug("\"%s\"", str);
211     else
212     debug("(no ID)");
213     }
214    
215     debug(":%s\n", filename);
216    
217    
218     /*
219     * Traverse the directory structure to find the kernel.
220     */
221    
222     dirlen = buf[0x84] + 256*buf[0x85] + 65536*buf[0x86];
223     if (dirlen != buf[0x8b] + 256*buf[0x8a] + 65536*buf[0x89])
224     fatal("WARNING: Root directory length mismatch?\n");
225    
226     dirofs = (int64_t)(buf[0x8c] + (buf[0x8d] << 8) + (buf[0x8e] << 16) +
227 dpavlin 22 ((uint64_t)buf[0x8f] << 24)) * 2048;
228 dpavlin 6
229 dpavlin 34 #ifdef ISO_DEBUG
230     debug("root = %i bytes at 0x%llx\n", dirlen, (long long)dirofs);
231     #endif
232 dpavlin 6
233     dirbuf = malloc(dirlen);
234     if (dirbuf == NULL) {
235     fatal("out of memory in iso_load_bootblock()\n");
236     exit(1);
237     }
238    
239     res2 = diskimage_access(m, disk_id, disk_type, 0, dirofs, dirbuf,
240     dirlen);
241     if (!res2) {
242     fatal("Couldn't read the disk image. Aborting.\n");
243     goto ret;
244     }
245    
246     found_dir = 1; /* Assume root dir */
247     dp = dirbuf; filenr = 1;
248     p = NULL;
249     while (dp < dirbuf + dirlen) {
250 dpavlin 22 size_t i, nlen = dp[0];
251     int x = dp[2] + (dp[3] << 8) + (dp[4] << 16) +
252     ((uint64_t)dp[5] << 24);
253 dpavlin 6 int y = dp[6] + (dp[7] << 8);
254     char direntry[65];
255    
256     dp += 8;
257    
258     /*
259     * As long as there is an \ or / in the filename, then we
260     * have not yet found the directory.
261     */
262     p = strchr(filename, '/');
263     if (p == NULL)
264     p = strchr(filename, '\\');
265    
266 dpavlin 34 #ifdef ISO_DEBUG
267     debug("%i%s: %i, %i, \"", filenr, filenr == found_dir?
268     " [CURRENT]" : "", x, y);
269     #endif
270 dpavlin 6 for (i=0; i<nlen && i<sizeof(direntry)-1; i++)
271     if (dp[i]) {
272     direntry[i] = dp[i];
273 dpavlin 34 #ifdef ISO_DEBUG
274     debug("%c", dp[i]);
275     #endif
276 dpavlin 6 } else
277     break;
278 dpavlin 34 #ifdef ISO_DEBUG
279     debug("\"\n");
280     #endif
281 dpavlin 6 direntry[i] = '\0';
282    
283     /* A directory name match? */
284 dpavlin 34 if ((p != NULL && strncasecmp(filename, direntry, nlen) == 0
285     && nlen == (size_t)p - (size_t)filename && found_dir == y)
286     || (p == NULL && direntry[0] == '\0') ) {
287 dpavlin 6 found_dir = filenr;
288 dpavlin 34 if (p != NULL)
289     filename = p+1;
290 dpavlin 6 dirofs = 2048 * (int64_t)x;
291     }
292    
293     dp += nlen;
294    
295     /* 16-bit aligned lenght: */
296     if (nlen & 1)
297     dp ++;
298    
299     filenr ++;
300     }
301    
302     p = strchr(filename, '/');
303     if (p == NULL)
304     p = strchr(filename, '\\');
305    
306     if (p != NULL) {
307     char *blah = filename_orig;
308    
309     fatal("could not find '%s' in /", filename);
310    
311     /* Print the first part of the filename: */
312     while (blah != filename)
313     fatal("%c", *blah++);
314    
315     fatal("\n");
316     goto ret;
317     }
318    
319     /* debug("dirofs = 0x%llx\n", (long long)dirofs); */
320    
321     /* Free the old dirbuf, and allocate a new one: */
322     free(dirbuf);
323     dirbuf = malloc(512);
324     if (dirbuf == NULL) {
325     fatal("out of memory in iso_load_bootblock()\n");
326     exit(1);
327     }
328    
329     for (;;) {
330 dpavlin 22 size_t len, i;
331 dpavlin 6
332     /* Too close to another sector? Then realign. */
333     if ((dirofs & 2047) + 70 > 2047) {
334     dirofs = (dirofs | 2047) + 1;
335     /* debug("realign dirofs = 0x%llx\n", dirofs); */
336     }
337    
338     res2 = diskimage_access(m, disk_id, disk_type, 0, dirofs,
339     dirbuf, 256);
340     if (!res2) {
341     fatal("Couldn't read the disk image. Aborting.\n");
342     goto ret;
343     }
344    
345     dp = dirbuf;
346     len = dp[0];
347     if (len < 2)
348     break;
349    
350     /*
351     * TODO: Actually parse the directory entry!
352     *
353     * Haha, this must be rewritten.
354     */
355     for (i=32; i<len; i++) {
356     if (i < len - strlen(filename))
357     if (strncasecmp(filename, (char *)dp + i,
358     strlen(filename)) == 0) {
359     /* The filename was found somewhere
360     in the directory entry. */
361     if (match_entry != NULL) {
362     fatal("TODO: I'm too lazy to"
363     " implement a correct "
364     "directory parser right "
365     "now... (BUG)\n");
366     exit(1);
367     }
368     match_entry = malloc(512);
369     if (match_entry == NULL) {
370     fatal("out of memory\n");
371     exit(1);
372     }
373     memcpy(match_entry, dp, 512);
374     break;
375     }
376     }
377    
378     dirofs += len;
379     }
380    
381     if (match_entry == NULL) {
382     char *blah = filename_orig;
383    
384     fatal("could not find '%s' in /", filename);
385    
386     /* Print the first part of the filename: */
387     while (blah != filename)
388     fatal("%c", *blah++);
389    
390     fatal("\n");
391     goto ret;
392     }
393    
394     fileofs = match_entry[2] + (match_entry[3] << 8) +
395 dpavlin 22 (match_entry[4] << 16) + ((uint64_t)match_entry[5] << 24);
396 dpavlin 6 filelen = match_entry[10] + (match_entry[11] << 8) +
397 dpavlin 22 (match_entry[12] << 16) + ((uint64_t)match_entry[13] << 24);
398 dpavlin 6 fileofs *= 2048;
399    
400     /* debug("filelen=%llx fileofs=%llx\n", (long long)filelen,
401     (long long)fileofs); */
402    
403     filebuf = malloc(filelen);
404     if (filebuf == NULL) {
405     fatal("could not allocate %lli bytes to read the file"
406     " from the disk image!\n", (long long)filelen);
407     goto ret;
408     }
409    
410 dpavlin 22 tmpfname = strdup("/tmp/gxemul.XXXXXXXXXXXX");
411 dpavlin 6
412     res2 = diskimage_access(m, disk_id, disk_type, 0, fileofs, filebuf,
413     filelen);
414     if (!res2) {
415     fatal("could not read the file from the disk image!\n");
416     goto ret;
417     }
418    
419 dpavlin 22 tmpfile_handle = mkstemp(tmpfname);
420 dpavlin 6 if (tmpfile_handle < 0) {
421 dpavlin 22 fatal("could not create %s\n", tmpfname);
422 dpavlin 6 exit(1);
423     }
424     write(tmpfile_handle, filebuf, filelen);
425     close(tmpfile_handle);
426    
427 dpavlin 22 debug("extracted %lli bytes into %s\n", (long long)filelen, tmpfname);
428    
429 dpavlin 6 /* Add the temporary filename to the load_namesp array: */
430     (*n_loadp)++;
431     new_array = malloc(sizeof(char *) * (*n_loadp));
432     if (new_array == NULL) {
433     fatal("out of memory\n");
434     exit(1);
435     }
436     memcpy(new_array, *load_namesp, sizeof(char *) * (*n_loadp));
437     *load_namesp = new_array;
438    
439     /* This adds a Backspace char in front of the filename; this
440     is a special hack which causes the file to be removed once
441     it has been loaded. */
442 dpavlin 22 tmpfname = realloc(tmpfname, strlen(tmpfname) + 2);
443     memmove(tmpfname + 1, tmpfname, strlen(tmpfname) + 1);
444     tmpfname[0] = 8;
445 dpavlin 6
446 dpavlin 22 (*load_namesp)[*n_loadp - 1] = tmpfname;
447 dpavlin 6
448     res = 1;
449    
450     ret:
451     if (dirbuf != NULL)
452     free(dirbuf);
453    
454     if (filebuf != NULL)
455     free(filebuf);
456    
457     if (match_entry != NULL)
458     free(match_entry);
459    
460     free(filename_orig);
461    
462     debug_indentation(-iadd);
463     return res;
464     }
465    
466    
467     /*
468 dpavlin 14 * apple_load_bootblock():
469     *
470     * Try to load a kernel from a disk image with an Apple Partition Table.
471     *
472     * TODO: This function uses too many magic offsets and so on; it should be
473     * cleaned up some day. See http://www.awprofessional.com/articles/
474     * article.asp?p=376123&seqNum=3&rl=1 for some info on the Apple
475     * partition format.
476     *
477     * Returns 1 on success, 0 on failure.
478     */
479     static int apple_load_bootblock(struct machine *m, struct cpu *cpu,
480     int disk_id, int disk_type, int *n_loadp, char ***load_namesp)
481     {
482     unsigned char buf[0x8000];
483     int res, partnr, n_partitions = 0, n_hfs_partitions = 0;
484     uint64_t hfs_start, hfs_length;
485    
486     res = diskimage_access(m, disk_id, disk_type, 0, 0x0, buf, sizeof(buf));
487     if (!res) {
488     fatal("apple_load_bootblock: couldn't read the disk "
489     "image. Aborting.\n");
490     return 0;
491     }
492    
493     partnr = 0;
494     do {
495     int start, length;
496     int ofs = 0x200 * (partnr + 1);
497     if (partnr == 0)
498     n_partitions = buf[ofs + 7];
499 dpavlin 22 start = ((uint64_t)buf[ofs + 8] << 24) + (buf[ofs + 9] << 16) +
500 dpavlin 14 (buf[ofs + 10] << 8) + buf[ofs + 11];
501 dpavlin 22 length = ((uint64_t)buf[ofs+12] << 24) + (buf[ofs + 13] << 16) +
502 dpavlin 14 (buf[ofs + 14] << 8) + buf[ofs + 15];
503    
504     debug("partition %i: '%s', type '%s', start %i, length %i\n",
505     partnr, buf + ofs + 0x10, buf + ofs + 0x30,
506     start, length);
507    
508     if (strcmp((char *)buf + ofs + 0x30, "Apple_HFS") == 0) {
509     n_hfs_partitions ++;
510     hfs_start = 512 * start;
511     hfs_length = 512 * length;
512     }
513    
514     /* Any more partitions? */
515     partnr ++;
516     } while (partnr < n_partitions);
517    
518     if (n_hfs_partitions == 0) {
519     fatal("Error: No HFS partition found! TODO\n");
520     return 0;
521     }
522     if (n_hfs_partitions >= 2) {
523     fatal("Error: Too many HFS partitions found! TODO\n");
524     return 0;
525     }
526    
527     return 0;
528     }
529    
530    
531     /*
532 dpavlin 2 * load_bootblock():
533     *
534     * For some emulation modes, it is possible to boot from a harddisk image by
535     * loading a bootblock from a specific disk offset into memory, and executing
536     * that, instead of requiring a separate kernel file. It is then up to the
537     * bootblock to load a kernel.
538 dpavlin 6 *
539     * Returns 1 on success, 0 on failure.
540 dpavlin 2 */
541 dpavlin 6 static int load_bootblock(struct machine *m, struct cpu *cpu,
542     int *n_loadp, char ***load_namesp)
543 dpavlin 2 {
544 dpavlin 6 int boot_disk_id, boot_disk_type = 0, n_blocks, res, readofs,
545     iso_type, retval = 0;
546 dpavlin 2 unsigned char minibuf[0x20];
547     unsigned char *bootblock_buf;
548 dpavlin 34 uint64_t bootblock_offset, base_offset;
549 dpavlin 2 uint64_t bootblock_loadaddr, bootblock_pc;
550    
551 dpavlin 6 boot_disk_id = diskimage_bootdev(m, &boot_disk_type);
552 dpavlin 2 if (boot_disk_id < 0)
553 dpavlin 6 return 0;
554 dpavlin 2
555 dpavlin 34 base_offset = diskimage_get_baseoffset(m, boot_disk_id, boot_disk_type);
556    
557 dpavlin 2 switch (m->machine_type) {
558 dpavlin 34
559     case MACHINE_DREAMCAST:
560     if (!diskimage_is_a_cdrom(cpu->machine, boot_disk_id,
561     boot_disk_type)) {
562     fatal("The Dreamcast emulation mode can only boot"
563     " from CD images, not from other disk types.\n");
564     exit(1);
565     }
566    
567     bootblock_buf = malloc(32768);
568     if (bootblock_buf == NULL) {
569     fprintf(stderr, "Out of memory.\n");
570     exit(1);
571     }
572    
573     debug("loading Dreamcast IP.BIN from %s id %i\n",
574     diskimage_types[boot_disk_type], boot_disk_id);
575    
576     res = diskimage_access(m, boot_disk_id, boot_disk_type,
577     0, base_offset, bootblock_buf, 0x8000);
578     if (!res) {
579     fatal("Couldn't read the disk image. Aborting.\n");
580     return 0;
581     }
582    
583     if (strncmp((char *)bootblock_buf, "SEGA ", 5) != 0) {
584     fatal("This is not a Dreamcast IP.BIN header.\n");
585     free(bootblock_buf);
586     return 0;
587     }
588    
589     /* Store IP.BIN at 0x8c008000, and set entry point. */
590     store_buf(cpu, 0x8c008000, (char *)bootblock_buf, 32768);
591     cpu->pc = 0x8c008300;
592    
593     /* Remember the name of the file to boot (1ST_READ.BIN): */
594     if (cpu->machine->boot_kernel_filename == NULL ||
595     cpu->machine->boot_kernel_filename[0] == '\0') {
596     int i = 0x60;
597     while (i < 0x70) {
598     if (bootblock_buf[i] == ' ')
599     bootblock_buf[i] = 0;
600     i ++;
601     }
602     cpu->machine->boot_kernel_filename = strdup(
603     (char *)bootblock_buf + 0x60);
604     }
605    
606     debug("boot filename: %s\n",
607     cpu->machine->boot_kernel_filename);
608    
609     free(bootblock_buf);
610    
611     break;
612    
613 dpavlin 22 case MACHINE_PMAX:
614 dpavlin 2 /*
615     * The first few bytes of a disk contains information about
616     * where the bootblock(s) are located. (These are all 32-bit
617     * little-endian words.)
618     *
619     * Offset 0x10 = load address
620     * 0x14 = initial PC value
621     * 0x18 = nr of 512-byte blocks to read
622     * 0x1c = offset on disk to where the bootblocks
623     * are (in 512-byte units)
624     * 0x20 = nr of blocks to read...
625     * 0x24 = offset...
626     *
627     * nr of blocks to read and offset are repeated until nr of
628     * blocks to read is zero.
629     */
630 dpavlin 6 res = diskimage_access(m, boot_disk_id, boot_disk_type, 0, 0,
631 dpavlin 2 minibuf, sizeof(minibuf));
632    
633     bootblock_loadaddr = minibuf[0x10] + (minibuf[0x11] << 8)
634 dpavlin 22 + (minibuf[0x12] << 16) + ((uint64_t)minibuf[0x13] << 24);
635 dpavlin 2
636     /* Convert loadaddr to uncached: */
637     if ((bootblock_loadaddr & 0xf0000000ULL) != 0x80000000 &&
638 dpavlin 32 (bootblock_loadaddr & 0xf0000000ULL) != 0xa0000000) {
639     fatal("\nWARNING! Weird load address 0x%08"PRIx32
640     " for SCSI id %i.\n\n",
641     (uint32_t)bootblock_loadaddr, boot_disk_id);
642     if (bootblock_loadaddr == 0) {
643     fatal("I'm assuming that this is _not_ a "
644     "DEC bootblock.\nAre you sure you are"
645     " booting from the correct disk?\n");
646     exit(1);
647     }
648     }
649    
650 dpavlin 2 bootblock_loadaddr &= 0x0fffffffULL;
651     bootblock_loadaddr |= 0xffffffffa0000000ULL;
652    
653     bootblock_pc = minibuf[0x14] + (minibuf[0x15] << 8)
654 dpavlin 22 + (minibuf[0x16] << 16) + ((uint64_t)minibuf[0x17] << 24);
655 dpavlin 2
656     bootblock_pc &= 0x0fffffffULL;
657     bootblock_pc |= 0xffffffffa0000000ULL;
658     cpu->pc = bootblock_pc;
659    
660     debug("DEC boot: loadaddr=0x%08x, pc=0x%08x",
661     (int)bootblock_loadaddr, (int)bootblock_pc);
662    
663     readofs = 0x18;
664    
665     for (;;) {
666 dpavlin 6 res = diskimage_access(m, boot_disk_id, boot_disk_type,
667     0, readofs, minibuf, sizeof(minibuf));
668 dpavlin 2 if (!res) {
669 dpavlin 6 fatal("Couldn't read the disk image. "
670     "Aborting.\n");
671     return 0;
672 dpavlin 2 }
673    
674     n_blocks = minibuf[0] + (minibuf[1] << 8)
675 dpavlin 22 + (minibuf[2] << 16) + ((uint64_t)minibuf[3] << 24);
676 dpavlin 2
677 dpavlin 22 bootblock_offset = (minibuf[4] + (minibuf[5] << 8) +
678     (minibuf[6]<<16) + ((uint64_t)minibuf[7]<<24)) * 512;
679 dpavlin 2
680     if (n_blocks < 1)
681     break;
682    
683     debug(readofs == 0x18? ": %i" : " + %i", n_blocks);
684    
685     if (n_blocks * 512 > 65536)
686     fatal("\nWARNING! Unusually large bootblock "
687     "(%i bytes)\n\n", n_blocks * 512);
688    
689     bootblock_buf = malloc(n_blocks * 512);
690     if (bootblock_buf == NULL) {
691     fprintf(stderr, "out of memory in "
692     "load_bootblock()\n");
693     exit(1);
694     }
695    
696 dpavlin 6 res = diskimage_access(m, boot_disk_id, boot_disk_type,
697     0, bootblock_offset, bootblock_buf, n_blocks * 512);
698 dpavlin 2 if (!res) {
699     fatal("WARNING: could not load bootblocks from"
700     " disk offset 0x%llx\n",
701     (long long)bootblock_offset);
702     }
703    
704     store_buf(cpu, bootblock_loadaddr,
705     (char *)bootblock_buf, n_blocks * 512);
706    
707     bootblock_loadaddr += 512*n_blocks;
708     free(bootblock_buf);
709     readofs += 8;
710     }
711    
712     debug(readofs == 0x18? ": no blocks?\n" : " blocks\n");
713 dpavlin 6 return 1;
714     }
715    
716    
717     /*
718     * Try reading a kernel manually from the disk. The code here
719 dpavlin 18 * does not rely on machine-dependent boot blocks etc.
720 dpavlin 6 */
721 dpavlin 34 /* ISO9660: (0x800 bytes at 0x8000 + base_offset) */
722 dpavlin 6 bootblock_buf = malloc(0x800);
723     if (bootblock_buf == NULL) {
724     fprintf(stderr, "Out of memory.\n");
725 dpavlin 2 exit(1);
726     }
727 dpavlin 6
728     res = diskimage_access(m, boot_disk_id, boot_disk_type,
729 dpavlin 34 0, base_offset + 0x8000, bootblock_buf, 0x800);
730 dpavlin 6 if (!res) {
731     fatal("Couldn't read the disk image. Aborting.\n");
732     return 0;
733     }
734    
735     iso_type = 0;
736     if (strncmp((char *)bootblock_buf+1, "CD001", 5) == 0)
737     iso_type = 1;
738     if (strncmp((char *)bootblock_buf+1, "CDW01", 5) == 0)
739     iso_type = 2;
740     if (strncmp((char *)bootblock_buf+1, "CDROM", 5) == 0)
741     iso_type = 3;
742    
743     if (iso_type != 0) {
744 dpavlin 32 /*
745     * If the user specified a kernel name, then load it from
746     * disk.
747     */
748 dpavlin 6 if (cpu->machine->boot_kernel_filename == NULL ||
749     cpu->machine->boot_kernel_filename[0] == '\0')
750     fatal("\nISO9660 filesystem, but no kernel "
751     "specified? (Use the -j option.)\n");
752     else
753     retval = iso_load_bootblock(m, cpu, boot_disk_id,
754     boot_disk_type, iso_type, bootblock_buf,
755     n_loadp, load_namesp);
756     }
757    
758 dpavlin 14 if (retval != 0)
759     goto ret_ok;
760    
761     /* Apple parition table: */
762     res = diskimage_access(m, boot_disk_id, boot_disk_type,
763     0, 0x0, bootblock_buf, 0x800);
764     if (!res) {
765     fatal("Couldn't read the disk image. Aborting.\n");
766     return 0;
767     }
768     if (bootblock_buf[0x000] == 'E' && bootblock_buf[0x001] == 'R' &&
769     bootblock_buf[0x200] == 'P' && bootblock_buf[0x201] == 'M') {
770     if (cpu->machine->boot_kernel_filename == NULL ||
771     cpu->machine->boot_kernel_filename[0] == '\0')
772     fatal("\nApple partition table, but no kernel "
773     "specified? (Use the -j option.)\n");
774     else
775     retval = apple_load_bootblock(m, cpu, boot_disk_id,
776     boot_disk_type, n_loadp, load_namesp);
777     }
778    
779     ret_ok:
780 dpavlin 6 free(bootblock_buf);
781     return retval;
782 dpavlin 2 }
783    
784    
785     /*
786     * emul_new():
787     *
788     * Returns a reasonably initialized struct emul.
789     */
790 dpavlin 34 struct emul *emul_new(char *name, int id)
791 dpavlin 2 {
792     struct emul *e;
793     e = malloc(sizeof(struct emul));
794     if (e == NULL) {
795     fprintf(stderr, "out of memory in emul_new()\n");
796     exit(1);
797     }
798    
799     memset(e, 0, sizeof(struct emul));
800    
801 dpavlin 34 e->path = malloc(15);
802     if (e->path == NULL) {
803     fprintf(stderr, "out of memory\n");
804     exit(1);
805     }
806     snprintf(e->path, 15, "emul[%i]", id);
807    
808 dpavlin 32 e->settings = settings_new();
809    
810     settings_add(e->settings, "n_machines", 0,
811     SETTINGS_TYPE_INT, SETTINGS_FORMAT_DECIMAL,
812     (void *) &e->n_machines);
813    
814     /* TODO: More settings? */
815    
816 dpavlin 2 /* Sane default values: */
817     e->n_machines = 0;
818 dpavlin 10 e->next_serial_nr = 1;
819 dpavlin 2
820     if (name != NULL) {
821     e->name = strdup(name);
822     if (e->name == NULL) {
823     fprintf(stderr, "out of memory in emul_new()\n");
824     exit(1);
825     }
826 dpavlin 32
827     settings_add(e->settings, "name", 0,
828     SETTINGS_TYPE_STRING, SETTINGS_FORMAT_STRING,
829     (void *) &e->name);
830 dpavlin 2 }
831    
832     return e;
833     }
834    
835    
836     /*
837 dpavlin 32 * emul_destroy():
838     *
839     * Destroys a previously created emul object.
840     */
841     void emul_destroy(struct emul *emul)
842     {
843     int i;
844    
845     if (emul->name != NULL) {
846     settings_remove(emul->settings, "name");
847     free(emul->name);
848     }
849    
850     for (i=0; i<emul->n_machines; i++)
851     machine_destroy(emul->machines[i]);
852    
853     if (emul->machines != NULL)
854     free(emul->machines);
855    
856     /* Remove any remaining level-1 settings: */
857     settings_remove_all(emul->settings);
858     settings_destroy(emul->settings);
859    
860     free(emul);
861     }
862    
863    
864     /*
865 dpavlin 2 * emul_add_machine():
866     *
867     * Calls machine_new(), adds the new machine into the emul struct, and
868     * returns a pointer to the new machine.
869     *
870     * This function should be used instead of manually calling machine_new().
871     */
872     struct machine *emul_add_machine(struct emul *e, char *name)
873     {
874     struct machine *m;
875 dpavlin 32 char tmpstr[20];
876     int i;
877 dpavlin 2
878 dpavlin 34 m = machine_new(name, e, e->n_machines);
879 dpavlin 2 m->serial_nr = (e->next_serial_nr ++);
880    
881 dpavlin 32 i = e->n_machines;
882    
883 dpavlin 2 e->n_machines ++;
884     e->machines = realloc(e->machines,
885     sizeof(struct machine *) * e->n_machines);
886     if (e->machines == NULL) {
887     fprintf(stderr, "emul_add_machine(): out of memory\n");
888     exit(1);
889     }
890    
891 dpavlin 32 e->machines[i] = m;
892    
893     snprintf(tmpstr, sizeof(tmpstr), "machine[%i]", i);
894     settings_add(e->settings, tmpstr, 1, SETTINGS_TYPE_SUBSETTINGS, 0,
895     e->machines[i]->settings);
896    
897 dpavlin 2 return m;
898     }
899    
900    
901     /*
902     * add_arc_components():
903     *
904     * This function adds ARCBIOS memory descriptors for the loaded program,
905     * and ARCBIOS components for SCSI devices.
906     */
907     static void add_arc_components(struct machine *m)
908     {
909     struct cpu *cpu = m->cpus[m->bootstrap_cpu];
910     uint64_t start = cpu->pc & 0x1fffffff;
911     uint64_t len = 0xc00000 - start;
912     struct diskimage *d;
913     uint64_t scsicontroller, scsidevice, scsidisk;
914    
915     if ((cpu->pc >> 60) != 0xf) {
916     start = cpu->pc & 0xffffffffffULL;
917     len = 0xc00000 - start;
918     }
919    
920     len += 1048576 * m->memory_offset_in_mb;
921    
922 dpavlin 12 /*
923     * NOTE/TODO: magic 12MB end of load program area
924     *
925     * Hm. This breaks the old FreeBSD/MIPS snapshots...
926     */
927     #if 0
928 dpavlin 2 arcbios_add_memory_descriptor(cpu,
929     0x60000 + m->memory_offset_in_mb * 1048576,
930     start-0x60000 - m->memory_offset_in_mb * 1048576,
931     ARCBIOS_MEM_FreeMemory);
932 dpavlin 12 #endif
933 dpavlin 2 arcbios_add_memory_descriptor(cpu,
934     start, len, ARCBIOS_MEM_LoadedProgram);
935    
936 dpavlin 6 scsicontroller = arcbios_get_scsicontroller(m);
937 dpavlin 2 if (scsicontroller == 0)
938     return;
939    
940     /* TODO: The device 'name' should defined be somewhere else. */
941    
942     d = m->first_diskimage;
943     while (d != NULL) {
944     if (d->type == DISKIMAGE_SCSI) {
945     int a, b, flags = COMPONENT_FLAG_Input;
946     char component_string[100];
947     char *name = "DEC RZ58 (C) DEC2000";
948    
949     /* Read-write, or read-only? */
950     if (d->writable)
951     flags |= COMPONENT_FLAG_Output;
952     else
953     flags |= COMPONENT_FLAG_ReadOnly;
954    
955     a = COMPONENT_TYPE_DiskController;
956     b = COMPONENT_TYPE_DiskPeripheral;
957    
958     if (d->is_a_cdrom) {
959     flags |= COMPONENT_FLAG_Removable;
960     a = COMPONENT_TYPE_CDROMController;
961     b = COMPONENT_TYPE_FloppyDiskPeripheral;
962     name = "NEC CD-ROM CDR-210P 1.0 ";
963     }
964    
965     scsidevice = arcbios_addchild_manual(cpu,
966     COMPONENT_CLASS_ControllerClass,
967     a, flags, 1, 2, d->id, 0xffffffff,
968     name, scsicontroller, NULL, 0);
969    
970     scsidisk = arcbios_addchild_manual(cpu,
971     COMPONENT_CLASS_PeripheralClass,
972     b, flags, 1, 2, 0, 0xffffffff, NULL,
973     scsidevice, NULL, 0);
974    
975     /*
976     * Add device string to component address mappings:
977     * "scsi(0)disk(0)rdisk(0)partition(0)"
978     */
979    
980     if (d->is_a_cdrom) {
981     snprintf(component_string,
982     sizeof(component_string),
983     "scsi(0)cdrom(%i)", d->id);
984 dpavlin 6 arcbios_add_string_to_component(m,
985 dpavlin 2 component_string, scsidevice);
986    
987     snprintf(component_string,
988     sizeof(component_string),
989     "scsi(0)cdrom(%i)fdisk(0)", d->id);
990 dpavlin 6 arcbios_add_string_to_component(m,
991 dpavlin 2 component_string, scsidisk);
992     } else {
993     snprintf(component_string,
994     sizeof(component_string),
995     "scsi(0)disk(%i)", d->id);
996 dpavlin 6 arcbios_add_string_to_component(m,
997 dpavlin 2 component_string, scsidevice);
998    
999     snprintf(component_string,
1000     sizeof(component_string),
1001     "scsi(0)disk(%i)rdisk(0)", d->id);
1002 dpavlin 6 arcbios_add_string_to_component(m,
1003 dpavlin 2 component_string, scsidisk);
1004     }
1005     }
1006    
1007     d = d->next;
1008     }
1009     }
1010    
1011    
1012     /*
1013     * emul_machine_setup():
1014     *
1015     * o) Initialize the hardware (RAM, devices, CPUs, ...) which
1016     * will be emulated in this machine.
1017     *
1018     * o) Load ROM code and/or other programs into emulated memory.
1019     *
1020     * o) Special hacks needed after programs have been loaded.
1021     */
1022     void emul_machine_setup(struct machine *m, int n_load, char **load_names,
1023     int n_devices, char **device_names)
1024     {
1025     struct cpu *cpu;
1026 dpavlin 22 int i, iadd = DEBUG_INDENTATION;
1027 dpavlin 6 uint64_t memory_amount, entrypoint = 0, gp = 0, toc = 0;
1028 dpavlin 2 int byte_order;
1029    
1030     debug("machine \"%s\":\n", m->name);
1031     debug_indentation(iadd);
1032    
1033     /* For userland-only, this decides which ARCH/cpu_name to use: */
1034     if (m->machine_type == MACHINE_USERLAND && m->userland_emul != NULL) {
1035     useremul_name_to_useremul(NULL, m->userland_emul,
1036     &m->arch, &m->machine_name, &m->cpu_name);
1037     if (m->arch == ARCH_NOARCH) {
1038     printf("Unsupported userland emulation mode.\n");
1039     exit(1);
1040     }
1041     }
1042    
1043     if (m->machine_type == MACHINE_NONE) {
1044     fatal("No machine type specified?\n");
1045     exit(1);
1046     }
1047    
1048     m->cpu_family = cpu_family_ptr_by_number(m->arch);
1049    
1050 dpavlin 12 if (m->arch == ARCH_ALPHA)
1051     m->arch_pagesize = 8192;
1052    
1053 dpavlin 2 machine_memsize_fix(m);
1054    
1055     /*
1056     * Create the system's memory:
1057     *
1058     * (Don't print the amount for userland-only emulation; the
1059     * size doesn't matter.)
1060     */
1061     if (m->machine_type != MACHINE_USERLAND)
1062     debug("memory: %i MB", m->physical_ram_in_mb);
1063     memory_amount = (uint64_t)m->physical_ram_in_mb * 1048576;
1064     if (m->memory_offset_in_mb > 0) {
1065     /*
1066     * A special hack is used for some SGI models,
1067     * where memory is offset by 128MB to leave room for
1068     * EISA space and other things.
1069     */
1070     debug(" (offset by %iMB)", m->memory_offset_in_mb);
1071     memory_amount += 1048576 * m->memory_offset_in_mb;
1072     }
1073 dpavlin 12 m->memory = memory_new(memory_amount, m->arch);
1074 dpavlin 2 if (m->machine_type != MACHINE_USERLAND)
1075     debug("\n");
1076    
1077     /* Create CPUs: */
1078     if (m->cpu_name == NULL)
1079     machine_default_cputype(m);
1080     if (m->ncpus == 0) {
1081     /* TODO: This should be moved elsewhere... */
1082     if (m->machine_type == MACHINE_BEBOX)
1083     m->ncpus = 2;
1084     else if (m->machine_type == MACHINE_ARC &&
1085     m->machine_subtype == MACHINE_ARC_NEC_R96)
1086     m->ncpus = 2;
1087     else if (m->machine_type == MACHINE_ARC &&
1088     m->machine_subtype == MACHINE_ARC_NEC_R98)
1089     m->ncpus = 4;
1090     else
1091     m->ncpus = 1;
1092     }
1093     m->cpus = malloc(sizeof(struct cpu *) * m->ncpus);
1094     if (m->cpus == NULL) {
1095     fprintf(stderr, "out of memory\n");
1096     exit(1);
1097     }
1098     memset(m->cpus, 0, sizeof(struct cpu *) * m->ncpus);
1099    
1100     debug("cpu0");
1101     if (m->ncpus > 1)
1102     debug(" .. cpu%i", m->ncpus - 1);
1103     debug(": ");
1104     for (i=0; i<m->ncpus; i++) {
1105     m->cpus[i] = cpu_new(m->memory, m, i, m->cpu_name);
1106 dpavlin 24 if (m->cpus[i] == NULL) {
1107     fprintf(stderr, "Unable to create CPU object. "
1108     "Aborting.");
1109     exit(1);
1110     }
1111 dpavlin 2 }
1112     debug("\n");
1113    
1114 dpavlin 10 #if 0
1115     /* Special case: The Playstation Portable has an additional CPU: */
1116     if (m->machine_type == MACHINE_PSP) {
1117     debug("cpu%i: ", m->ncpus);
1118     m->cpus[m->ncpus] = cpu_new(m->memory, m,
1119     0 /* use 0 here to show info with debug() */,
1120     "Allegrex" /* TODO */);
1121     debug("\n");
1122     m->ncpus ++;
1123     }
1124     #endif
1125    
1126 dpavlin 2 if (m->use_random_bootstrap_cpu)
1127     m->bootstrap_cpu = random() % m->ncpus;
1128     else
1129     m->bootstrap_cpu = 0;
1130    
1131     cpu = m->cpus[m->bootstrap_cpu];
1132    
1133     /* Set cpu->useremul_syscall, and use userland_memory_rw: */
1134     if (m->userland_emul != NULL) {
1135     useremul_name_to_useremul(cpu,
1136     m->userland_emul, NULL, NULL, NULL);
1137 dpavlin 12
1138     switch (m->arch) {
1139     #ifdef ENABLE_ALPHA
1140     case ARCH_ALPHA:
1141     cpu->memory_rw = alpha_userland_memory_rw;
1142     break;
1143     #endif
1144     default:cpu->memory_rw = userland_memory_rw;
1145     }
1146 dpavlin 2 }
1147    
1148     if (m->use_x11)
1149     x11_init(m);
1150    
1151     /* Fill memory with random bytes: */
1152     if (m->random_mem_contents) {
1153     for (i=0; i<m->physical_ram_in_mb * 1048576; i+=256) {
1154     unsigned char data[256];
1155     unsigned int j;
1156     for (j=0; j<sizeof(data); j++)
1157     data[j] = random() & 255;
1158 dpavlin 6 cpu->memory_rw(cpu, m->memory, i, data, sizeof(data),
1159     MEM_WRITE, CACHE_NONE | NO_EXCEPTIONS | PHYSICAL);
1160 dpavlin 2 }
1161     }
1162    
1163     if (m->userland_emul != NULL) {
1164     /*
1165     * For userland-only emulation, no machine emulation
1166     * is needed.
1167     */
1168     } else {
1169     for (i=0; i<n_devices; i++)
1170     device_add(m, device_names[i]);
1171    
1172     machine_setup(m);
1173     }
1174    
1175     diskimage_dump_info(m);
1176 dpavlin 22 console_debug_dump(m);
1177 dpavlin 2
1178     /* Load files (ROM code, boot code, ...) into memory: */
1179     if (n_load == 0) {
1180 dpavlin 6 if (m->first_diskimage != NULL) {
1181     if (!load_bootblock(m, cpu, &n_load, &load_names)) {
1182     fprintf(stderr, "\nNo executable files were"
1183     " specified, and booting directly from disk"
1184     " failed.\n");
1185     exit(1);
1186     }
1187     } else {
1188 dpavlin 2 fprintf(stderr, "No executable file(s) loaded, and "
1189     "we are not booting directly from a disk image."
1190     "\nAborting.\n");
1191     exit(1);
1192     }
1193     }
1194    
1195     while (n_load > 0) {
1196 dpavlin 6 FILE *tmp_f;
1197     char *name_to_load = *load_names;
1198     int remove_after_load = 0;
1199    
1200     /* Special hack for removing temporary files: */
1201     if (name_to_load[0] == 8) {
1202     name_to_load ++;
1203     remove_after_load = 1;
1204     }
1205    
1206     /*
1207 dpavlin 10 * gzipped files are automagically gunzipped:
1208     * NOTE/TODO: This isn't secure. system() is used.
1209 dpavlin 6 */
1210     tmp_f = fopen(name_to_load, "r");
1211     if (tmp_f != NULL) {
1212     unsigned char buf[2]; /* gzip header */
1213     memset(buf, 0, sizeof(buf));
1214     fread(buf, 1, sizeof(buf), tmp_f);
1215     if (buf[0]==0x1f && buf[1]==0x8b) {
1216 dpavlin 10 size_t zzlen = strlen(name_to_load)*2 + 100;
1217     char *zz = malloc(zzlen);
1218 dpavlin 6 debug("gunziping %s\n", name_to_load);
1219 dpavlin 10 /*
1220     * gzip header found. If this was a file
1221     * extracted from, say, a CDROM image, then it
1222     * already has a temporary name. Otherwise we
1223     * have to gunzip into a temporary file.
1224     */
1225     if (remove_after_load) {
1226     snprintf(zz, zzlen, "mv %s %s.gz",
1227     name_to_load, name_to_load);
1228     system(zz);
1229     snprintf(zz, zzlen, "gunzip %s.gz",
1230     name_to_load);
1231     system(zz);
1232     } else {
1233     /* gunzip into new temp file: */
1234     int tmpfile_handle;
1235     char *new_temp_name =
1236     strdup("/tmp/gxemul.XXXXXXXXXXXX");
1237     tmpfile_handle = mkstemp(new_temp_name);
1238     close(tmpfile_handle);
1239     snprintf(zz, zzlen, "gunzip -c '%s' > "
1240     "%s", name_to_load, new_temp_name);
1241     system(zz);
1242     name_to_load = new_temp_name;
1243     remove_after_load = 1;
1244     }
1245 dpavlin 6 free(zz);
1246     }
1247     fclose(tmp_f);
1248     }
1249    
1250 dpavlin 10 /*
1251     * Ugly (but usable) hack for Playstation Portable: If the
1252     * filename ends with ".pbp" and the file contains an ELF
1253     * header, then extract the ELF file into a temporary file.
1254     */
1255     if (strlen(name_to_load) > 4 && strcasecmp(name_to_load +
1256     strlen(name_to_load) - 4, ".pbp") == 0 &&
1257     (tmp_f = fopen(name_to_load, "r")) != NULL) {
1258     off_t filesize, j, found=0;
1259     unsigned char *buf;
1260     fseek(tmp_f, 0, SEEK_END);
1261     filesize = ftello(tmp_f);
1262     fseek(tmp_f, 0, SEEK_SET);
1263     buf = malloc(filesize);
1264     if (buf == NULL) {
1265     fprintf(stderr, "out of memory while trying"
1266     " to read %s\n", name_to_load);
1267     exit(1);
1268     }
1269     fread(buf, 1, filesize, tmp_f);
1270     fclose(tmp_f);
1271     /* Search for the ELF header, from offset 1 (!): */
1272     for (j=1; j<filesize - 4; j++)
1273     if (memcmp(buf + j, ELFMAG, SELFMAG) == 0) {
1274     found = j;
1275     break;
1276     }
1277     if (found != 0) {
1278     int tmpfile_handle;
1279     char *new_temp_name =
1280     strdup("/tmp/gxemul.XXXXXXXXXXXX");
1281     debug("extracting ELF from %s (offset 0x%x)\n",
1282     name_to_load, (int)found);
1283     tmpfile_handle = mkstemp(new_temp_name);
1284     write(tmpfile_handle, buf + found,
1285     filesize - found);
1286     close(tmpfile_handle);
1287     name_to_load = new_temp_name;
1288     remove_after_load = 1;
1289     }
1290     }
1291    
1292 dpavlin 2 byte_order = NO_BYTE_ORDER_OVERRIDE;
1293    
1294 dpavlin 6 /*
1295     * Load the file: :-)
1296     */
1297     file_load(m, m->memory, name_to_load, &entrypoint,
1298 dpavlin 2 m->arch, &gp, &byte_order, &toc);
1299    
1300 dpavlin 6 if (remove_after_load) {
1301     debug("removing %s\n", name_to_load);
1302     unlink(name_to_load);
1303     }
1304    
1305 dpavlin 2 if (byte_order != NO_BYTE_ORDER_OVERRIDE)
1306     cpu->byte_order = byte_order;
1307    
1308     cpu->pc = entrypoint;
1309    
1310     switch (m->arch) {
1311 dpavlin 14
1312     case ARCH_ALPHA:
1313 dpavlin 18 /* For position-independent code: */
1314 dpavlin 14 cpu->cd.alpha.r[ALPHA_T12] = cpu->pc;
1315     break;
1316    
1317     case ARCH_ARM:
1318 dpavlin 20 if (cpu->pc & 3) {
1319     fatal("ARM: lowest bits of pc set: TODO\n");
1320     exit(1);
1321     }
1322 dpavlin 14 cpu->pc &= 0xfffffffc;
1323     break;
1324    
1325     case ARCH_AVR:
1326     cpu->pc &= 0xfffff;
1327     if (cpu->pc & 1) {
1328     fatal("AVR: lowest bit of pc set: TODO\n");
1329     exit(1);
1330     }
1331     break;
1332    
1333 dpavlin 32 case ARCH_RCA180X:
1334     cpu->pc &= 0xffff;
1335     break;
1336    
1337 dpavlin 14 case ARCH_M68K:
1338     break;
1339    
1340 dpavlin 2 case ARCH_MIPS:
1341 dpavlin 20 if ((cpu->pc >> 32) == 0 && (cpu->pc & 0x80000000ULL))
1342 dpavlin 2 cpu->pc |= 0xffffffff00000000ULL;
1343    
1344     cpu->cd.mips.gpr[MIPS_GPR_GP] = gp;
1345    
1346     if ((cpu->cd.mips.gpr[MIPS_GPR_GP] >> 32) == 0 &&
1347     (cpu->cd.mips.gpr[MIPS_GPR_GP] & 0x80000000ULL))
1348     cpu->cd.mips.gpr[MIPS_GPR_GP] |=
1349     0xffffffff00000000ULL;
1350     break;
1351 dpavlin 4
1352 dpavlin 2 case ARCH_PPC:
1353 dpavlin 6 /* See http://www.linuxbase.org/spec/ELF/ppc64/
1354     spec/x458.html for more info. */
1355 dpavlin 2 cpu->cd.ppc.gpr[2] = toc;
1356 dpavlin 6 /* TODO */
1357 dpavlin 14 if (cpu->cd.ppc.bits == 32)
1358     cpu->pc &= 0xffffffffULL;
1359 dpavlin 2 break;
1360 dpavlin 4
1361 dpavlin 14 case ARCH_SH:
1362 dpavlin 30 if (cpu->cd.sh.cpu_type.bits == 32)
1363 dpavlin 14 cpu->pc &= 0xffffffffULL;
1364     cpu->pc &= ~1;
1365 dpavlin 12 break;
1366    
1367 dpavlin 2 case ARCH_SPARC:
1368     break;
1369 dpavlin 4
1370 dpavlin 28 case ARCH_TRANSPUTER:
1371     cpu->pc &= 0xffffffffULL;
1372     break;
1373    
1374 dpavlin 2 default:
1375     fatal("emul_machine_setup(): Internal error: "
1376     "Unimplemented arch %i\n", m->arch);
1377     exit(1);
1378     }
1379    
1380     /*
1381     * For userland emulation, the remaining items
1382     * on the command line will be passed as parameters
1383     * to the emulated program, and will not be treated
1384     * as filenames to load into the emulator.
1385     * The program's name will be in load_names[0], and the
1386     * rest of the parameters in load_names[1] and up.
1387     */
1388     if (m->userland_emul != NULL)
1389     break;
1390    
1391     n_load --;
1392     load_names ++;
1393     }
1394    
1395     if (m->byte_order_override != NO_BYTE_ORDER_OVERRIDE)
1396     cpu->byte_order = m->byte_order_override;
1397    
1398     /* Same byte order and entrypoint for all CPUs: */
1399     for (i=0; i<m->ncpus; i++)
1400     if (i != m->bootstrap_cpu) {
1401     m->cpus[i]->byte_order = cpu->byte_order;
1402     m->cpus[i]->pc = cpu->pc;
1403     }
1404    
1405     if (m->userland_emul != NULL)
1406     useremul_setup(cpu, n_load, load_names);
1407    
1408     /* Startup the bootstrap CPU: */
1409 dpavlin 30 cpu->running = 1;
1410 dpavlin 2
1411     /* ... or pause all CPUs, if start_paused is set: */
1412     if (m->start_paused) {
1413     for (i=0; i<m->ncpus; i++)
1414     m->cpus[i]->running = 0;
1415     }
1416    
1417     /* Add PC dump points: */
1418     add_dump_points(m);
1419    
1420     /* TODO: This is MIPS-specific! */
1421 dpavlin 22 if (m->machine_type == MACHINE_PMAX &&
1422 dpavlin 2 cpu->cd.mips.cpu_type.mmu_model == MMU3K)
1423     add_symbol_name(&m->symbol_context,
1424 dpavlin 12 0x9fff0000, 0x10000, "r2k3k_cache", 0, 0);
1425 dpavlin 2
1426     symbol_recalc_sizes(&m->symbol_context);
1427    
1428     /* Special hack for ARC/SGI emulation: */
1429     if ((m->machine_type == MACHINE_ARC ||
1430     m->machine_type == MACHINE_SGI) && m->prom_emulation)
1431     add_arc_components(m);
1432    
1433     debug("starting cpu%i at ", m->bootstrap_cpu);
1434     switch (m->arch) {
1435 dpavlin 14
1436     case ARCH_ARM:
1437     /* ARM cpus aren't 64-bit: */
1438     debug("0x%08x", (int)entrypoint);
1439     break;
1440    
1441     case ARCH_AVR:
1442     /* Atmel AVR uses a 16-bit or 22-bit program counter: */
1443     debug("0x%04x", (int)entrypoint);
1444     break;
1445    
1446 dpavlin 2 case ARCH_MIPS:
1447 dpavlin 12 if (cpu->is_32bit) {
1448 dpavlin 2 debug("0x%08x", (int)m->cpus[
1449     m->bootstrap_cpu]->pc);
1450     if (cpu->cd.mips.gpr[MIPS_GPR_GP] != 0)
1451     debug(" (gp=0x%08x)", (int)m->cpus[
1452     m->bootstrap_cpu]->cd.mips.gpr[
1453     MIPS_GPR_GP]);
1454     } else {
1455     debug("0x%016llx", (long long)m->cpus[
1456     m->bootstrap_cpu]->pc);
1457     if (cpu->cd.mips.gpr[MIPS_GPR_GP] != 0)
1458     debug(" (gp=0x%016llx)", (long long)
1459     cpu->cd.mips.gpr[MIPS_GPR_GP]);
1460     }
1461     break;
1462 dpavlin 14
1463 dpavlin 2 case ARCH_PPC:
1464     if (cpu->cd.ppc.bits == 32)
1465     debug("0x%08x", (int)entrypoint);
1466     else
1467     debug("0x%016llx", (long long)entrypoint);
1468     break;
1469 dpavlin 14
1470 dpavlin 2 default:
1471 dpavlin 22 if (cpu->is_32bit)
1472     debug("0x%08x", (int)cpu->pc);
1473     else
1474     debug("0x%016llx", (long long)cpu->pc);
1475 dpavlin 2 }
1476     debug("\n");
1477    
1478     debug_indentation(-iadd);
1479     }
1480    
1481    
1482     /*
1483     * emul_dumpinfo():
1484     *
1485     * Dump info about all machines in an emul.
1486     */
1487     void emul_dumpinfo(struct emul *e)
1488     {
1489 dpavlin 22 int j, nm, iadd = DEBUG_INDENTATION;
1490 dpavlin 2
1491     if (e->net != NULL)
1492     net_dumpinfo(e->net);
1493    
1494     nm = e->n_machines;
1495     for (j=0; j<nm; j++) {
1496     debug("machine %i: \"%s\"\n", j, e->machines[j]->name);
1497     debug_indentation(iadd);
1498     machine_dumpinfo(e->machines[j]);
1499     debug_indentation(-iadd);
1500     }
1501     }
1502    
1503    
1504     /*
1505     * emul_simple_init():
1506     *
1507     * For a normal setup:
1508     *
1509     * o) Initialize a network.
1510     * o) Initialize one machine.
1511     *
1512     * For a userland-only setup:
1513     *
1514     * o) Initialize a "pseudo"-machine.
1515     */
1516     void emul_simple_init(struct emul *emul)
1517     {
1518 dpavlin 22 int iadd = DEBUG_INDENTATION;
1519 dpavlin 2 struct machine *m;
1520    
1521     if (emul->n_machines != 1) {
1522     fprintf(stderr, "emul_simple_init(): n_machines != 1\n");
1523     exit(1);
1524     }
1525    
1526     m = emul->machines[0];
1527    
1528     if (m->userland_emul == NULL) {
1529     debug("Simple setup...\n");
1530     debug_indentation(iadd);
1531    
1532 dpavlin 10 /* Create a simple network: */
1533 dpavlin 2 emul->net = net_init(emul, NET_INIT_FLAG_GATEWAY,
1534 dpavlin 32 NET_DEFAULT_IPV4_MASK,
1535     NET_DEFAULT_IPV4_LEN,
1536     NULL, 0, 0, NULL);
1537 dpavlin 2 } else {
1538     /* Userland pseudo-machine: */
1539     debug("Syscall emulation (userland-only) setup...\n");
1540     debug_indentation(iadd);
1541     }
1542    
1543     /* Create the machine: */
1544     emul_machine_setup(m, extra_argc, extra_argv, 0, NULL);
1545    
1546     debug_indentation(-iadd);
1547     }
1548    
1549    
1550     /*
1551     * emul_create_from_configfile():
1552     *
1553     * Create an emul struct by reading settings from a configuration file.
1554     */
1555 dpavlin 34 struct emul *emul_create_from_configfile(char *fname, int id)
1556 dpavlin 2 {
1557 dpavlin 22 int iadd = DEBUG_INDENTATION;
1558 dpavlin 34 struct emul *e = emul_new(fname, id);
1559 dpavlin 2
1560     debug("Creating emulation from configfile \"%s\":\n", fname);
1561     debug_indentation(iadd);
1562    
1563 dpavlin 24 emul_parse_config(e, fname);
1564 dpavlin 2
1565     debug_indentation(-iadd);
1566     return e;
1567     }
1568    
1569    
1570     /*
1571     * emul_run():
1572     *
1573     * o) Set up things needed before running emulations.
1574     *
1575     * o) Run emulations (one or more, in parallel).
1576     *
1577     * o) De-initialize things.
1578     */
1579     void emul_run(struct emul **emuls, int n_emuls)
1580     {
1581     struct emul *e;
1582     int i = 0, j, go = 1, n, anything;
1583    
1584     if (n_emuls < 1) {
1585     fprintf(stderr, "emul_run(): no thing to do\n");
1586     return;
1587     }
1588    
1589     atexit(fix_console);
1590    
1591     /* Initialize the interactive debugger: */
1592     debugger_init(emuls, n_emuls);
1593    
1594 dpavlin 22 /* Run any additional debugger commands before starting: */
1595     for (i=0; i<n_emuls; i++) {
1596     struct emul *emul = emuls[i];
1597     if (emul->n_debugger_cmds > 0) {
1598     int j;
1599     if (i == 0)
1600     print_separator();
1601     for (j = 0; j < emul->n_debugger_cmds; j ++) {
1602     debug("> %s\n", emul->debugger_cmds[j]);
1603     debugger_execute_cmd(emul->debugger_cmds[j],
1604     strlen(emul->debugger_cmds[j]));
1605     }
1606     }
1607     }
1608    
1609     print_separator();
1610     debug("\n");
1611    
1612    
1613 dpavlin 2 /*
1614     * console_init_main() makes sure that the terminal is in a
1615     * reasonable state.
1616     *
1617     * The SIGINT handler is for CTRL-C (enter the interactive debugger).
1618     *
1619     * The SIGCONT handler is invoked whenever the user presses CTRL-Z
1620     * (or sends SIGSTOP) and then continues. It makes sure that the
1621     * terminal is in an expected state.
1622     */
1623     console_init_main(emuls[0]); /* TODO: what is a good argument? */
1624     signal(SIGINT, debugger_activate);
1625     signal(SIGCONT, console_sigcont);
1626    
1627     /* Not in verbose mode? Then set quiet_mode. */
1628     if (!verbose)
1629     quiet_mode = 1;
1630    
1631     /* Initialize all CPUs in all machines in all emulations: */
1632     for (i=0; i<n_emuls; i++) {
1633     e = emuls[i];
1634     if (e == NULL)
1635     continue;
1636     for (j=0; j<e->n_machines; j++)
1637 dpavlin 12 cpu_run_init(e->machines[j]);
1638 dpavlin 2 }
1639    
1640 dpavlin 12 /* TODO: Generalize: */
1641     if (emuls[0]->machines[0]->show_trace_tree)
1642     cpu_functioncall_trace(emuls[0]->machines[0]->cpus[0],
1643     emuls[0]->machines[0]->cpus[0]->pc);
1644    
1645 dpavlin 32 /* Start emulated clocks: */
1646     timer_start();
1647    
1648 dpavlin 2 /*
1649     * MAIN LOOP:
1650     *
1651     * Run all emulations in parallel, running each machine in
1652     * each emulation.
1653     */
1654     while (go) {
1655     go = 0;
1656    
1657 dpavlin 26 /* Flush X11 and serial console output every now and then: */
1658 dpavlin 28 if (emuls[0]->machines[0]->ninstrs >
1659     emuls[0]->machines[0]->ninstrs_flush + (1<<19)) {
1660 dpavlin 26 x11_check_event(emuls, n_emuls);
1661     console_flush();
1662 dpavlin 28 emuls[0]->machines[0]->ninstrs_flush =
1663     emuls[0]->machines[0]->ninstrs;
1664 dpavlin 26 }
1665 dpavlin 2
1666 dpavlin 28 if (emuls[0]->machines[0]->ninstrs >
1667     emuls[0]->machines[0]->ninstrs_show + (1<<25)) {
1668     emuls[0]->machines[0]->ninstrs_since_gettimeofday +=
1669     (emuls[0]->machines[0]->ninstrs -
1670     emuls[0]->machines[0]->ninstrs_show);
1671 dpavlin 26 cpu_show_cycles(emuls[0]->machines[0], 0);
1672 dpavlin 28 emuls[0]->machines[0]->ninstrs_show =
1673     emuls[0]->machines[0]->ninstrs;
1674 dpavlin 26 }
1675 dpavlin 2
1676 dpavlin 26 if (single_step == ENTER_SINGLE_STEPPING) {
1677     /* TODO: Cleanup! */
1678     old_instruction_trace =
1679     emuls[0]->machines[0]->instruction_trace;
1680     old_quiet_mode = quiet_mode;
1681     old_show_trace_tree =
1682     emuls[0]->machines[0]->show_trace_tree;
1683     emuls[0]->machines[0]->instruction_trace = 1;
1684     emuls[0]->machines[0]->show_trace_tree = 1;
1685     quiet_mode = 0;
1686     single_step = SINGLE_STEPPING;
1687     }
1688 dpavlin 24
1689 dpavlin 26 if (single_step == SINGLE_STEPPING)
1690     debugger();
1691    
1692 dpavlin 32 for (i=0; i<n_emuls; i++) {
1693     e = emuls[i];
1694 dpavlin 26
1695 dpavlin 32 for (j=0; j<e->n_machines; j++) {
1696     if (e->machines[j]->gdb.port > 0)
1697     debugger_gdb_check_incoming(
1698     e->machines[j]);
1699 dpavlin 26
1700 dpavlin 32 anything = machine_run(e->machines[j]);
1701     if (anything)
1702     go = 1;
1703     }
1704 dpavlin 2 }
1705     }
1706    
1707 dpavlin 32 /* Stop any running timers: */
1708     timer_stop();
1709    
1710 dpavlin 2 /* Deinitialize all CPUs in all machines in all emulations: */
1711     for (i=0; i<n_emuls; i++) {
1712     e = emuls[i];
1713     if (e == NULL)
1714     continue;
1715     for (j=0; j<e->n_machines; j++)
1716 dpavlin 12 cpu_run_deinit(e->machines[j]);
1717 dpavlin 2 }
1718    
1719     /* force_debugger_at_exit flag set? Then enter the debugger: */
1720     if (force_debugger_at_exit) {
1721     quiet_mode = 0;
1722     debugger_reset();
1723     debugger();
1724     }
1725    
1726 dpavlin 32 /* Any machine using X11? Then wait before exiting: */
1727 dpavlin 2 n = 0;
1728     for (i=0; i<n_emuls; i++)
1729     for (j=0; j<emuls[i]->n_machines; j++)
1730     if (emuls[i]->machines[j]->use_x11)
1731     n++;
1732     if (n > 0) {
1733     printf("Press enter to quit.\n");
1734     while (!console_charavail(MAIN_CONSOLE)) {
1735     x11_check_event(emuls, n_emuls);
1736 dpavlin 32 usleep(10000);
1737 dpavlin 2 }
1738     console_readchar(MAIN_CONSOLE);
1739     }
1740    
1741 dpavlin 32 console_deinit_main();
1742 dpavlin 2 }
1743    

  ViewVC Help
Powered by ViewVC 1.1.26