| /* Main simulator entry points specific to the ARC. |
| Copyright (C) 1996, 1997, 1998, 1999, 2003, 2004, 2005, 2006, 2007, 2008, |
| 2009 Free Software Foundation, Inc. |
| |
| This file is part of GDB, the GNU debugger. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License along |
| with this program; if not, write to the Free Software Foundation, Inc., |
| 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
| |
| |
| /******************************************************************************/ |
| /* */ |
| /* Outline: */ |
| /* This module provides operations to: */ |
| /* */ |
| /* 1) create an "instance" of the ARC simulator */ |
| /* 2) destroy an "instance" of the ARC simulator */ |
| /* 3) create an "inferior" to run on the simulator */ |
| /* 4) execute a simulator-related command */ |
| /* */ |
| /* N.B. there can be only one simulator instance at a time because of the */ |
| /* use of the current_state global variable. */ |
| /* */ |
| /* This module is also responsible for setting up the "command line" */ |
| /* arguments and environment (name/value pairs) to be passed to the */ |
| /* program that is to be debugged. This data is passed on the stack above */ |
| /* the top of stack as it is known to the program. */ |
| /* */ |
| /* E.g. if we are passing 4 arguments to main, we must place the data on */ |
| /* the stack as: */ |
| /* */ |
| /* . */ |
| /* . */ |
| /* stack[top + A3] <== <arg_3> */ |
| /* . */ |
| /* . */ |
| /* stack[top + A2] <== <arg_2> */ |
| /* . */ |
| /* . */ |
| /* stack[top + A1] <== <arg_1> */ |
| /* . */ |
| /* . */ |
| /* stack[top + A0] <== <arg_0> */ |
| /* stack[top + 28] <== 0x0 # ? NULL terminator */ |
| /* stack[top + 24] <== 0x0 # envp NULL terminator */ |
| /* stack[top + 20] <== 0x0 # argv NULL terminator */ |
| /* stack[top + 16] <== TOP + A3 # argv[3] */ |
| /* stack[top + 12] <== TOP + A2 # argv[2] */ |
| /* stack[top + 8] <== TOP + A1 # argv[1] */ |
| /* stack[top + 4] <== TOP + A0 # argv[0] */ |
| /* stack[top ] <== 0x4 # argc */ |
| /* */ |
| /* where TOP = &stack[top] */ |
| /* and A0 .. A3 are the offsets of the stored arguments from the stack */ |
| /* top. */ |
| /* */ |
| /* */ |
| /* Notes: */ |
| /* The interface to this module is somewhat muddled: both sim_open and */ |
| /* sim_create_inferior have a BFD parameter which denotes the executable */ |
| /* file which is to be run; but for sim_open this parameter may be NULL. */ |
| /* */ |
| /* Also, both sim_open and sim_create_inferior have an argv parameter, */ |
| /* but for sim_open *some* of the strings in this array parameter may be */ |
| /* command-line arguments to be passed to the program to be executed, */ |
| /* whilst the others are arguments for the simulator itself; but for */ |
| /* sim_create_inferior, *all* of the strings (if any) in this parameter */ |
| /* are such command-line arguments. */ |
| /* */ |
| /* Finally, sim_create_inferior has an envp parameter which holds a set */ |
| /* of name/value pairs to be passed as the environment of the executed */ |
| /* program, whereas sim_open does not; but this is not (currently) done. */ |
| /* */ |
| /* */ |
| /* This complexity arises from the variety of ways in which a simulator */ |
| /* instance may be created and used: */ |
| /* */ |
| /* a) the instance may be created by gdb before the executable file is */ |
| /* known; e.g. the user may issue the commands */ |
| /* */ |
| /* set endian big | little */ |
| /* target sim */ |
| /* file <executable> */ |
| /* load */ |
| /* run */ |
| /* */ |
| /* and in this case the BFD parameter to sim_open is NULL, and its */ |
| /* argv parameter does not hold the executable's arguments; */ |
| /* */ |
| /* b) the instance may be created by gdb after the executable file is */ |
| /* known; e.g. the user may issue the commands */ |
| /* */ |
| /* file <executable> */ |
| /* target sim */ |
| /* load */ |
| /* run */ |
| /* */ |
| /* and in this case the BFD parameter to sim_open is non-NULL, and */ |
| /* its argv parameter does not hold the executable's arguments; */ |
| /* */ |
| /* c) the instance may be created by a standalone executable; e.g. */ |
| /* known; e.g. the user may issue the command */ |
| /* */ |
| /* run <executable> [ <arg1> .. <argN> ] */ |
| /* */ |
| /* and in this case the BFD parameter to sim_open is non-NULL, and */ |
| /* its argv parameter does hold the executable's arguments. */ |
| /* */ |
| /* Note that in each case, the argv parameter to sim_create_inferior */ |
| /* holds the command-line arguments for the executable (so, there is */ |
| /* apparently no need for them to be passed in the sim_open argv also!). */ |
| /* */ |
| /* The arguments to the executed program may also be specified in several */ |
| /* ways; e.g by use of the gdb 'set args' command, or as arguments to the */ |
| /* gdb 'run' command; or, in the case of a standalone executable, on the */ |
| /* command line. */ |
| /* */ |
| /* Note that the executable program can be run (by gdb) repeatedly with */ |
| /* different argument lists, i.e. there may be multiple calls of */ |
| /* sim_create_inferior after a call of sim_open; and each of these lists */ |
| /* may require a different amount of memory to hold them on the stack. */ |
| /* */ |
| /* */ |
| /* It is necessary to define a memory region with a particular start */ |
| /* address and size in the simulator memory (all accesses outside this */ |
| /* address range by the executed program are erroneous, thus allowing */ |
| /* invalid accesses to be detected); this region must include the program */ |
| /* text, (un)initialized data, heap and stack. This must also include */ |
| /* the argument/environment data which is passed above the top of the */ |
| /* stack. */ |
| /* */ |
| /* If the executable file is known (i.e. we have a non-NULL BFD), */ |
| /* the bounds of the memory region required for the program may be */ |
| /* extracted from the section header information in the file; if the */ |
| /* arguments/environment are known, the space required to hold them on */ |
| /* the stack may be computed. This allows the total space to be computed, */ |
| /* and so a memory region holding it may be defined. */ |
| /* */ |
| /* However, if a subsequent execution of the program should require a */ |
| /* greater total space (because its arguments have changed) it is then */ |
| /* necessary to define an additional memory region to provide the extra */ |
| /* space; it is not possible to redefine the existing region, or a new */ |
| /* region of the new size (as memory regions may not overlap). */ |
| /* */ |
| /******************************************************************************/ |
| |
| /* system header files */ |
| |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #else |
| #ifdef HAVE_STRINGS_H |
| #include <strings.h> |
| #endif |
| #endif |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| |
| /* simulator / binutils header files */ |
| |
| #include "sim-main.h" |
| #include "sim-options.h" |
| #include "libiberty.h" |
| #include "bfd.h" |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* conditional compilation flags */ |
| /* -------------------------------------------------------------------------- */ |
| |
| //#define LOGGING |
| //#define PUSH_ENVIRONMENT_ONTO_STACK |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* externally visible data */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* Records simulator descriptor so utilities like arc_dump_regs can be called |
| from gdb. */ |
| SIM_DESC current_state; |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local data */ |
| /* -------------------------------------------------------------------------- */ |
| |
| #define DEFAULT_ENVIRONMENT_SPACE 2048 |
| |
| #define TARGET_POINTER_SIZE 4 |
| #define TARGET_INT_SIZE 4 |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local macros */ |
| /* -------------------------------------------------------------------------- */ |
| |
| #define IS_LITTLE_ENDIAN(abfd) (abfd) ? bfd_little_endian (abfd) \ |
| : (CURRENT_TARGET_BYTE_ORDER == LITTLE_ENDIAN) |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* local functions */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* Cover function of sim_state_free to free the cpu buffers as well. */ |
| |
| static void |
| free_state (SIM_DESC sd) |
| { |
| if (STATE_MODULES (sd) != NULL) |
| sim_module_uninstall (sd); |
| sim_cpu_free_all (sd); |
| sim_state_free (sd); |
| } |
| |
| |
| /* PROFILE_CPU_CALLBACK */ |
| |
| static void |
| print_arc_misc_cpu (SIM_CPU *cpu, int verbose) |
| { |
| if (CPU_PROFILE_FLAGS (cpu) [PROFILE_INSN_IDX]) |
| { |
| SIM_DESC sd = CPU_STATE (cpu); |
| char buf[20]; |
| |
| sim_io_printf (sd, "Miscellaneous Statistics\n\n"); |
| sim_io_printf (sd, " %-*s %s\n\n", |
| PROFILE_LABEL_WIDTH, "Fill nops:", |
| sim_add_commas (buf, sizeof (buf), |
| CPU_ARC_MISC_PROFILE (cpu)->fillnop_count)); |
| } |
| } |
| |
| |
| #ifdef LOGGING |
| static void |
| dump (SIM_DESC sd, char** argv, char** envp) |
| { |
| char **cpp, **rpp; |
| char* tag; |
| int cnt; |
| |
| for (cpp = argv, tag = "argv", cnt = 2; cnt--; cpp = envp, tag = "env") |
| { |
| if (cpp) |
| { |
| int i = 0; |
| |
| for (rpp = cpp; *rpp; rpp++, i++) |
| sim_io_eprintf(sd, "%s[%d] = %s\n", tag, i, *rpp); |
| } |
| } |
| } |
| #endif |
| |
| /* Setup copy arguments / environment to the stack area of SD according |
| to argv and envp. Either or both of argv and envp may be NULL. |
| Return 0 on failure, nonzero on success. */ |
| |
| static int |
| setup_stack (SIM_DESC sd, int little_endian_p, char** argv, char** envp) |
| { |
| SIM_CPU* cpu = STATE_CPU (sd, 0); |
| int wpp = sd->memory.stack_top + TARGET_INT_SIZE; |
| int cp = sd->memory.argument_data_start; |
| int count; |
| char** cpp; |
| |
| #ifdef LOGGING |
| sim_io_eprintf(sd, "setup stack (%c/E) %d args\n", |
| (little_endian_p) ? 'L' : 'B', |
| sd->memory.num_arguments); |
| dump(sd, argv, envp); |
| #endif |
| |
| if (sd->memory.stack_top <= sd->memory.stack_start) |
| { |
| host_callback *callback = STATE_CALLBACK (sd); |
| |
| (*callback->printf_filtered) (callback, "stack overflow\n"); |
| return 0; |
| } |
| |
| /* Can't use sim_core_write_unaligned_4 without everything |
| initialized when tracing, and then these writes would get into |
| the trace. */ |
| #define write_dword(addr, data) \ |
| do \ |
| { \ |
| bfd_byte buf[4]; \ |
| USI data_ = data; \ |
| USI addr_ = addr; \ |
| if (little_endian_p) \ |
| bfd_putl32 (data_, buf); \ |
| else \ |
| bfd_putb32 (data_, buf); \ |
| if (sim_core_write_buffer (sd, cpu, 0, buf, addr_, 4) != 4) \ |
| { \ |
| sim_io_eprintf(sd, "failed to write word to address 0x%x\n", addr);\ |
| return 0; \ |
| } \ |
| } \ |
| while (0) |
| |
| |
| /* Push the arguments and environment onto the stack. */ |
| |
| write_dword (sd->memory.stack_top, sd->memory.num_arguments); |
| for (cpp = argv, count = 2; count--; cpp = envp) |
| { |
| if (cpp) |
| { |
| char* argument; |
| char** rpp; |
| |
| for (rpp = cpp; (argument = *cpp); cpp++) |
| { |
| size_t len = strlen(argument) + 1; |
| |
| #ifdef LOGGING |
| sim_io_eprintf(sd, "pushing argument '%s' onto program stack at address 0x%x\n", argument, cp); |
| #endif |
| |
| if (sim_core_write_buffer (sd, cpu, 0, argument, cp, len) != len) |
| { |
| sim_io_eprintf(sd, "could not push argument '%s' onto program stack at address 0x%x\n", argument, cp); |
| return 0; |
| } |
| write_dword (wpp, cp); |
| cp += len; |
| wpp += TARGET_POINTER_SIZE; |
| } |
| } |
| |
| write_dword (wpp, 0); // NULL array terminator |
| wpp += TARGET_POINTER_SIZE; |
| |
| } |
| write_dword (wpp, 0); /* uClibc aux_dat NULL terminator. */ |
| |
| /* success */ |
| return 1; |
| } |
| |
| |
| /* Find out heap and stack end boundaries, and calculate required memory size; |
| if this cannot be done, use the default memory size. |
| ABFD, ARGV and/or ENVP may be NULL. |
| If this calculation fails, return 0. */ |
| |
| static int |
| determine_memory_requirements (SIM_DESC sd, struct bfd *abfd, char **argv, |
| char **envp, struct sim_memory* memory) |
| { |
| USI stack_start = 0, stack_top = 0, heap_start = 0, heap_end = 0; |
| USI program_end = 0; |
| USI memory_size; |
| USI data_start; |
| int argc = 0; |
| size_t total_argument_length = 0; |
| int num_pointers = 0; |
| |
| /* N.B. the *_end variables actually denote the next byte after the end of |
| the sections to which they refer; however, they are used consistently |
| in this way, so that is not a problem! */ |
| |
| /* If we have an executable file to look at. */ |
| if (abfd) |
| { |
| asection* section; |
| |
| /* Look at each section in the file. */ |
| for (section = abfd->sections; section; section = section->next) |
| { |
| if (strcmp (bfd_get_section_name (abfd, section), ".stack") == 0) |
| { |
| stack_start = bfd_get_section_vma (abfd, section); |
| stack_top = stack_start + bfd_section_size (abfd, section); |
| stack_top &= -TARGET_POINTER_SIZE; |
| |
| /* N.B. this assumes that the target memory region to be |
| created has the range 0 .. stack_top - 1, i.e. that there |
| is nothing in the program that has to be loaded at |
| addresses above the stack top. */ |
| memory_size = stack_top; |
| } |
| else if (strcmp (bfd_get_section_name (abfd, section), ".heap") == 0) |
| { |
| heap_start = bfd_get_section_vma (abfd, section); |
| heap_end = heap_start + bfd_section_size (abfd, section); |
| } |
| else if (bfd_get_section_flags(abfd, section) & SEC_LOAD) |
| { |
| USI section_end = bfd_get_section_vma (abfd, section) + |
| bfd_section_size (abfd, section); |
| |
| /* Keep track of the end address of whatever else is to be |
| loaded. */ |
| if (program_end < section_end) |
| program_end = section_end; |
| } |
| } |
| |
| /* If we know the start of the stack, check for an overlap. */ |
| if (stack_start > 0 && program_end > stack_start) |
| { |
| sim_io_eprintf(sd, |
| "program data overlaps program stack at 0x%x (0x%x)\n", |
| stack_start, program_end); |
| return 0; |
| } |
| |
| /* No heap section found? */ |
| if (heap_end == 0) |
| { |
| /* Assume the heap lies between the program data and the stack. */ |
| heap_start = program_end; |
| heap_end = stack_start; |
| } |
| } |
| |
| |
| /* If we have arguments or environment variables to pass to the program. */ |
| |
| if (argv) |
| { |
| char **rpp; |
| |
| for (rpp = argv; *rpp; rpp++, num_pointers++) |
| total_argument_length += strlen (*rpp) + 1; |
| |
| argc = num_pointers; |
| } |
| num_pointers++; /* For NULL terminator. */ |
| |
| if (envp) |
| { |
| char** rpp; |
| |
| for (rpp = envp; *rpp; rpp++, num_pointers++) |
| total_argument_length += strlen (*rpp) + 1; |
| } |
| num_pointers++; /* For NULL terminator. */ |
| |
| num_pointers++; /* For uclibc aux_dat. */ |
| |
| /* If we could not get the stack bounds from the executable file (and hence |
| do not know the memory size), use the default memory size and take the |
| top of the stack as being at the end of that memory range (aligned to |
| the size of a target pointer). */ |
| if (!stack_top) |
| stack_top = (USI) ((ARC_DEFAULT_MEM_SIZE + 3) & -TARGET_POINTER_SIZE); |
| |
| data_start = (USI) (stack_top + |
| TARGET_INT_SIZE + /* For argc. */ |
| num_pointers * TARGET_POINTER_SIZE); |
| |
| /* We need enough memory to hold the program stack, plus the data to be passed |
| above the top of the stack. */ |
| memory_size = (USI) (data_start + total_argument_length); |
| |
| #ifdef PUSH_ENVIRONMENT_ONTO_STACK |
| if (!envp) |
| memory_size += DEFAULT_ENVIRONMENT_SPACE; |
| #endif |
| |
| /* Round up to multiple of 32: strlen expects memory to come in chunks |
| that are at least cache-line (32 bytes) sized. |
| FIXME: is that true? */ |
| memory_size += 31; |
| memory_size &= -32; |
| |
| memory->heap_start = heap_start; |
| memory->heap_end = heap_end; |
| memory->stack_top = stack_top; |
| memory->stack_start = stack_start; |
| memory->total_size = memory_size; |
| memory->argument_data_start = data_start; |
| memory->num_arguments = (USI) argc; |
| |
| #ifdef LOGGING |
| sim_io_eprintf(sd, "heap start : 0x%x\n", heap_start); |
| sim_io_eprintf(sd, "heap end : 0x%x\n", heap_end); |
| sim_io_eprintf(sd, "stack start : 0x%x\n", stack_start); |
| sim_io_eprintf(sd, "stack top : 0x%x\n", stack_top); |
| sim_io_eprintf(sd, "memory size : 0x%x\n", memory_size); |
| sim_io_eprintf(sd, "arg data start: 0x%x\n", data_start); |
| sim_io_eprintf(sd, "%d args\n", argc); |
| #endif |
| |
| /* Success. */ |
| return 1; |
| } |
| |
| |
| static void |
| define_memory_region (SIM_DESC sd, USI start, USI size) |
| { |
| /* Allocate core managed memory if none specified by user. */ |
| if (!sd->memory_regions_defined_by_user) |
| { |
| #ifdef LOGGING |
| sim_io_printf (sd, "memory region 0x%x,0x%x\n", start, size); |
| #endif |
| sim_do_commandf (sd, "memory region 0x%x,0x%x", start, size); |
| } |
| } |
| |
| |
| /* -------------------------------------------------------------------------- */ |
| /* externally visible functions */ |
| /* -------------------------------------------------------------------------- */ |
| |
| /* Create an instance of the simulator. */ |
| |
| SIM_DESC |
| sim_open (SIM_OPEN_KIND kind, |
| host_callback *callback, |
| struct bfd *abfd, /* May be NULL. */ |
| char **argv) |
| { |
| SIM_DESC sd = sim_state_alloc (kind, callback); |
| int little_endian_p; |
| char** prog_argv; |
| char c; |
| |
| SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); |
| |
| #ifdef LOGGING |
| sim_io_eprintf (sd, "sim_open: %p\n", abfd); |
| dump(sd, argv, NULL); |
| #endif |
| |
| /* The cpu data is kept in a separately-allocated chunk of memory. */ |
| if (sim_cpu_alloc_all (sd, 1, cgen_cpu_max_extra_bytes ()) != SIM_RC_OK) |
| { |
| free_state (sd); |
| return 0; |
| } |
| |
| #if 0 /* FIXME: pc is in mach-specific struct. */ |
| /* FIXME: watchpoints code shouldn't need this. */ |
| { |
| SIM_CPU *current_cpu = STATE_CPU (sd, 0); |
| STATE_WATCHPOINTS (sd)->pc = &(PC); |
| STATE_WATCHPOINTS (sd)->sizeof_pc = sizeof (PC); |
| } |
| #endif |
| |
| if (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK) |
| { |
| free_state (sd); |
| return 0; |
| } |
| |
| #ifdef HAVE_DV_SOCKSER /* FIXME: was done differently before. */ |
| if (dv_sockser_install (sd) != SIM_RC_OK) |
| { |
| free_state (sd); |
| return 0; |
| } |
| #endif |
| |
| #if 0 /* FIXME: 'twould be nice if we could do this. */ |
| /* These options override any module options. |
| Obviously ambiguity should be avoided, however the caller may wish to |
| augment the meaning of an option. */ |
| if (extra_options != NULL) |
| sim_add_option_table (sd, extra_options); |
| #endif |
| |
| /* getopt will print the error message so we just have to exit if this fails. |
| FIXME: Hmmm... in the case of gdb we need getopt to call |
| print_filtered. */ |
| if (sim_parse_args (sd, argv) != SIM_RC_OK) |
| { |
| free_state (sd); |
| return 0; |
| } |
| |
| #ifdef LOGGING |
| /* sim_parse_args may set up STATE_PROG_ARGV(sd), in the case that kind == SIM_OPEN_STANDALONE. */ |
| dump(sd, STATE_PROG_ARGV (sd), NULL); |
| #endif |
| |
| /* Check for/establish the reference program image, and set arch info. */ |
| if (sim_analyze_program (sd, |
| (STATE_PROG_ARGV (sd) != NULL |
| ? *STATE_PROG_ARGV (sd) |
| : NULL), |
| abfd) != SIM_RC_OK) |
| { |
| free_state (sd); |
| return 0; |
| } |
| |
| prog_argv = STATE_PROG_ARGV (sd); |
| |
| /* If we have not been given an executable file. */ |
| if (!abfd) |
| { |
| /* If the test below fails, we will use ARC_DEFAULT_MEM_SIZE. */ |
| if (prog_argv != NULL && *prog_argv != NULL) |
| { |
| char* name = *prog_argv; |
| |
| abfd = bfd_openr (name, 0); |
| |
| if (abfd == NULL || !bfd_check_format (abfd, bfd_object)) |
| { |
| free_state (sd); |
| return 0; |
| } |
| } |
| } |
| |
| /* Establish any remaining configuration options. */ |
| if (sim_config (sd) != SIM_RC_OK) |
| { |
| free_state (sd); |
| return 0; |
| } |
| |
| little_endian_p = IS_LITTLE_ENDIAN(abfd); |
| |
| /* Check whether core managed memory has been specified by user. |
| Use address 4 here in case the user wanted address 0 unmapped. |
| N.B. this is really not a very good check - we want to know whether the |
| user has explicitly specified the target's memory regions, so that we |
| don't define a region ourself (which might overlap), and we try to |
| find that out by seeing if we can read the memory at address 0x4 !!!! */ |
| sd->memory_regions_defined_by_user = |
| sim_core_read_buffer (sd, NULL, read_map, &c, 4, 1) != 0; |
| |
| /* Calculate the memory size required without actually initializing the stack. */ |
| if (!determine_memory_requirements(sd, abfd, prog_argv, NULL, &sd->memory)) |
| { |
| free_state (sd); |
| return 0; |
| } |
| |
| define_memory_region (sd, 0, sd->memory.total_size); |
| |
| /* If the simulator is being used stand-alone, we know that the program |
| arguments we have been given here are not going to change later on (when |
| sim_create_inferior is called) - so we can go ahead and set up the stack |
| with those arguments right now. */ |
| if (STATE_OPEN_KIND (sd) == SIM_OPEN_STANDALONE) |
| { |
| /* Now that we do know the memory size, initialize the stack. */ |
| if (!setup_stack (sd, little_endian_p, prog_argv, NULL)) |
| { |
| free_state (sd); |
| return 0; |
| } |
| } |
| |
| if (sim_post_argv_init (sd) != SIM_RC_OK) |
| { |
| free_state (sd); |
| return 0; |
| } |
| |
| /* Open a copy of the cpu descriptor table. */ |
| { |
| CGEN_CPU_DESC cd = arc_cgen_cpu_open_1 |
| (STATE_ARCHITECTURE (sd)->printable_name, |
| (little_endian_p ? CGEN_ENDIAN_LITTLE : CGEN_ENDIAN_BIG)); |
| int i; |
| |
| for (i = 0; i < MAX_NR_PROCESSORS; ++i) |
| { |
| SIM_CPU *cpu = STATE_CPU (sd, i); |
| CPU_CPU_DESC (cpu) = cd; |
| CPU_DISASSEMBLER (cpu) = sim_cgen_disassemble_insn; |
| } |
| |
| arc_cgen_init_dis (cd); |
| } |
| |
| /* Initialize various cgen things not done by common framework. |
| Must be done after arc_cgen_cpu_open. */ |
| cgen_init (sd); |
| |
| for (c = 0; c < MAX_NR_PROCESSORS; c++) |
| { |
| /* Only needed for profiling, but the structure member is small. */ |
| memset (CPU_ARC_MISC_PROFILE (STATE_CPU (sd, i)), 0, |
| sizeof (* CPU_ARC_MISC_PROFILE (STATE_CPU (sd, i)))); |
| |
| /* Hook in callback for reporting these stats. */ |
| PROFILE_INFO_CPU_CALLBACK (CPU_PROFILE_DATA (STATE_CPU (sd, i))) = |
| print_arc_misc_cpu; |
| } |
| |
| /* Store in a global so things like arc32_dump_regs can be invoked |
| from the gdb command line. */ |
| current_state = sd; |
| |
| return sd; |
| } |
| |
| |
| void |
| sim_close (SIM_DESC sd, int quitting) |
| { |
| arc_cgen_cpu_close (CPU_CPU_DESC (STATE_CPU (sd, 0))); |
| sim_module_uninstall (sd); |
| } |
| |
| |
| SIM_RC |
| sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char **argv, char **envp) |
| { |
| SIM_CPU *current_cpu = STATE_CPU (sd, 0); |
| SIM_ADDR addr; |
| |
| #ifndef PUSH_ENVIRONMENT_ONTO_STACK |
| envp = NULL; |
| #endif |
| #ifdef LOGGING |
| sim_io_eprintf (sd, "sim_create_inferior: %p\n", abfd); |
| dump (sd, argv, envp); |
| #endif |
| |
| if (abfd != NULL) |
| { |
| int little_endian_p = bfd_little_endian (abfd); |
| |
| if (little_endian_p) |
| { |
| if (CURRENT_TARGET_BYTE_ORDER == BIG_ENDIAN) |
| { |
| sim_io_eprintf (sd, "Target is big-endian but executable file %s is little-endian.\n", |
| bfd_get_filename (abfd)); |
| return SIM_RC_FAIL; |
| } |
| } |
| else |
| { |
| if (CURRENT_TARGET_BYTE_ORDER == LITTLE_ENDIAN) |
| { |
| sim_io_eprintf (sd, "Target is little-endian but executable file %s is big-endian.\n", |
| bfd_get_filename(abfd)); |
| return SIM_RC_FAIL; |
| } |
| } |
| |
| addr = bfd_get_start_address (abfd); |
| } |
| else |
| addr = 0; |
| |
| sim_pc_set (current_cpu, addr); |
| |
| /* If the simulator is being used stand-alone, we have already set up the |
| stack (when sim_open was called); but if the simulator is being used by |
| gdb we must set up the stack each time that sim_create_inferior is |
| called, in case the program arguments have changed since last time. */ |
| if (STATE_OPEN_KIND(sd) == SIM_OPEN_DEBUG) |
| { |
| struct sim_memory memory; |
| |
| if (determine_memory_requirements (sd, abfd, argv, envp, &memory)) |
| { |
| USI current_size = sd->memory.total_size; |
| |
| if (memory.total_size > current_size) |
| { |
| #ifdef LOGGING |
| sim_io_eprintf (sd, "program requires memory size 0x%x bytes" |
| " but simulator currently has memory size 0x%x bytes\n", |
| memory.total_size, current_size); |
| #endif |
| |
| /* Define another memory region to provide the extra memory |
| required. */ |
| define_memory_region (sd, current_size, |
| memory.total_size - current_size); |
| |
| /* Update all the memory details. */ |
| sd->memory = memory; |
| } |
| else |
| { |
| /* Update all the memory details *except* the current size. */ |
| sd->memory = memory; |
| sd->memory.total_size = current_size; |
| } |
| |
| if (!setup_stack (sd, IS_LITTLE_ENDIAN (abfd), argv, envp)) |
| return SIM_RC_FAIL; |
| } |
| else |
| return SIM_RC_FAIL; |
| } |
| |
| current_cpu->endbrk = sd->memory.heap_start; |
| |
| /* Set r28 (SP) to the stack top, and set r0/r1 to argc/argv. */ |
| a5f_h_cr_set (current_cpu, 0, sd->memory.num_arguments); |
| a5f_h_cr_set (current_cpu, 1, sd->memory.stack_top + 4); |
| a5f_h_cr_set (current_cpu, 28, sd->memory.stack_top); |
| |
| #ifdef LOGGING |
| sim_io_eprintf (sd, "R0 = 0x%08X\n", sd->memory.num_arguments); |
| sim_io_eprintf (sd, "R1 = 0x%08X\n", sd->memory.stack_top + 4); |
| sim_io_eprintf (sd, "SP = 0x%08X\n", sd->memory.stack_top); |
| #endif |
| |
| #if 0 |
| STATE_ARGV (sd) = sim_copy_argv (argv); |
| STATE_ENVP (sd) = sim_copy_argv (envp); |
| #endif |
| |
| return SIM_RC_OK; |
| } |
| |
| |
| void |
| sim_do_command (SIM_DESC sd, char* cmd) |
| { |
| char **argv; |
| |
| if (cmd == NULL) |
| return; |
| |
| argv = buildargv (cmd); |
| |
| /* Is the command 'info reg[ister] <name>' ? */ |
| |
| if (argv[0] != NULL |
| && strcasecmp (argv[0], "info") == 0 |
| && argv[1] != NULL |
| && strncasecmp (argv[1], "reg", 3) == 0) |
| { |
| SI val; |
| |
| if (argv[2] == NULL) |
| sim_io_eprintf (sd, "Missing register in `%s'\n", cmd); |
| else if (argv[3] != NULL) |
| sim_io_eprintf (sd, "Too many arguments in `%s'\n", cmd); |
| |
| /* Should we recognize some/all of the ARC register names here? */ |
| |
| else |
| sim_io_eprintf (sd, "Printing of register `%s' not supported with `sim info'\n", |
| argv[2]); |
| } |
| else |
| { |
| if (sim_args_command (sd, cmd) != SIM_RC_OK) |
| sim_io_eprintf (sd, "Unknown sim command `%s'\n", cmd); |
| } |
| |
| freeargv (argv); |
| } |
| |
| /******************************************************************************/ |
