| /* Main simulator entry points specific to the CRIS. | |
| Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. | |
| Contributed by Axis Communications. | |
| This file is part of the GNU simulators. | |
| 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 3 of the License, 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, see <http://www.gnu.org/licenses/>. */ | |
| /* Based on the fr30 file, mixing in bits from the i960 and pruning of | |
| dead code. */ | |
| #include "libiberty.h" | |
| #include "bfd.h" | |
| #include "sim-main.h" | |
| #ifdef HAVE_STDLIB_H | |
| #include <stdlib.h> | |
| #endif | |
| #include "sim-options.h" | |
| #include "dis-asm.h" | |
| /* Apparently the autoconf bits are missing (though HAVE_ENVIRON is used | |
| in other dirs; also lacking there). Patch around it for major systems. */ | |
| #if defined (HAVE_ENVIRON) || defined (__GLIBC__) | |
| extern char **environ; | |
| #define GET_ENVIRON() environ | |
| #else | |
| char *missing_environ[] = { "SHELL=/bin/sh", "PATH=/bin:/usr/bin", NULL }; | |
| #define GET_ENVIRON() missing_environ | |
| #endif | |
| /* AUX vector entries. */ | |
| #define TARGET_AT_NULL 0 | |
| #define TARGET_AT_PHDR 3 | |
| #define TARGET_AT_PHENT 4 | |
| #define TARGET_AT_PHNUM 5 | |
| #define TARGET_AT_PAGESZ 6 | |
| #define TARGET_AT_BASE 7 | |
| #define TARGET_AT_FLAGS 8 | |
| #define TARGET_AT_ENTRY 9 | |
| #define TARGET_AT_UID 11 | |
| #define TARGET_AT_EUID 12 | |
| #define TARGET_AT_GID 13 | |
| #define TARGET_AT_EGID 14 | |
| #define TARGET_AT_HWCAP 16 | |
| #define TARGET_AT_CLKTCK 17 | |
| /* Used with get_progbounds to find out how much memory is needed for the | |
| program. We don't want to allocate more, since that could mask | |
| invalid memory accesses program bugs. */ | |
| struct progbounds { | |
| USI startmem; | |
| USI endmem; | |
| }; | |
| static void free_state (SIM_DESC); | |
| static void get_progbounds (bfd *, asection *, void *); | |
| static SIM_RC cris_option_handler (SIM_DESC, sim_cpu *, int, char *, int); | |
| /* Since we don't build the cgen-opcode table, we use the old | |
| disassembler. */ | |
| static CGEN_DISASSEMBLER cris_disassemble_insn; | |
| /* By default, we set up stack and environment variables like the Linux | |
| kernel. */ | |
| static char cris_bare_iron = 0; | |
| /* Whether 0x9000000xx have simulator-specific meanings. */ | |
| char cris_have_900000xxif = 0; | |
| /* What to do when we face a more or less unknown syscall. */ | |
| enum cris_unknown_syscall_action_type cris_unknown_syscall_action | |
| = CRIS_USYSC_MSG_STOP; | |
| /* Records simulator descriptor so utilities like cris_dump_regs can be | |
| called from gdb. */ | |
| SIM_DESC current_state; | |
| /* CRIS-specific options. */ | |
| typedef enum { | |
| OPTION_CRIS_STATS = OPTION_START, | |
| OPTION_CRIS_TRACE, | |
| OPTION_CRIS_NAKED, | |
| OPTION_CRIS_900000XXIF, | |
| OPTION_CRIS_UNKNOWN_SYSCALL | |
| } CRIS_OPTIONS; | |
| static const OPTION cris_options[] = | |
| { | |
| { {"cris-cycles", required_argument, NULL, OPTION_CRIS_STATS}, | |
| '\0', "basic|unaligned|schedulable|all", | |
| "Dump execution statistics", | |
| cris_option_handler, NULL }, | |
| { {"cris-trace", required_argument, NULL, OPTION_CRIS_TRACE}, | |
| '\0', "basic", | |
| "Emit trace information while running", | |
| cris_option_handler, NULL }, | |
| { {"cris-naked", no_argument, NULL, OPTION_CRIS_NAKED}, | |
| '\0', NULL, "Don't set up stack and environment", | |
| cris_option_handler, NULL }, | |
| { {"cris-900000xx", no_argument, NULL, OPTION_CRIS_900000XXIF}, | |
| '\0', NULL, "Define addresses at 0x900000xx with simulator semantics", | |
| cris_option_handler, NULL }, | |
| { {"cris-unknown-syscall", required_argument, NULL, | |
| OPTION_CRIS_UNKNOWN_SYSCALL}, | |
| '\0', "stop|enosys|enosys-quiet", "Action at an unknown system call", | |
| cris_option_handler, NULL }, | |
| { {NULL, no_argument, NULL, 0}, '\0', NULL, NULL, NULL, NULL } | |
| }; | |
| /* Add the CRIS-specific option list to the simulator. */ | |
| SIM_RC | |
| cris_option_install (SIM_DESC sd) | |
| { | |
| SIM_ASSERT (STATE_MAGIC (sd) == SIM_MAGIC_NUMBER); | |
| if (sim_add_option_table (sd, NULL, cris_options) != SIM_RC_OK) | |
| return SIM_RC_FAIL; | |
| return SIM_RC_OK; | |
| } | |
| /* Handle CRIS-specific options. */ | |
| static SIM_RC | |
| cris_option_handler (SIM_DESC sd, sim_cpu *cpu ATTRIBUTE_UNUSED, int opt, | |
| char *arg, int is_command ATTRIBUTE_UNUSED) | |
| { | |
| /* The options are CRIS-specific, but cpu-specific option-handling is | |
| broken; required to being with "--cpu0-". We store the flags in an | |
| unused field in the global state structure and move the flags over | |
| to the module-specific CPU data when we store things in the | |
| cpu-specific structure. */ | |
| char *tracefp = STATE_TRACE_FLAGS (sd); | |
| switch ((CRIS_OPTIONS) opt) | |
| { | |
| case OPTION_CRIS_STATS: | |
| if (strcmp (arg, "basic") == 0) | |
| *tracefp = FLAG_CRIS_MISC_PROFILE_SIMPLE; | |
| else if (strcmp (arg, "unaligned") == 0) | |
| *tracefp | |
| = (FLAG_CRIS_MISC_PROFILE_UNALIGNED | |
| | FLAG_CRIS_MISC_PROFILE_SIMPLE); | |
| else if (strcmp (arg, "schedulable") == 0) | |
| *tracefp | |
| = (FLAG_CRIS_MISC_PROFILE_SCHEDULABLE | |
| | FLAG_CRIS_MISC_PROFILE_SIMPLE); | |
| else if (strcmp (arg, "all") == 0) | |
| *tracefp = FLAG_CRIS_MISC_PROFILE_ALL; | |
| else | |
| { | |
| /* Beware; the framework does not handle the error case; | |
| we have to do it ourselves. */ | |
| sim_io_eprintf (sd, "Unknown option `--cris-cycles=%s'\n", arg); | |
| return SIM_RC_FAIL; | |
| } | |
| break; | |
| case OPTION_CRIS_TRACE: | |
| if (strcmp (arg, "basic") == 0) | |
| *tracefp |= FLAG_CRIS_MISC_PROFILE_XSIM_TRACE; | |
| else | |
| { | |
| sim_io_eprintf (sd, "Unknown option `--cris-trace=%s'\n", arg); | |
| return SIM_RC_FAIL; | |
| } | |
| break; | |
| case OPTION_CRIS_NAKED: | |
| cris_bare_iron = 1; | |
| break; | |
| case OPTION_CRIS_900000XXIF: | |
| cris_have_900000xxif = 1; | |
| break; | |
| case OPTION_CRIS_UNKNOWN_SYSCALL: | |
| if (strcmp (arg, "enosys") == 0) | |
| cris_unknown_syscall_action = CRIS_USYSC_MSG_ENOSYS; | |
| else if (strcmp (arg, "enosys-quiet") == 0) | |
| cris_unknown_syscall_action = CRIS_USYSC_QUIET_ENOSYS; | |
| else if (strcmp (arg, "stop") == 0) | |
| cris_unknown_syscall_action = CRIS_USYSC_MSG_STOP; | |
| else | |
| { | |
| sim_io_eprintf (sd, "Unknown option `--cris-unknown-syscall=%s'\n", | |
| arg); | |
| return SIM_RC_FAIL; | |
| } | |
| break; | |
| default: | |
| /* We'll actually never get here; the caller handles the error | |
| case. */ | |
| sim_io_eprintf (sd, "Unknown option `%s'\n", arg); | |
| return SIM_RC_FAIL; | |
| } | |
| /* Imply --profile-model=on. */ | |
| return sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on"); | |
| } | |
| /* 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); | |
| } | |
| /* BFD section iterator to find the highest allocated section address | |
| (plus one). If we could, we should use the program header table | |
| instead, but we can't get to that using bfd. */ | |
| void | |
| get_progbounds (bfd *abfd ATTRIBUTE_UNUSED, asection *s, void *vp) | |
| { | |
| struct progbounds *pbp = (struct progbounds *) vp; | |
| if ((bfd_get_section_flags (abfd, s) & SEC_ALLOC)) | |
| { | |
| bfd_size_type sec_size = bfd_get_section_size (s); | |
| bfd_size_type sec_start = bfd_get_section_vma (abfd, s); | |
| bfd_size_type sec_end = sec_start + sec_size; | |
| if (sec_end > pbp->endmem) | |
| pbp->endmem = sec_end; | |
| if (sec_start < pbp->startmem) | |
| pbp->startmem = sec_start; | |
| } | |
| } | |
| /* Create an instance of the simulator. */ | |
| SIM_DESC | |
| sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd, | |
| char **argv) | |
| { | |
| char c; | |
| int i; | |
| USI startmem = 0; | |
| USI endmem = CRIS_DEFAULT_MEM_SIZE; | |
| USI endbrk = endmem; | |
| USI stack_low = 0; | |
| SIM_DESC sd = sim_state_alloc (kind, callback); | |
| /* Can't initialize to "" below. It's either a GCC bug in old | |
| releases (up to and including 2.95.3 (.4 in debian) or a bug in the | |
| standard ;-) that the rest of the elements won't be initialized. */ | |
| bfd_byte sp_init[4] = {0, 0, 0, 0}; | |
| /* 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 (sim_pre_argv_init (sd, argv[0]) != SIM_RC_OK) | |
| { | |
| free_state (sd); | |
| return 0; | |
| } | |
| /* 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; | |
| } | |
| /* If we have a binary program, endianness-setting would not be taken | |
| from elsewhere unfortunately, so set it here. At the time of this | |
| writing, it isn't used until sim_config, but that might change so | |
| set it here before memory is defined or touched. */ | |
| current_target_byte_order = LITTLE_ENDIAN; | |
| /* check for/establish the reference program image */ | |
| if (sim_analyze_program (sd, | |
| (STATE_PROG_ARGV (sd) != NULL | |
| ? *STATE_PROG_ARGV (sd) | |
| : NULL), | |
| abfd) != SIM_RC_OK) | |
| { | |
| free_state (sd); | |
| return 0; | |
| } | |
| /* For CRIS simulator-specific use, we need to find out the bounds of | |
| the program as well, which is not done by sim_analyze_program | |
| above. */ | |
| if (STATE_PROG_BFD (sd)) | |
| { | |
| struct progbounds pb; | |
| /* The sections should now be accessible using bfd functions. */ | |
| pb.startmem = 0x7fffffff; | |
| pb.endmem = 0; | |
| bfd_map_over_sections (STATE_PROG_BFD (sd), get_progbounds, &pb); | |
| /* We align the area that the program uses to page boundaries. */ | |
| startmem = pb.startmem & ~8191; | |
| endbrk = pb.endmem; | |
| endmem = (endbrk + 8191) & ~8191; | |
| } | |
| /* Find out how much room is needed for the environment and argv, create | |
| that memory and fill it. Only do this when there's a program | |
| specified. */ | |
| if (STATE_PROG_BFD (sd) && !cris_bare_iron) | |
| { | |
| char *name = bfd_get_filename (STATE_PROG_BFD (sd)); | |
| char **my_environ = GET_ENVIRON (); | |
| /* We use these maps to give the same behavior as the old xsim | |
| simulator. */ | |
| USI envtop = 0x40000000; | |
| USI stacktop = 0x3e000000; | |
| USI envstart; | |
| int envc; | |
| int len = strlen (name) + 1; | |
| USI epp, epp0; | |
| USI stacklen; | |
| int i; | |
| char **prog_argv = STATE_PROG_ARGV (sd); | |
| int my_argc = 0; | |
| /* All CPU:s have the same memory map, apparently. */ | |
| SIM_CPU *cpu = STATE_CPU (sd, 0); | |
| USI csp; | |
| bfd_byte buf[4]; | |
| /* Count in the environment as well. */ | |
| for (envc = 0; my_environ[envc] != NULL; envc++) | |
| len += strlen (my_environ[envc]) + 1; | |
| for (i = 0; prog_argv[i] != NULL; my_argc++, i++) | |
| len += strlen (prog_argv[i]) + 1; | |
| envstart = (envtop - len) & ~8191; | |
| /* Create read-only block for the environment strings. */ | |
| sim_core_attach (sd, NULL, 0, access_read, 0, | |
| envstart, (len + 8191) & ~8191, | |
| 0, NULL, NULL); | |
| /* This shouldn't happen. */ | |
| if (envstart < stacktop) | |
| stacktop = envstart - 64 * 8192; | |
| csp = stacktop; | |
| /* Note that the linux kernel does not correctly compute the storage | |
| needs for the static-exe AUX vector. */ | |
| csp -= 4 * 4 * 2; | |
| csp -= (envc + 1) * 4; | |
| csp -= (my_argc + 1) * 4; | |
| csp -= 4; | |
| /* Write the target representation of the start-up-value for the | |
| stack-pointer suitable for register initialization below. */ | |
| bfd_putl32 (csp, sp_init); | |
| /* If we make this 1M higher; say 8192*1024, we have to take | |
| special precautions for pthreads, because pthreads assumes that | |
| the memory that low isn't mmapped, and that it can mmap it | |
| without fallback in case of failure (and we fail ungracefully | |
| long before *that*: the memory isn't accounted for in our mmap | |
| list). */ | |
| stack_low = (csp - (7168*1024)) & ~8191; | |
| stacklen = stacktop - stack_low; | |
| /* Tee hee, we have an executable stack. Well, it's necessary to | |
| test GCC trampolines... */ | |
| sim_core_attach (sd, NULL, 0, access_read_write_exec, 0, | |
| stack_low, stacklen, | |
| 0, NULL, NULL); | |
| epp = epp0 = envstart; | |
| /* 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 \ | |
| { \ | |
| USI data_ = data; \ | |
| USI addr_ = addr; \ | |
| bfd_putl32 (data_, buf); \ | |
| if (sim_core_write_buffer (sd, cpu, 0, buf, addr_, 4) != 4) \ | |
| goto abandon_chip; \ | |
| } \ | |
| while (0) | |
| write_dword (csp, my_argc); | |
| csp += 4; | |
| for (i = 0; i < my_argc; i++, csp += 4) | |
| { | |
| size_t strln = strlen (prog_argv[i]) + 1; | |
| if (sim_core_write_buffer (sd, cpu, 0, prog_argv[i], epp, strln) | |
| != strln) | |
| goto abandon_chip; | |
| write_dword (csp, envstart + epp - epp0); | |
| epp += strln; | |
| } | |
| write_dword (csp, 0); | |
| csp += 4; | |
| for (i = 0; i < envc; i++, csp += 4) | |
| { | |
| unsigned int strln = strlen (my_environ[i]) + 1; | |
| if (sim_core_write_buffer (sd, cpu, 0, my_environ[i], epp, strln) | |
| != strln) | |
| goto abandon_chip; | |
| write_dword (csp, envstart + epp - epp0); | |
| epp += strln; | |
| } | |
| write_dword (csp, 0); | |
| csp += 4; | |
| #define NEW_AUX_ENT(nr, id, val) \ | |
| do \ | |
| { \ | |
| write_dword (csp + (nr) * 4 * 2, (id)); \ | |
| write_dword (csp + (nr) * 4 * 2 + 4, (val)); \ | |
| } \ | |
| while (0) | |
| /* Note that there are some extra AUX entries for a dynlinked | |
| program loaded image. */ | |
| /* AUX entries always present. */ | |
| NEW_AUX_ENT (0, TARGET_AT_HWCAP, 0); | |
| NEW_AUX_ENT (1, TARGET_AT_PAGESZ, 8192); | |
| NEW_AUX_ENT (2, TARGET_AT_CLKTCK, 100); | |
| csp += 4 * 2 * 3; | |
| NEW_AUX_ENT (0, TARGET_AT_NULL, 0); | |
| #undef NEW_AUX_ENT | |
| /* Register R10 should hold 0 at static start (no initfunc), but | |
| that's the default, so don't bother. */ | |
| } | |
| /* Allocate core managed memory if none specified by user. */ | |
| if (sim_core_read_buffer (sd, NULL, read_map, &c, startmem, 1) == 0) | |
| sim_do_commandf (sd, "memory region 0x%lx,0x%lx", startmem, | |
| endmem - startmem); | |
| /* Allocate simulator I/O managed memory if none specified by user. */ | |
| if (cris_have_900000xxif) | |
| { | |
| if (sim_core_read_buffer (sd, NULL, read_map, &c, 0x90000000, 1) == 0) | |
| sim_core_attach (sd, NULL, 0, access_write, 0, 0x90000000, 0x100, | |
| 0, &cris_devices, NULL); | |
| else | |
| { | |
| (*callback-> | |
| printf_filtered) (callback, | |
| "Seeing --cris-900000xx with memory defined there\n"); | |
| goto abandon_chip; | |
| } | |
| } | |
| /* Establish any remaining configuration options. */ | |
| if (sim_config (sd) != SIM_RC_OK) | |
| { | |
| abandon_chip: | |
| 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 = cris_cgen_cpu_open_1 (STATE_ARCHITECTURE (sd)->printable_name, | |
| CGEN_ENDIAN_LITTLE); | |
| for (i = 0; i < MAX_NR_PROCESSORS; ++i) | |
| { | |
| SIM_CPU *cpu = STATE_CPU (sd, i); | |
| CPU_CPU_DESC (cpu) = cd; | |
| CPU_DISASSEMBLER (cpu) = cris_disassemble_insn; | |
| /* See cris_option_handler for the reason why this is needed. */ | |
| CPU_CRIS_MISC_PROFILE (cpu)->flags = STATE_TRACE_FLAGS (sd)[0]; | |
| /* Set SP to the stack we allocated above. */ | |
| (* CPU_REG_STORE (cpu)) (cpu, H_GR_SP, (char *) sp_init, 4); | |
| /* Set the simulator environment data. */ | |
| cpu->highest_mmapped_page = NULL; | |
| cpu->endmem = endmem; | |
| cpu->endbrk = endbrk; | |
| cpu->stack_low = stack_low; | |
| cpu->syscalls = 0; | |
| cpu->m1threads = 0; | |
| cpu->threadno = 0; | |
| cpu->max_threadid = 0; | |
| cpu->thread_data = NULL; | |
| memset (cpu->sighandler, 0, sizeof (cpu->sighandler)); | |
| cpu->make_thread_cpu_data = NULL; | |
| cpu->thread_cpu_data_size = 0; | |
| #if WITH_HW | |
| cpu->deliver_interrupt = NULL; | |
| #endif | |
| } | |
| #if WITH_HW | |
| /* Always be cycle-accurate and call before/after functions if | |
| with-hardware. */ | |
| sim_profile_set_option (sd, "-model", PROFILE_MODEL_IDX, "on"); | |
| #endif | |
| } | |
| /* Initialize various cgen things not done by common framework. | |
| Must be done after cris_cgen_cpu_open. */ | |
| cgen_init (sd); | |
| /* Store in a global so things like cris_dump_regs can be invoked | |
| from the gdb command line. */ | |
| current_state = sd; | |
| cris_set_callbacks (callback); | |
| return sd; | |
| } | |
| void | |
| sim_close (SIM_DESC sd, int quitting ATTRIBUTE_UNUSED) | |
| { | |
| cris_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 ATTRIBUTE_UNUSED, | |
| char **envp ATTRIBUTE_UNUSED) | |
| { | |
| SIM_CPU *current_cpu = STATE_CPU (sd, 0); | |
| SIM_ADDR addr; | |
| if (abfd != NULL) | |
| addr = bfd_get_start_address (abfd); | |
| else | |
| addr = 0; | |
| sim_pc_set (current_cpu, addr); | |
| /* Other simulators have #if 0:d code that says | |
| STATE_ARGV (sd) = sim_copy_argv (argv); | |
| STATE_ENVP (sd) = sim_copy_argv (envp); | |
| Enabling that gives you not-found link-errors for sim_copy_argv. | |
| FIXME: Do archaeology to find out more. */ | |
| return SIM_RC_OK; | |
| } | |
| void | |
| sim_do_command (SIM_DESC sd, char *cmd) | |
| { | |
| if (sim_args_command (sd, cmd) != SIM_RC_OK) | |
| sim_io_eprintf (sd, "Unknown command `%s'\n", cmd); | |
| } | |
| /* Disassemble an instruction. */ | |
| static void | |
| cris_disassemble_insn (SIM_CPU *cpu, | |
| const CGEN_INSN *insn ATTRIBUTE_UNUSED, | |
| const ARGBUF *abuf ATTRIBUTE_UNUSED, | |
| IADDR pc, char *buf) | |
| { | |
| disassembler_ftype pinsn; | |
| struct disassemble_info disasm_info; | |
| SFILE sfile; | |
| SIM_DESC sd = CPU_STATE (cpu); | |
| sfile.buffer = sfile.current = buf; | |
| INIT_DISASSEMBLE_INFO (disasm_info, (FILE *) &sfile, | |
| (fprintf_ftype) sim_disasm_sprintf); | |
| disasm_info.endian = | |
| (bfd_big_endian (STATE_PROG_BFD (sd)) ? BFD_ENDIAN_BIG | |
| : bfd_little_endian (STATE_PROG_BFD (sd)) ? BFD_ENDIAN_LITTLE | |
| : BFD_ENDIAN_UNKNOWN); | |
| /* We live with the cast until the prototype is fixed, or else we get a | |
| warning because the functions differ in the signedness of one parameter. */ | |
| disasm_info.read_memory_func = | |
| sim_disasm_read_memory; | |
| disasm_info.memory_error_func = sim_disasm_perror_memory; | |
| disasm_info.application_data = (PTR) cpu; | |
| pinsn = cris_get_disassembler (STATE_PROG_BFD (sd)); | |
| (*pinsn) (pc, &disasm_info); | |
| } |