1 /* This file is part of the program psim.
3 Copyright 1994, 1995, 1996, 1997, 2003 Andrew Cagney
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 #include "cpu.h" /* includes psim.h */
52 #include "libiberty.h"
53 #include "gdb/signals.h"
55 /* system structure, actual size of processor array determined at
62 os_emul *os_emulation;
65 /* escape routine for inner functions */
67 void *path_to_restart;
69 /* status from last halt */
70 psim_status halt_status;
72 /* the processors proper */
74 int last_cpu; /* CPU that last (tried to) execute an instruction */
75 cpu *processors[MAX_NR_PROCESSORS];
79 int current_target_byte_order;
80 int current_host_byte_order;
81 int current_environment;
82 int current_alignment;
83 int current_floating_point;
84 int current_model_issue = MODEL_ISSUE_IGNORE;
85 int current_stdio = DO_USE_STDIO;
86 model_enum current_model = WITH_DEFAULT_MODEL;
89 /* create the device tree */
95 device *root = tree_parse(NULL, "core");
96 tree_parse(root, "/aliases");
97 tree_parse(root, "/options");
98 tree_parse(root, "/chosen");
99 tree_parse(root, "/packages");
100 tree_parse(root, "/cpus");
101 tree_parse(root, "/openprom");
102 tree_parse(root, "/openprom/init");
103 tree_parse(root, "/openprom/trace");
104 tree_parse(root, "/openprom/options");
110 find_arg(char *err_msg,
115 if (argv[*ptr_to_argp] == NULL)
117 return argv[*ptr_to_argp];
122 psim_usage(int verbose, int help)
124 printf_filtered("Usage:\n");
125 printf_filtered("\n");
126 printf_filtered("\tpsim [ <psim-option> ... ] <image> [ <image-arg> ... ]\n");
127 printf_filtered("\n");
128 printf_filtered("Where\n");
129 printf_filtered("\n");
130 printf_filtered("\t<image> Name of the PowerPC program to run.\n");
132 printf_filtered("\t This can either be a PowerPC binary or\n");
133 printf_filtered("\t a text file containing a device tree\n");
134 printf_filtered("\t specification.\n");
135 printf_filtered("\t PSIM will attempt to determine from the\n");
136 printf_filtered("\t specified <image> the intended emulation\n");
137 printf_filtered("\t environment.\n");
138 printf_filtered("\t If PSIM gets it wrong, the emulation\n");
139 printf_filtered("\t environment can be specified using the\n");
140 printf_filtered("\t `-e' option (described below).\n");
141 printf_filtered("\n"); }
142 printf_filtered("\t<image-arg> Argument to be passed to <image>\n");
144 printf_filtered("\t These arguments will be passed to\n");
145 printf_filtered("\t <image> (as standard C argv, argc)\n");
146 printf_filtered("\t when <image> is started.\n");
147 printf_filtered("\n"); }
148 printf_filtered("\t<psim-option> See below\n");
149 printf_filtered("\n");
150 printf_filtered("The following are valid <psim-option>s:\n");
151 printf_filtered("\n");
153 printf_filtered("\t-c <count> Limit the simulation to <count> iterations\n");
155 printf_filtered("\n");
158 printf_filtered("\t-i or -i2 Print instruction counting statistics\n");
160 printf_filtered("\t Specify -i2 for a more detailed display\n");
161 printf_filtered("\n");
164 printf_filtered("\t-I Print execution unit statistics\n");
165 if (verbose) { printf_filtered("\n"); }
167 printf_filtered("\t-e <os-emul> specify an OS or platform to model\n");
169 printf_filtered("\t Can be any of the following:\n");
170 printf_filtered("\t bug - OEA + MOTO BUG ROM calls\n");
171 printf_filtered("\t netbsd - UEA + NetBSD system calls\n");
172 printf_filtered("\t solaris - UEA + Solaris system calls\n");
173 printf_filtered("\t linux - UEA + Linux system calls\n");
174 printf_filtered("\t chirp - OEA + a few OpenBoot calls\n");
175 printf_filtered("\n"); }
177 printf_filtered("\t-E <endian> Specify the endianness of the target\n");
179 printf_filtered("\t Can be any of the following:\n");
180 printf_filtered("\t big - big endian target\n");
181 printf_filtered("\t little - little endian target\n");
182 printf_filtered("\n"); }
184 printf_filtered("\t-f <file> Merge <file> into the device tree\n");
185 if (verbose) { printf_filtered("\n"); }
187 printf_filtered("\t-h -? -H give more detailed usage\n");
188 if (verbose) { printf_filtered("\n"); }
190 printf_filtered("\t-m <model> Specify the processor to model (604)\n");
192 printf_filtered("\t Selects the processor to use when\n");
193 printf_filtered("\t modeling execution units. Includes:\n");
194 printf_filtered("\t 604, 603 and 603e\n");
195 printf_filtered("\n"); }
197 printf_filtered("\t-n <nr-smp> Specify the number of processors in SMP simulations\n");
199 printf_filtered("\t Specifies the number of processors that are\n");
200 printf_filtered("\t to be modeled in a symetric multi-processor (SMP)\n");
201 printf_filtered("\t simulation\n");
202 printf_filtered("\n"); }
204 printf_filtered("\t-o <dev-spec> Add device <dev-spec> to the device tree\n");
205 if (verbose) { printf_filtered("\n"); }
207 printf_filtered("\t-r <ram-size> Set RAM size in bytes (OEA environments)\n");
208 if (verbose) { printf_filtered("\n"); }
210 printf_filtered("\t-t [!]<trace> Enable (disable) <trace> option\n");
211 if (verbose) { printf_filtered("\n"); }
213 printf_filtered("\n");
214 trace_usage(verbose);
215 device_usage(verbose);
217 printf_filtered("\n");
221 if (REPORT_BUGS_TO[0])
222 printf ("Report bugs to %s\n", REPORT_BUGS_TO);
226 /* Test "string" for containing a string of digits that form a number
227 between "min" and "max". The return value is the number or "err". */
229 int is_num( char *string, int min, int max, int err)
233 for ( ; *string; ++string)
235 if (!isdigit(*string))
240 result = result * 10 + (*string - '0');
242 if (result < min || result > max)
250 psim_options(device *root,
253 device *current = root;
258 while (argv[argp] != NULL && argv[argp][0] == '-') {
259 char *p = argv[argp] + 1;
268 param = find_arg("Missing <count> option for -c (max-iterations)\n", &argp, argv);
269 tree_parse(root, "/openprom/options/max-iterations %s", param);
272 param = find_arg("Missing <emul> option for -e (os-emul)\n", &argp, argv);
273 tree_parse(root, "/openprom/options/os-emul %s", param);
276 /* endian spec, ignored for now */
277 param = find_arg("Missing <endian> option for -E (target-endian)\n", &argp, argv);
278 if (strcmp (param, "big") == 0)
279 tree_parse (root, "/options/little-endian? false");
280 else if (strcmp (param, "little") == 0)
281 tree_parse (root, "/options/little-endian? true");
284 printf_filtered ("Invalid <endian> option for -E (target-endian)\n");
289 param = find_arg("Missing <file> option for -f\n", &argp, argv);
290 psim_merge_device_file(root, param);
301 tree_parse(root, "/openprom/trace/print-info %c", p[1]);
305 tree_parse(root, "/openprom/trace/print-info 1");
309 tree_parse(root, "/openprom/trace/print-info 2");
310 tree_parse(root, "/openprom/options/model-issue %d",
311 MODEL_ISSUE_PROCESS);
314 param = find_arg("Missing <model> option for -m (model)\n", &argp, argv);
315 tree_parse(root, "/openprom/options/model \"%s", param);
318 param = find_arg("Missing <nr-smp> option for -n (smp)\n", &argp, argv);
319 tree_parse(root, "/openprom/options/smp %s", param);
322 param = find_arg("Missing <dev-spec> option for -o\n", &argp, argv);
323 if (memcmp(param, "mpc860c0", 8) == 0)
325 if (param[8] == '\0')
326 tree_parse(root, "/options/mpc860c0 5");
327 else if (param[8] == '=' && is_num(param+9, 1, 10, 0))
329 tree_parse(root, "/options/mpc860c0 %s", param+9);
331 else error("Invalid mpc860c0 option for -o\n");
334 current = tree_parse(current, "%s", param);
337 param = find_arg("Missing <ram-size> option for -r (oea-memory-size)\n", &argp, argv);
338 tree_parse(root, "/openprom/options/oea-memory-size %s",
342 param = find_arg("Missing <trace> option for -t (trace/*)\n", &argp, argv);
344 tree_parse(root, "/openprom/trace/%s 0", param+1);
346 tree_parse(root, "/openprom/trace/%s 1", param);
349 /* it's a long option of the form --optionname=optionvalue.
350 Such options can be passed through if we are invoked by
352 if (strstr(argv[argp], "architecture") != NULL) {
353 /* we must consume the argument here, so that we get out
355 p = argv[argp] + strlen(argv[argp]) - 1;
356 printf_filtered("Warning - architecture parameter ignored\n");
358 else if (strcmp (argv[argp], "--help") == 0)
360 else if (strcmp (argv[argp], "--version") == 0)
362 extern const char version[];
363 printf ("GNU simulator %s%s\n", PKGVERSION, version);
367 error("Unrecognized option");
374 /* force the trace node to process its options now *before* the tree
375 initialization occures */
376 device_ioctl(tree_find_device(root, "/openprom/trace"),
378 device_ioctl_set_trace);
381 void semantic_init(device* root);
385 /* return where the options end */
391 psim_command(device *root,
395 if (argv[argp] == NULL) {
398 else if (strcmp(argv[argp], "trace") == 0) {
399 const char *opt = find_arg("Missing <trace> option", &argp, argv);
401 trace_option(opt + 1, 0);
403 trace_option(opt, 1);
405 else if (strcmp(*argv, "change-media") == 0) {
406 char *device = find_arg("Missing device name", &argp, argv);
407 char *media = argv[++argp];
408 device_ioctl(tree_find_device(root, device), NULL, 0,
409 device_ioctl_change_media, media);
412 printf_filtered("Unknown PSIM command %s, try\n", argv[argp]);
413 printf_filtered(" trace <trace-option>\n");
414 printf_filtered(" change-media <device> [ <new-image> ]\n");
419 /* create the simulator proper from the device tree and executable */
423 psim_create(const char *file_name,
429 os_emul *os_emulation;
432 /* given this partially populated device tree, os_emul_create() uses
433 it and file_name to determine the selected emulation and hence
434 further populate the tree with any other required nodes. */
436 os_emulation = os_emul_create(file_name, root);
437 if (os_emulation == NULL)
438 error("psim: either file %s was not reconized or unreconized or unknown os-emulation type\n", file_name);
440 /* fill in the missing real number of CPU's */
441 nr_cpus = tree_find_integer_property(root, "/openprom/options/smp");
442 if (MAX_NR_PROCESSORS < nr_cpus)
443 error("target and configured number of cpus conflict\n");
445 /* fill in the missing TARGET BYTE ORDER information */
446 current_target_byte_order
447 = (tree_find_boolean_property(root, "/options/little-endian?")
450 if (CURRENT_TARGET_BYTE_ORDER != current_target_byte_order)
451 error("target and configured byte order conflict\n");
453 /* fill in the missing HOST BYTE ORDER information */
454 current_host_byte_order = (current_host_byte_order = 1,
455 (*(char*)(¤t_host_byte_order)
458 if (CURRENT_HOST_BYTE_ORDER != current_host_byte_order)
459 error("host and configured byte order conflict\n");
461 /* fill in the missing OEA/VEA information */
462 env = tree_find_string_property(root, "/openprom/options/env");
463 current_environment = ((strcmp(env, "user") == 0
464 || strcmp(env, "uea") == 0)
466 : (strcmp(env, "virtual") == 0
467 || strcmp(env, "vea") == 0)
468 ? VIRTUAL_ENVIRONMENT
469 : (strcmp(env, "operating") == 0
470 || strcmp(env, "oea") == 0)
471 ? OPERATING_ENVIRONMENT
473 if (current_environment == 0)
474 error("unreconized /options env property\n");
475 if (CURRENT_ENVIRONMENT != current_environment)
476 error("target and configured environment conflict\n");
478 /* fill in the missing ALLIGNMENT information */
480 = (tree_find_boolean_property(root, "/openprom/options/strict-alignment?")
482 : NONSTRICT_ALIGNMENT);
483 if (CURRENT_ALIGNMENT != current_alignment)
484 error("target and configured alignment conflict\n");
486 /* fill in the missing FLOATING POINT information */
487 current_floating_point
488 = (tree_find_boolean_property(root, "/openprom/options/floating-point?")
489 ? HARD_FLOATING_POINT
490 : SOFT_FLOATING_POINT);
491 if (CURRENT_FLOATING_POINT != current_floating_point)
492 error("target and configured floating-point conflict\n");
494 /* fill in the missing STDIO information */
496 = (tree_find_boolean_property(root, "/openprom/options/use-stdio?")
499 if (CURRENT_STDIO != current_stdio)
500 error("target and configured stdio interface conflict\n");
502 /* sort out the level of detail for issue modeling */
504 = tree_find_integer_property(root, "/openprom/options/model-issue");
505 if (CURRENT_MODEL_ISSUE != current_model_issue)
506 error("target and configured model-issue conflict\n");
508 /* sort out our model architecture - wrong.
510 FIXME: this should be obtaining the required information from the
511 device tree via the "/chosen" property "cpu" which is an instance
512 (ihandle) for the only executing processor. By converting that
513 ihandle into the corresponding cpu's phandle and then querying
514 the "name" property, the cpu type can be determined. Ok? */
516 model_set(tree_find_string_property(root, "/openprom/options/model"));
519 system = ZALLOC(psim);
520 system->events = event_queue_create();
521 system->memory = core_from_device(root);
522 system->monitor = mon_create();
523 system->nr_cpus = nr_cpus;
524 system->os_emulation = os_emulation;
525 system->devices = root;
527 /* now all the processors attaching to each their per-cpu information */
528 for (cpu_nr = 0; cpu_nr < MAX_NR_PROCESSORS; cpu_nr++) {
529 system->processors[cpu_nr] = cpu_create(system,
531 mon_cpu(system->monitor,
533 system->os_emulation,
537 /* dump out the contents of the device tree */
538 if (ppc_trace[trace_print_device_tree] || ppc_trace[trace_dump_device_tree])
540 if (ppc_trace[trace_dump_device_tree])
547 /* allow the simulation to stop/restart abnormaly */
551 psim_set_halt_and_restart(psim *system,
553 void *restart_jmp_buf)
555 system->path_to_halt = halt_jmp_buf;
556 system->path_to_restart = restart_jmp_buf;
561 psim_clear_halt_and_restart(psim *system)
563 system->path_to_halt = NULL;
564 system->path_to_restart = NULL;
569 psim_restart(psim *system,
572 ASSERT(current_cpu >= 0 && current_cpu < system->nr_cpus);
573 ASSERT(system->path_to_restart != NULL);
574 system->last_cpu = current_cpu;
575 longjmp(*(jmp_buf*)(system->path_to_restart), current_cpu + 1);
580 cntrl_c_simulation(void *data)
584 psim_nr_cpus(system),
591 psim_stop(psim *system)
593 event_queue_schedule_after_signal(psim_event_queue(system),
601 psim_halt(psim *system,
606 ASSERT(current_cpu >= 0 && current_cpu <= system->nr_cpus);
607 ASSERT(system->path_to_halt != NULL);
608 system->last_cpu = current_cpu;
609 system->halt_status.reason = reason;
610 system->halt_status.signal = signal;
611 if (current_cpu == system->nr_cpus) {
612 system->halt_status.cpu_nr = 0;
613 system->halt_status.program_counter =
614 cpu_get_program_counter(system->processors[0]);
617 system->halt_status.cpu_nr = current_cpu;
618 system->halt_status.program_counter =
619 cpu_get_program_counter(system->processors[current_cpu]);
621 longjmp(*(jmp_buf*)(system->path_to_halt), current_cpu + 1);
627 psim_last_cpu(psim *system)
629 return system->last_cpu;
634 psim_nr_cpus(psim *system)
636 return system->nr_cpus;
641 psim_get_status(psim *system)
643 return system->halt_status;
649 psim_cpu(psim *system,
652 if (cpu_nr < 0 || cpu_nr >= system->nr_cpus)
655 return system->processors[cpu_nr];
661 psim_device(psim *system,
664 return tree_find_device(system->devices, path);
669 psim_event_queue(psim *system)
671 return system->events;
678 psim_max_iterations_exceeded(void *data)
682 system->nr_cpus, /* halted during an event */
690 psim_init(psim *system)
694 /* scrub the monitor */
695 mon_init(system->monitor, system->nr_cpus);
697 /* trash any pending events */
698 event_queue_init(system->events);
700 /* if needed, schedule a halt event. FIXME - In the future this
701 will be replaced by a more generic change to psim_command(). A
702 new command `schedule NNN halt' being added. */
703 if (tree_find_property(system->devices, "/openprom/options/max-iterations")) {
704 event_queue_schedule(system->events,
705 tree_find_integer_property(system->devices,
706 "/openprom/options/max-iterations") - 2,
707 psim_max_iterations_exceeded,
711 /* scrub all the cpus */
712 for (cpu_nr = 0; cpu_nr < system->nr_cpus; cpu_nr++)
713 cpu_init(system->processors[cpu_nr]);
715 /* init all the devices (which updates the cpus) */
716 tree_init(system->devices, system);
718 /* and the emulation (which needs an initialized device tree) */
719 os_emul_init(system->os_emulation, system->nr_cpus);
721 /* now sync each cpu against the initialized state of its registers */
722 for (cpu_nr = 0; cpu_nr < system->nr_cpus; cpu_nr++) {
723 cpu *processor = system->processors[cpu_nr];
724 cpu_synchronize_context(processor, cpu_get_program_counter(processor));
725 cpu_page_tlb_invalidate_all(processor);
728 /* force loop to start with first cpu */
729 system->last_cpu = -1;
734 psim_stack(psim *system,
738 /* pass the stack device the argv/envp and let it work out what to
740 device *stack_device = tree_find_device(system->devices,
741 "/openprom/init/stack");
742 if (stack_device != (device*)0) {
743 unsigned_word stack_pointer;
744 ASSERT (psim_read_register(system, 0, &stack_pointer, "sp",
745 cooked_transfer) > 0);
746 device_ioctl(stack_device,
749 device_ioctl_create_stack,
758 /* SIMULATE INSTRUCTIONS, various different ways of achieving the same
763 psim_step(psim *system)
765 volatile int keep_running = 0;
766 idecode_run_until_stop(system, &keep_running,
767 system->events, system->processors, system->nr_cpus);
772 psim_run(psim *system)
775 system->events, system->processors, system->nr_cpus);
779 /* storage manipulation functions */
783 psim_read_register(psim *system,
789 register_descriptions description;
793 /* find our processor */
794 if (which_cpu == MAX_NR_PROCESSORS) {
795 if (system->last_cpu == system->nr_cpus
796 || system->last_cpu == -1)
799 which_cpu = system->last_cpu;
801 ASSERT(which_cpu >= 0 && which_cpu < system->nr_cpus);
803 processor = system->processors[which_cpu];
805 /* find the register description */
806 description = register_description(reg);
807 if (description.type == reg_invalid)
809 cooked_buf = alloca (description.size);
811 /* get the cooked value */
812 switch (description.type) {
815 *(gpreg*)cooked_buf = cpu_registers(processor)->gpr[description.index];
819 *(spreg*)cooked_buf = cpu_registers(processor)->spr[description.index];
823 *(sreg*)cooked_buf = cpu_registers(processor)->sr[description.index];
827 *(fpreg*)cooked_buf = cpu_registers(processor)->fpr[description.index];
831 *(unsigned_word*)cooked_buf = cpu_get_program_counter(processor);
835 *(creg*)cooked_buf = cpu_registers(processor)->cr;
839 *(msreg*)cooked_buf = cpu_registers(processor)->msr;
843 *(fpscreg*)cooked_buf = cpu_registers(processor)->fpscr;
847 *(unsigned_word*)cooked_buf = mon_get_number_of_insns(system->monitor,
852 if (cpu_model(processor) == NULL)
853 error("$stalls only valid if processor unit model enabled (-I)\n");
854 *(unsigned_word*)cooked_buf = model_get_number_of_stalls(cpu_model(processor));
858 if (cpu_model(processor) == NULL)
859 error("$cycles only valid if processor unit model enabled (-I)\n");
860 *(unsigned_word*)cooked_buf = model_get_number_of_cycles(cpu_model(processor));
865 *(vreg*)cooked_buf = cpu_registers(processor)->altivec.vr[description.index];
869 *(vscreg*)cooked_buf = cpu_registers(processor)->altivec.vscr;
875 *(gpreg*)cooked_buf = cpu_registers(processor)->e500.gprh[description.index];
879 *(unsigned64*)cooked_buf = EVR(description.index);
883 *(accreg*)cooked_buf = cpu_registers(processor)->e500.acc;
888 printf_filtered("psim_read_register(processor=0x%lx,buf=0x%lx,reg=%s) %s\n",
889 (unsigned long)processor, (unsigned long)buf, reg,
890 "read of this register unimplemented");
895 /* the PSIM internal values are in host order. To fetch raw data,
896 they need to be converted into target order and then returned */
897 if (mode == raw_transfer) {
898 /* FIXME - assumes that all registers are simple integers */
899 switch (description.size) {
901 *(unsigned_1*)buf = H2T_1(*(unsigned_1*)cooked_buf);
904 *(unsigned_2*)buf = H2T_2(*(unsigned_2*)cooked_buf);
907 *(unsigned_4*)buf = H2T_4(*(unsigned_4*)cooked_buf);
910 *(unsigned_8*)buf = H2T_8(*(unsigned_8*)cooked_buf);
914 if (CURRENT_HOST_BYTE_ORDER != CURRENT_TARGET_BYTE_ORDER)
916 union { vreg v; unsigned_8 d[2]; } h, t;
917 memcpy(&h.v/*dest*/, cooked_buf/*src*/, description.size);
918 { _SWAP_8(t.d[0] =, h.d[1]); }
919 { _SWAP_8(t.d[1] =, h.d[0]); }
920 memcpy(buf/*dest*/, &t/*src*/, description.size);
924 memcpy(buf/*dest*/, cooked_buf/*src*/, description.size);
930 memcpy(buf/*dest*/, cooked_buf/*src*/, description.size);
933 return description.size;
940 psim_write_register(psim *system,
947 register_descriptions description;
950 /* find our processor */
951 if (which_cpu == MAX_NR_PROCESSORS) {
952 if (system->last_cpu == system->nr_cpus
953 || system->last_cpu == -1)
956 which_cpu = system->last_cpu;
959 /* find the description of the register */
960 description = register_description(reg);
961 if (description.type == reg_invalid)
963 cooked_buf = alloca (description.size);
965 if (which_cpu == -1) {
967 for (i = 0; i < system->nr_cpus; i++)
968 psim_write_register(system, i, buf, reg, mode);
969 return description.size;
971 ASSERT(which_cpu >= 0 && which_cpu < system->nr_cpus);
973 processor = system->processors[which_cpu];
975 /* If the data is comming in raw (target order), need to cook it
976 into host order before putting it into PSIM's internal structures */
977 if (mode == raw_transfer) {
978 switch (description.size) {
980 *(unsigned_1*)cooked_buf = T2H_1(*(unsigned_1*)buf);
983 *(unsigned_2*)cooked_buf = T2H_2(*(unsigned_2*)buf);
986 *(unsigned_4*)cooked_buf = T2H_4(*(unsigned_4*)buf);
989 *(unsigned_8*)cooked_buf = T2H_8(*(unsigned_8*)buf);
993 if (CURRENT_HOST_BYTE_ORDER != CURRENT_TARGET_BYTE_ORDER)
995 union { vreg v; unsigned_8 d[2]; } h, t;
996 memcpy(&t.v/*dest*/, buf/*src*/, description.size);
997 { _SWAP_8(h.d[0] =, t.d[1]); }
998 { _SWAP_8(h.d[1] =, t.d[0]); }
999 memcpy(cooked_buf/*dest*/, &h/*src*/, description.size);
1003 memcpy(cooked_buf/*dest*/, buf/*src*/, description.size);
1008 memcpy(cooked_buf/*dest*/, buf/*src*/, description.size);
1011 /* put the cooked value into the register */
1012 switch (description.type) {
1015 cpu_registers(processor)->gpr[description.index] = *(gpreg*)cooked_buf;
1019 cpu_registers(processor)->fpr[description.index] = *(fpreg*)cooked_buf;
1023 cpu_set_program_counter(processor, *(unsigned_word*)cooked_buf);
1027 cpu_registers(processor)->spr[description.index] = *(spreg*)cooked_buf;
1031 cpu_registers(processor)->sr[description.index] = *(sreg*)cooked_buf;
1035 cpu_registers(processor)->cr = *(creg*)cooked_buf;
1039 cpu_registers(processor)->msr = *(msreg*)cooked_buf;
1043 cpu_registers(processor)->fpscr = *(fpscreg*)cooked_buf;
1048 cpu_registers(processor)->e500.gprh[description.index] = *(gpreg*)cooked_buf;
1054 v = *(unsigned64*)cooked_buf;
1055 cpu_registers(processor)->e500.gprh[description.index] = v >> 32;
1056 cpu_registers(processor)->gpr[description.index] = v;
1061 cpu_registers(processor)->e500.acc = *(accreg*)cooked_buf;
1067 cpu_registers(processor)->altivec.vr[description.index] = *(vreg*)cooked_buf;
1071 cpu_registers(processor)->altivec.vscr = *(vscreg*)cooked_buf;
1076 printf_filtered("psim_write_register(processor=0x%lx,cooked_buf=0x%lx,reg=%s) %s\n",
1077 (unsigned long)processor, (unsigned long)cooked_buf, reg,
1078 "read of this register unimplemented");
1083 return description.size;
1090 psim_read_memory(psim *system,
1093 unsigned_word vaddr,
1097 if (which_cpu == MAX_NR_PROCESSORS) {
1098 if (system->last_cpu == system->nr_cpus
1099 || system->last_cpu == -1)
1102 which_cpu = system->last_cpu;
1104 processor = system->processors[which_cpu];
1105 return vm_data_map_read_buffer(cpu_data_map(processor),
1106 buffer, vaddr, nr_bytes,
1113 psim_write_memory(psim *system,
1116 unsigned_word vaddr,
1118 int violate_read_only_section)
1121 if (which_cpu == MAX_NR_PROCESSORS) {
1122 if (system->last_cpu == system->nr_cpus
1123 || system->last_cpu == -1)
1126 which_cpu = system->last_cpu;
1128 ASSERT(which_cpu >= 0 && which_cpu < system->nr_cpus);
1129 processor = system->processors[which_cpu];
1130 return vm_data_map_write_buffer(cpu_data_map(processor),
1131 buffer, vaddr, nr_bytes, 1/*violate-read-only*/,
1138 psim_print_info(psim *system,
1141 mon_print_info(system, system->monitor, verbose);
1145 /* Merge a device tree and a device file. */
1149 psim_merge_device_file(device *root,
1150 const char *file_name)
1154 char device_path[1000];
1157 /* try opening the file */
1158 description = fopen(file_name, "r");
1159 if (description == NULL) {
1161 error("Invalid file %s specified", file_name);
1166 while (fgets(device_path, sizeof(device_path), description)) {
1168 /* check that the full line was read */
1169 if (strchr(device_path, '\n') == NULL) {
1170 fclose(description);
1171 error("%s:%d: line to long - %s",
1172 file_name, line_nr, device_path);
1175 *strchr(device_path, '\n') = '\0';
1177 /* skip comments ("#" or ";") and blank lines lines */
1178 for (device = device_path;
1179 *device != '\0' && isspace(*device);
1181 if (device[0] == '#'
1183 || device[0] == '\0')
1185 /* merge any appended lines */
1186 while (device_path[strlen(device_path) - 1] == '\\') {
1187 int curlen = strlen(device_path) - 1;
1189 device_path[curlen] = '\0';
1190 /* append the next line */
1191 if (!fgets(device_path + curlen, sizeof(device_path) - curlen, description)) {
1192 fclose(description);
1193 error("%s:%s: unexpected eof in line continuation - %s",
1194 file_name, line_nr, device_path);
1196 if (strchr(device_path, '\n') == NULL) {
1197 fclose(description);
1198 error("%s:%d: line to long - %s",
1199 file_name, line_nr, device_path);
1202 *strchr(device_path, '\n') = '\0';
1205 /* parse this line */
1206 current = tree_parse(current, "%s", device);
1208 fclose(description);
1212 #endif /* _PSIM_C_ */