1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include "qemu/osdep.h"
21#include "qemu-common.h"
22#include "qemu/units.h"
23#include "sysemu/tcg.h"
24#include "qemu-version.h"
25#include <sys/syscall.h>
26#include <sys/resource.h>
27
28#include "qapi/error.h"
29#include "qemu.h"
30#include "qemu/path.h"
31#include "qemu/config-file.h"
32#include "qemu/cutils.h"
33#include "qemu/error-report.h"
34#include "qemu/help_option.h"
35#include "qemu/module.h"
36#include "cpu.h"
37#include "exec/exec-all.h"
38#include "tcg.h"
39#include "qemu/timer.h"
40#include "qemu/envlist.h"
41#include "qemu/guest-random.h"
42#include "elf.h"
43#include "trace/control.h"
44#include "target_elf.h"
45#include "cpu_loop-common.h"
46#include "crypto/init.h"
47
48char *exec_path;
49
50int singlestep;
51static const char *filename;
52static const char *argv0;
53static int gdbstub_port;
54static envlist_t *envlist;
55static const char *cpu_model;
56static const char *cpu_type;
57static const char *seed_optarg;
58unsigned long mmap_min_addr;
59unsigned long guest_base;
60int have_guest_base;
61
62
63
64
65
66
67
68
69
70
71
72
73
74#ifndef MAX_RESERVED_VA
75# if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS
76# if TARGET_VIRT_ADDR_SPACE_BITS == 32 && \
77 (TARGET_LONG_BITS == 32 || defined(TARGET_ABI32))
78
79
80# define MAX_RESERVED_VA (0xfffffffful & TARGET_PAGE_MASK)
81# else
82# define MAX_RESERVED_VA (1ul << TARGET_VIRT_ADDR_SPACE_BITS)
83# endif
84# else
85# define MAX_RESERVED_VA 0
86# endif
87#endif
88
89unsigned long reserved_va;
90
91static void usage(int exitcode);
92
93static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
94const char *qemu_uname_release;
95
96
97
98
99unsigned long guest_stack_size = 8 * 1024 * 1024UL;
100
101void gemu_log(const char *fmt, ...)
102{
103 va_list ap;
104
105 va_start(ap, fmt);
106 vfprintf(stderr, fmt, ap);
107 va_end(ap);
108}
109
110#if defined(TARGET_I386)
111int cpu_get_pic_interrupt(CPUX86State *env)
112{
113 return -1;
114}
115#endif
116
117
118
119
120
121void fork_start(void)
122{
123 start_exclusive();
124 mmap_fork_start();
125 cpu_list_lock();
126}
127
128void fork_end(int child)
129{
130 mmap_fork_end(child);
131 if (child) {
132 CPUState *cpu, *next_cpu;
133
134
135 CPU_FOREACH_SAFE(cpu, next_cpu) {
136 if (cpu != thread_cpu) {
137 QTAILQ_REMOVE_RCU(&cpus, cpu, node);
138 }
139 }
140 qemu_init_cpu_list();
141 gdbserver_fork(thread_cpu);
142
143
144
145 } else {
146 cpu_list_unlock();
147 end_exclusive();
148 }
149}
150
151__thread CPUState *thread_cpu;
152
153bool qemu_cpu_is_self(CPUState *cpu)
154{
155 return thread_cpu == cpu;
156}
157
158void qemu_cpu_kick(CPUState *cpu)
159{
160 cpu_exit(cpu);
161}
162
163void task_settid(TaskState *ts)
164{
165 if (ts->ts_tid == 0) {
166 ts->ts_tid = (pid_t)syscall(SYS_gettid);
167 }
168}
169
170void stop_all_tasks(void)
171{
172
173
174
175
176 start_exclusive();
177}
178
179
180void init_task_state(TaskState *ts)
181{
182 ts->used = 1;
183 ts->sigaltstack_used = (struct target_sigaltstack) {
184 .ss_sp = 0,
185 .ss_size = 0,
186 .ss_flags = TARGET_SS_DISABLE,
187 };
188}
189
190CPUArchState *cpu_copy(CPUArchState *env)
191{
192 CPUState *cpu = env_cpu(env);
193 CPUState *new_cpu = cpu_create(cpu_type);
194 CPUArchState *new_env = new_cpu->env_ptr;
195 CPUBreakpoint *bp;
196 CPUWatchpoint *wp;
197
198
199 cpu_reset(new_cpu);
200
201 memcpy(new_env, env, sizeof(CPUArchState));
202
203
204
205
206 QTAILQ_INIT(&new_cpu->breakpoints);
207 QTAILQ_INIT(&new_cpu->watchpoints);
208 QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {
209 cpu_breakpoint_insert(new_cpu, bp->pc, bp->flags, NULL);
210 }
211 QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) {
212 cpu_watchpoint_insert(new_cpu, wp->vaddr, wp->len, wp->flags, NULL);
213 }
214
215 return new_env;
216}
217
218static void handle_arg_help(const char *arg)
219{
220 usage(EXIT_SUCCESS);
221}
222
223static void handle_arg_log(const char *arg)
224{
225 int mask;
226
227 mask = qemu_str_to_log_mask(arg);
228 if (!mask) {
229 qemu_print_log_usage(stdout);
230 exit(EXIT_FAILURE);
231 }
232 qemu_log_needs_buffers();
233 qemu_set_log(mask);
234}
235
236static void handle_arg_dfilter(const char *arg)
237{
238 qemu_set_dfilter_ranges(arg, NULL);
239}
240
241static void handle_arg_log_filename(const char *arg)
242{
243 qemu_set_log_filename(arg, &error_fatal);
244}
245
246static void handle_arg_set_env(const char *arg)
247{
248 char *r, *p, *token;
249 r = p = strdup(arg);
250 while ((token = strsep(&p, ",")) != NULL) {
251 if (envlist_setenv(envlist, token) != 0) {
252 usage(EXIT_FAILURE);
253 }
254 }
255 free(r);
256}
257
258static void handle_arg_unset_env(const char *arg)
259{
260 char *r, *p, *token;
261 r = p = strdup(arg);
262 while ((token = strsep(&p, ",")) != NULL) {
263 if (envlist_unsetenv(envlist, token) != 0) {
264 usage(EXIT_FAILURE);
265 }
266 }
267 free(r);
268}
269
270static void handle_arg_argv0(const char *arg)
271{
272 argv0 = strdup(arg);
273}
274
275static void handle_arg_stack_size(const char *arg)
276{
277 char *p;
278 guest_stack_size = strtoul(arg, &p, 0);
279 if (guest_stack_size == 0) {
280 usage(EXIT_FAILURE);
281 }
282
283 if (*p == 'M') {
284 guest_stack_size *= MiB;
285 } else if (*p == 'k' || *p == 'K') {
286 guest_stack_size *= KiB;
287 }
288}
289
290static void handle_arg_ld_prefix(const char *arg)
291{
292 interp_prefix = strdup(arg);
293}
294
295static void handle_arg_pagesize(const char *arg)
296{
297 qemu_host_page_size = atoi(arg);
298 if (qemu_host_page_size == 0 ||
299 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
300 fprintf(stderr, "page size must be a power of two\n");
301 exit(EXIT_FAILURE);
302 }
303}
304
305static void handle_arg_seed(const char *arg)
306{
307 seed_optarg = arg;
308}
309
310static void handle_arg_gdb(const char *arg)
311{
312 gdbstub_port = atoi(arg);
313}
314
315static void handle_arg_uname(const char *arg)
316{
317 qemu_uname_release = strdup(arg);
318}
319
320static void handle_arg_cpu(const char *arg)
321{
322 cpu_model = strdup(arg);
323 if (cpu_model == NULL || is_help_option(cpu_model)) {
324
325#if defined(cpu_list)
326 cpu_list();
327#endif
328 exit(EXIT_FAILURE);
329 }
330}
331
332static void handle_arg_guest_base(const char *arg)
333{
334 guest_base = strtol(arg, NULL, 0);
335 have_guest_base = 1;
336}
337
338static void handle_arg_reserved_va(const char *arg)
339{
340 char *p;
341 int shift = 0;
342 reserved_va = strtoul(arg, &p, 0);
343 switch (*p) {
344 case 'k':
345 case 'K':
346 shift = 10;
347 break;
348 case 'M':
349 shift = 20;
350 break;
351 case 'G':
352 shift = 30;
353 break;
354 }
355 if (shift) {
356 unsigned long unshifted = reserved_va;
357 p++;
358 reserved_va <<= shift;
359 if (reserved_va >> shift != unshifted
360 || (MAX_RESERVED_VA && reserved_va > MAX_RESERVED_VA)) {
361 fprintf(stderr, "Reserved virtual address too big\n");
362 exit(EXIT_FAILURE);
363 }
364 }
365 if (*p) {
366 fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p);
367 exit(EXIT_FAILURE);
368 }
369}
370
371static void handle_arg_singlestep(const char *arg)
372{
373 singlestep = 1;
374}
375
376static void handle_arg_strace(const char *arg)
377{
378 do_strace = 1;
379}
380
381static void handle_arg_version(const char *arg)
382{
383 printf("qemu-" TARGET_NAME " version " QEMU_FULL_VERSION
384 "\n" QEMU_COPYRIGHT "\n");
385 exit(EXIT_SUCCESS);
386}
387
388static char *trace_file;
389static void handle_arg_trace(const char *arg)
390{
391 g_free(trace_file);
392 trace_file = trace_opt_parse(arg);
393}
394
395struct qemu_argument {
396 const char *argv;
397 const char *env;
398 bool has_arg;
399 void (*handle_opt)(const char *arg);
400 const char *example;
401 const char *help;
402};
403
404static const struct qemu_argument arg_table[] = {
405 {"h", "", false, handle_arg_help,
406 "", "print this help"},
407 {"help", "", false, handle_arg_help,
408 "", ""},
409 {"g", "QEMU_GDB", true, handle_arg_gdb,
410 "port", "wait gdb connection to 'port'"},
411 {"L", "QEMU_LD_PREFIX", true, handle_arg_ld_prefix,
412 "path", "set the elf interpreter prefix to 'path'"},
413 {"s", "QEMU_STACK_SIZE", true, handle_arg_stack_size,
414 "size", "set the stack size to 'size' bytes"},
415 {"cpu", "QEMU_CPU", true, handle_arg_cpu,
416 "model", "select CPU (-cpu help for list)"},
417 {"E", "QEMU_SET_ENV", true, handle_arg_set_env,
418 "var=value", "sets targets environment variable (see below)"},
419 {"U", "QEMU_UNSET_ENV", true, handle_arg_unset_env,
420 "var", "unsets targets environment variable (see below)"},
421 {"0", "QEMU_ARGV0", true, handle_arg_argv0,
422 "argv0", "forces target process argv[0] to be 'argv0'"},
423 {"r", "QEMU_UNAME", true, handle_arg_uname,
424 "uname", "set qemu uname release string to 'uname'"},
425 {"B", "QEMU_GUEST_BASE", true, handle_arg_guest_base,
426 "address", "set guest_base address to 'address'"},
427 {"R", "QEMU_RESERVED_VA", true, handle_arg_reserved_va,
428 "size", "reserve 'size' bytes for guest virtual address space"},
429 {"d", "QEMU_LOG", true, handle_arg_log,
430 "item[,...]", "enable logging of specified items "
431 "(use '-d help' for a list of items)"},
432 {"dfilter", "QEMU_DFILTER", true, handle_arg_dfilter,
433 "range[,...]","filter logging based on address range"},
434 {"D", "QEMU_LOG_FILENAME", true, handle_arg_log_filename,
435 "logfile", "write logs to 'logfile' (default stderr)"},
436 {"p", "QEMU_PAGESIZE", true, handle_arg_pagesize,
437 "pagesize", "set the host page size to 'pagesize'"},
438 {"singlestep", "QEMU_SINGLESTEP", false, handle_arg_singlestep,
439 "", "run in singlestep mode"},
440 {"strace", "QEMU_STRACE", false, handle_arg_strace,
441 "", "log system calls"},
442 {"seed", "QEMU_RAND_SEED", true, handle_arg_seed,
443 "", "Seed for pseudo-random number generator"},
444 {"trace", "QEMU_TRACE", true, handle_arg_trace,
445 "", "[[enable=]<pattern>][,events=<file>][,file=<file>]"},
446 {"version", "QEMU_VERSION", false, handle_arg_version,
447 "", "display version information and exit"},
448 {NULL, NULL, false, NULL, NULL, NULL}
449};
450
451static void usage(int exitcode)
452{
453 const struct qemu_argument *arginfo;
454 int maxarglen;
455 int maxenvlen;
456
457 printf("usage: qemu-" TARGET_NAME " [options] program [arguments...]\n"
458 "Linux CPU emulator (compiled for " TARGET_NAME " emulation)\n"
459 "\n"
460 "Options and associated environment variables:\n"
461 "\n");
462
463
464
465
466 maxarglen = strlen("Argument");
467 maxenvlen = strlen("Env-variable");
468
469 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
470 int arglen = strlen(arginfo->argv);
471 if (arginfo->has_arg) {
472 arglen += strlen(arginfo->example) + 1;
473 }
474 if (strlen(arginfo->env) > maxenvlen) {
475 maxenvlen = strlen(arginfo->env);
476 }
477 if (arglen > maxarglen) {
478 maxarglen = arglen;
479 }
480 }
481
482 printf("%-*s %-*s Description\n", maxarglen+1, "Argument",
483 maxenvlen, "Env-variable");
484
485 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
486 if (arginfo->has_arg) {
487 printf("-%s %-*s %-*s %s\n", arginfo->argv,
488 (int)(maxarglen - strlen(arginfo->argv) - 1),
489 arginfo->example, maxenvlen, arginfo->env, arginfo->help);
490 } else {
491 printf("-%-*s %-*s %s\n", maxarglen, arginfo->argv,
492 maxenvlen, arginfo->env,
493 arginfo->help);
494 }
495 }
496
497 printf("\n"
498 "Defaults:\n"
499 "QEMU_LD_PREFIX = %s\n"
500 "QEMU_STACK_SIZE = %ld byte\n",
501 interp_prefix,
502 guest_stack_size);
503
504 printf("\n"
505 "You can use -E and -U options or the QEMU_SET_ENV and\n"
506 "QEMU_UNSET_ENV environment variables to set and unset\n"
507 "environment variables for the target process.\n"
508 "It is possible to provide several variables by separating them\n"
509 "by commas in getsubopt(3) style. Additionally it is possible to\n"
510 "provide the -E and -U options multiple times.\n"
511 "The following lines are equivalent:\n"
512 " -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
513 " -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n"
514 " QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n"
515 "Note that if you provide several changes to a single variable\n"
516 "the last change will stay in effect.\n"
517 "\n"
518 QEMU_HELP_BOTTOM "\n");
519
520 exit(exitcode);
521}
522
523static int parse_args(int argc, char **argv)
524{
525 const char *r;
526 int optind;
527 const struct qemu_argument *arginfo;
528
529 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
530 if (arginfo->env == NULL) {
531 continue;
532 }
533
534 r = getenv(arginfo->env);
535 if (r != NULL) {
536 arginfo->handle_opt(r);
537 }
538 }
539
540 optind = 1;
541 for (;;) {
542 if (optind >= argc) {
543 break;
544 }
545 r = argv[optind];
546 if (r[0] != '-') {
547 break;
548 }
549 optind++;
550 r++;
551 if (!strcmp(r, "-")) {
552 break;
553 }
554
555 if (r[0] == '-') {
556 r++;
557 }
558
559 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
560 if (!strcmp(r, arginfo->argv)) {
561 if (arginfo->has_arg) {
562 if (optind >= argc) {
563 (void) fprintf(stderr,
564 "qemu: missing argument for option '%s'\n", r);
565 exit(EXIT_FAILURE);
566 }
567 arginfo->handle_opt(argv[optind]);
568 optind++;
569 } else {
570 arginfo->handle_opt(NULL);
571 }
572 break;
573 }
574 }
575
576
577 if (arginfo->handle_opt == NULL) {
578 (void) fprintf(stderr, "qemu: unknown option '%s'\n", r);
579 exit(EXIT_FAILURE);
580 }
581 }
582
583 if (optind >= argc) {
584 (void) fprintf(stderr, "qemu: no user program specified\n");
585 exit(EXIT_FAILURE);
586 }
587
588 filename = argv[optind];
589 exec_path = argv[optind];
590
591 return optind;
592}
593
594int main(int argc, char **argv, char **envp)
595{
596 struct target_pt_regs regs1, *regs = ®s1;
597 struct image_info info1, *info = &info1;
598 struct linux_binprm bprm;
599 TaskState *ts;
600 CPUArchState *env;
601 CPUState *cpu;
602 int optind;
603 char **target_environ, **wrk;
604 char **target_argv;
605 int target_argc;
606 int i;
607 int ret;
608 int execfd;
609
610 error_init(argv[0]);
611 module_call_init(MODULE_INIT_TRACE);
612 qemu_init_cpu_list();
613 module_call_init(MODULE_INIT_QOM);
614
615 envlist = envlist_create();
616
617
618 for (wrk = environ; *wrk != NULL; wrk++) {
619 (void) envlist_setenv(envlist, *wrk);
620 }
621
622
623
624 {
625 struct rlimit lim;
626 if (getrlimit(RLIMIT_STACK, &lim) == 0
627 && lim.rlim_cur != RLIM_INFINITY
628 && lim.rlim_cur == (target_long)lim.rlim_cur) {
629 guest_stack_size = lim.rlim_cur;
630 }
631 }
632
633 cpu_model = NULL;
634
635 qemu_add_opts(&qemu_trace_opts);
636
637 optind = parse_args(argc, argv);
638
639 if (!trace_init_backends()) {
640 exit(1);
641 }
642 trace_init_file(trace_file);
643
644
645 memset(regs, 0, sizeof(struct target_pt_regs));
646
647
648 memset(info, 0, sizeof(struct image_info));
649
650 memset(&bprm, 0, sizeof (bprm));
651
652
653 init_paths(interp_prefix);
654
655 init_qemu_uname_release();
656
657 execfd = qemu_getauxval(AT_EXECFD);
658 if (execfd == 0) {
659 execfd = open(filename, O_RDONLY);
660 if (execfd < 0) {
661 printf("Error while loading %s: %s\n", filename, strerror(errno));
662 _exit(EXIT_FAILURE);
663 }
664 }
665
666 if (cpu_model == NULL) {
667 cpu_model = cpu_get_model(get_elf_eflags(execfd));
668 }
669 cpu_type = parse_cpu_option(cpu_model);
670
671
672 tcg_exec_init(0);
673
674
675
676
677 if (HOST_LONG_BITS == 64 &&
678 TARGET_VIRT_ADDR_SPACE_BITS <= 32 &&
679 reserved_va == 0) {
680
681
682
683 reserved_va = MAX_RESERVED_VA & qemu_host_page_mask;
684 }
685
686 cpu = cpu_create(cpu_type);
687 env = cpu->env_ptr;
688 cpu_reset(cpu);
689
690 thread_cpu = cpu;
691
692 if (getenv("QEMU_STRACE")) {
693 do_strace = 1;
694 }
695
696 if (seed_optarg == NULL) {
697 seed_optarg = getenv("QEMU_RAND_SEED");
698 }
699 {
700 Error *err = NULL;
701 if (seed_optarg != NULL) {
702 qemu_guest_random_seed_main(seed_optarg, &err);
703 } else {
704 qcrypto_init(&err);
705 }
706 if (err) {
707 error_reportf_err(err, "cannot initialize crypto: ");
708 exit(1);
709 }
710 }
711
712 target_environ = envlist_to_environ(envlist, NULL);
713 envlist_free(envlist);
714
715
716
717
718
719 guest_base = HOST_PAGE_ALIGN(guest_base);
720
721 if (reserved_va || have_guest_base) {
722 guest_base = init_guest_space(guest_base, reserved_va, 0,
723 have_guest_base);
724 if (guest_base == (unsigned long)-1) {
725 fprintf(stderr, "Unable to reserve 0x%lx bytes of virtual address "
726 "space for use as guest address space (check your virtual "
727 "memory ulimit setting or reserve less using -R option)\n",
728 reserved_va);
729 exit(EXIT_FAILURE);
730 }
731
732 if (reserved_va) {
733 mmap_next_start = reserved_va;
734 }
735 }
736
737
738
739
740
741
742 {
743 FILE *fp;
744
745 if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) {
746 unsigned long tmp;
747 if (fscanf(fp, "%lu", &tmp) == 1) {
748 mmap_min_addr = tmp;
749 qemu_log_mask(CPU_LOG_PAGE, "host mmap_min_addr=0x%lx\n", mmap_min_addr);
750 }
751 fclose(fp);
752 }
753 }
754
755
756
757
758 target_argc = argc - optind;
759 target_argv = calloc(target_argc + 1, sizeof (char *));
760 if (target_argv == NULL) {
761 (void) fprintf(stderr, "Unable to allocate memory for target_argv\n");
762 exit(EXIT_FAILURE);
763 }
764
765
766
767
768
769 i = 0;
770 if (argv0 != NULL) {
771 target_argv[i++] = strdup(argv0);
772 }
773 for (; i < target_argc; i++) {
774 target_argv[i] = strdup(argv[optind + i]);
775 }
776 target_argv[target_argc] = NULL;
777
778 ts = g_new0(TaskState, 1);
779 init_task_state(ts);
780
781 ts->info = info;
782 ts->bprm = &bprm;
783 cpu->opaque = ts;
784 task_settid(ts);
785
786 ret = loader_exec(execfd, filename, target_argv, target_environ, regs,
787 info, &bprm);
788 if (ret != 0) {
789 printf("Error while loading %s: %s\n", filename, strerror(-ret));
790 _exit(EXIT_FAILURE);
791 }
792
793 for (wrk = target_environ; *wrk; wrk++) {
794 g_free(*wrk);
795 }
796
797 g_free(target_environ);
798
799 if (qemu_loglevel_mask(CPU_LOG_PAGE)) {
800 qemu_log("guest_base 0x%lx\n", guest_base);
801 log_page_dump();
802
803 qemu_log("start_brk 0x" TARGET_ABI_FMT_lx "\n", info->start_brk);
804 qemu_log("end_code 0x" TARGET_ABI_FMT_lx "\n", info->end_code);
805 qemu_log("start_code 0x" TARGET_ABI_FMT_lx "\n", info->start_code);
806 qemu_log("start_data 0x" TARGET_ABI_FMT_lx "\n", info->start_data);
807 qemu_log("end_data 0x" TARGET_ABI_FMT_lx "\n", info->end_data);
808 qemu_log("start_stack 0x" TARGET_ABI_FMT_lx "\n", info->start_stack);
809 qemu_log("brk 0x" TARGET_ABI_FMT_lx "\n", info->brk);
810 qemu_log("entry 0x" TARGET_ABI_FMT_lx "\n", info->entry);
811 qemu_log("argv_start 0x" TARGET_ABI_FMT_lx "\n", info->arg_start);
812 qemu_log("env_start 0x" TARGET_ABI_FMT_lx "\n",
813 info->arg_end + (abi_ulong)sizeof(abi_ulong));
814 qemu_log("auxv_start 0x" TARGET_ABI_FMT_lx "\n", info->saved_auxv);
815 }
816
817 target_set_brk(info->brk);
818 syscall_init();
819 signal_init();
820
821
822
823
824 tcg_prologue_init(tcg_ctx);
825 tcg_region_init();
826
827 target_cpu_copy_regs(env, regs);
828
829 if (gdbstub_port) {
830 if (gdbserver_start(gdbstub_port) < 0) {
831 fprintf(stderr, "qemu: could not open gdbserver on port %d\n",
832 gdbstub_port);
833 exit(EXIT_FAILURE);
834 }
835 gdb_handlesig(cpu, 0);
836 }
837 cpu_loop(env);
838
839 return 0;
840}
841