/* Fetch the interpreter and executable loadmap addresses (for shared library support) for the FDPIC ABI. Return 0 if successful, -1 if not. (E.g, -1 will be returned if the ABI isn't the FDPIC ABI.) */ int frv_fdpic_loadmap_addresses (struct gdbarch *gdbarch, CORE_ADDR *interp_addr, CORE_ADDR *exec_addr) { if (frv_abi (gdbarch) != FRV_ABI_FDPIC) return -1; else { struct regcache *regcache = get_current_regcache (); if (interp_addr != NULL) { ULONGEST val; regcache_cooked_read_unsigned (regcache, fdpic_loadmap_interp_regnum, &val); *interp_addr = val; } if (exec_addr != NULL) { ULONGEST val; regcache_cooked_read_unsigned (regcache, fdpic_loadmap_exec_regnum, &val); *exec_addr = val; } return 0; } }
static void darwin_solib_get_all_image_info_addr_at_init (struct darwin_info *info) { char *interp_name; CORE_ADDR load_addr = 0; bfd *dyld_bfd = NULL; struct cleanup *cleanup; /* This method doesn't work with an attached process. */ if (current_inferior ()->attach_flag) return; /* Find the program interpreter. */ interp_name = find_program_interpreter (); if (!interp_name) return; cleanup = make_cleanup (null_cleanup, NULL); /* Create a bfd for the interpreter. */ dyld_bfd = gdb_bfd_open (interp_name, gnutarget, -1); if (dyld_bfd) { bfd *sub; make_cleanup_bfd_unref (dyld_bfd); sub = gdb_bfd_mach_o_fat_extract (dyld_bfd, bfd_object, gdbarch_bfd_arch_info (target_gdbarch ())); if (sub) { dyld_bfd = sub; make_cleanup_bfd_unref (sub); } else dyld_bfd = NULL; } if (!dyld_bfd) { do_cleanups (cleanup); return; } /* We find the dynamic linker's base address by examining the current pc (which should point at the entry point for the dynamic linker) and subtracting the offset of the entry point. */ load_addr = (regcache_read_pc (get_current_regcache ()) - bfd_get_start_address (dyld_bfd)); /* Now try to set a breakpoint in the dynamic linker. */ info->all_image_addr = lookup_symbol_from_bfd (dyld_bfd, "_dyld_all_image_infos"); do_cleanups (cleanup); if (info->all_image_addr == 0) return; info->all_image_addr += load_addr; }
static void save_bookmark_command (char *args, int from_tty) { /* Get target's idea of a bookmark. */ gdb_byte *bookmark_id = target_get_bookmark (args, from_tty); struct bookmark *b, *b1; struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ()); /* CR should not cause another identical bookmark. */ dont_repeat (); if (bookmark_id == NULL) error (_("target_get_bookmark failed.")); /* Set up a bookmark struct. */ b = xcalloc (1, sizeof (struct bookmark)); b->number = ++bookmark_count; init_sal (&b->sal); b->pc = regcache_read_pc (get_current_regcache ()); b->sal = find_pc_line (b->pc, 0); b->sal.pspace = get_frame_program_space (get_current_frame ()); b->opaque_data = bookmark_id; b->next = NULL; /* Add this bookmark to the end of the chain, so that a list of bookmarks will come out in order of increasing numbers. */ b1 = bookmark_chain; if (b1 == 0) bookmark_chain = b; else { while (b1->next) b1 = b1->next; b1->next = b; } printf_filtered (_("Saved bookmark %d at %s\n"), b->number, paddress (gdbarch, b->sal.pc)); }
char * fbsd_make_corefile_notes (bfd *obfd, int *note_size) { const struct regcache *regcache = get_current_regcache (); struct gdbarch *gdbarch = get_regcache_arch (regcache); gregset_t gregs; fpregset_t fpregs; char *note_data = NULL; Elf_Internal_Ehdr *i_ehdrp; const struct regset *regset; size_t size; /* Put a "FreeBSD" label in the ELF header. */ i_ehdrp = elf_elfheader (obfd); i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD; gdb_assert (gdbarch_regset_from_core_section_p (gdbarch)); size = sizeof gregs; regset = gdbarch_regset_from_core_section (gdbarch, ".reg", size); gdb_assert (regset && regset->collect_regset); regset->collect_regset (regset, regcache, -1, &gregs, size); note_data = elfcore_write_prstatus (obfd, note_data, note_size, ptid_get_pid (inferior_ptid), find_stop_signal (), &gregs); size = sizeof fpregs; regset = gdbarch_regset_from_core_section (gdbarch, ".reg2", size); gdb_assert (regset && regset->collect_regset); regset->collect_regset (regset, regcache, -1, &fpregs, size); note_data = elfcore_write_prfpreg (obfd, note_data, note_size, &fpregs, sizeof (fpregs)); if (get_exec_file (0)) { const char *fname = lbasename (get_exec_file (0)); char *psargs = xstrdup (fname); if (get_inferior_args ()) psargs = reconcat (psargs, psargs, " ", get_inferior_args (), (char *) NULL); note_data = elfcore_write_prpsinfo (obfd, note_data, note_size, fname, psargs); } make_cleanup (xfree, note_data); return note_data; }
static struct value * get_call_return_value (struct call_return_meta_info *ri) { struct value *retval = NULL; int stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid); if (TYPE_CODE (ri->value_type) == TYPE_CODE_VOID) retval = allocate_value (ri->value_type); else if (ri->struct_return_p) { if (stack_temporaries) { retval = value_from_contents_and_address (ri->value_type, NULL, ri->struct_addr); push_thread_stack_temporary (inferior_ptid, retval); } else { retval = allocate_value (ri->value_type); read_value_memory (retval, 0, 1, ri->struct_addr, value_contents_raw (retval), TYPE_LENGTH (ri->value_type)); } } else { retval = allocate_value (ri->value_type); gdbarch_return_value (ri->gdbarch, ri->function, ri->value_type, get_current_regcache (), value_contents_raw (retval), NULL); if (stack_temporaries && class_or_union_p (ri->value_type)) { /* Values of class type returned in registers are copied onto the stack and their lval_type set to lval_memory. This is required because further evaluation of the expression could potentially invoke methods on the return value requiring GDB to evaluate the "this" pointer. To evaluate the this pointer, GDB needs the memory address of the value. */ value_force_lval (retval, ri->struct_addr); push_thread_stack_temporary (inferior_ptid, retval); } } gdb_assert (retval != NULL); return retval; }
static void i386fbsd_resume (struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal signal) { pid_t pid = ptid_get_pid (ptid); int request = PT_STEP; if (pid == -1) /* Resume all threads. This only gets used in the non-threaded case, where "resume all threads" and "resume inferior_ptid" are the same. */ pid = ptid_get_pid (inferior_ptid); if (!step) { struct regcache *regcache = get_current_regcache (); ULONGEST eflags; /* Workaround for a bug in FreeBSD. Make sure that the trace flag is off when doing a continue. There is a code path through the kernel which leaves the flag set when it should have been cleared. If a process has a signal pending (such as SIGALRM) and we do a PT_STEP, the process never really has a chance to run because the kernel needs to notify the debugger that a signal is being sent. Therefore, the process never goes through the kernel's trap() function which would normally clear it. */ regcache_cooked_read_unsigned (regcache, I386_EFLAGS_REGNUM, &eflags); if (eflags & 0x0100) regcache_cooked_write_unsigned (regcache, I386_EFLAGS_REGNUM, eflags & ~0x0100); request = PT_CONTINUE; } /* An addres of (caddr_t) 1 tells ptrace to continue from where it was. (If GDB wanted it to start some other way, we have already written a new PC value to the child.) */ if (ptrace (request, pid, (caddr_t) 1, gdb_signal_to_host (signal)) == -1) perror_with_name (("ptrace")); }
static int ia64_linux_stopped_data_address (struct target_ops *ops, CORE_ADDR *addr_p) { CORE_ADDR psr; siginfo_t siginfo; struct regcache *regcache = get_current_regcache (); if (!linux_nat_get_siginfo (inferior_ptid, &siginfo)) return 0; if (siginfo.si_signo != SIGTRAP || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */) return 0; regcache_cooked_read_unsigned (regcache, IA64_PSR_REGNUM, &psr); psr |= IA64_PSR_DD; /* Set the dd bit - this will disable the watchpoint for the next instruction. */ regcache_cooked_write_unsigned (regcache, IA64_PSR_REGNUM, psr); *addr_p = (CORE_ADDR) siginfo.si_addr; return 1; }
static char * fbsd_make_corefile_notes (struct gdbarch *gdbarch, bfd *obfd, int *note_size) { struct regcache *regcache = get_current_regcache (); char *note_data; Elf_Internal_Ehdr *i_ehdrp; struct fbsd_collect_regset_section_cb_data data; /* Put a "FreeBSD" label in the ELF header. */ i_ehdrp = elf_elfheader (obfd); i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_FREEBSD; gdb_assert (gdbarch_iterate_over_regset_sections_p (gdbarch)); data.regcache = regcache; data.obfd = obfd; data.note_data = NULL; data.note_size = note_size; target_fetch_registers (regcache, -1); gdbarch_iterate_over_regset_sections (gdbarch, fbsd_collect_regset_section_cb, &data, regcache); note_data = data.note_data; if (get_exec_file (0)) { const char *fname = lbasename (get_exec_file (0)); char *psargs = xstrdup (fname); if (get_inferior_args ()) psargs = reconcat (psargs, psargs, " ", get_inferior_args (), (char *) NULL); note_data = elfcore_write_prpsinfo (obfd, note_data, note_size, fname, psargs); } return note_data; }
static CORE_ADDR darwin_read_exec_load_addr_at_init (struct darwin_info *info) { struct gdbarch *gdbarch = target_gdbarch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int addr_size = gdbarch_addr_bit (gdbarch) / 8; ULONGEST load_ptr_addr; ULONGEST load_addr; gdb_byte buf[8]; /* Get SP. */ if (regcache_cooked_read_unsigned (get_current_regcache (), gdbarch_sp_regnum (gdbarch), &load_ptr_addr) != REG_VALID) return 0; /* Read value at SP (image load address). */ if (target_read_memory (load_ptr_addr, buf, addr_size)) return 0; load_addr = extract_unsigned_integer (buf, addr_size, byte_order); return darwin_validate_exec_header (load_addr); }
static void core_open (char *filename, int from_tty) { const char *p; int siggy; struct cleanup *old_chain; char *temp; bfd *temp_bfd; int scratch_chan; int flags; volatile struct gdb_exception except; target_preopen (from_tty); if (!filename) { if (core_bfd) error (_("No core file specified. (Use `detach' " "to stop debugging a core file.)")); else error (_("No core file specified.")); } filename = tilde_expand (filename); if (!IS_ABSOLUTE_PATH (filename)) { temp = concat (current_directory, "/", filename, (char *) NULL); xfree (filename); filename = temp; } old_chain = make_cleanup (xfree, filename); flags = O_BINARY | O_LARGEFILE; if (write_files) flags |= O_RDWR; else flags |= O_RDONLY; scratch_chan = open (filename, flags, 0); if (scratch_chan < 0) perror_with_name (filename); temp_bfd = bfd_fopen (filename, gnutarget, write_files ? FOPEN_RUB : FOPEN_RB, scratch_chan); if (temp_bfd == NULL) perror_with_name (filename); if (!bfd_check_format (temp_bfd, bfd_core) && !gdb_check_format (temp_bfd)) { /* Do it after the err msg */ /* FIXME: should be checking for errors from bfd_close (for one thing, on error it does not free all the storage associated with the bfd). */ make_cleanup_bfd_close (temp_bfd); error (_("\"%s\" is not a core dump: %s"), filename, bfd_errmsg (bfd_get_error ())); } /* Looks semi-reasonable. Toss the old core file and work on the new. */ discard_cleanups (old_chain); /* Don't free filename any more */ unpush_target (&core_ops); core_bfd = temp_bfd; old_chain = make_cleanup (core_close_cleanup, 0 /*ignore*/); /* FIXME: kettenis/20031023: This is very dangerous. The CORE_GDBARCH that results from this call may very well be different from CURRENT_GDBARCH. However, its methods may only work if it is selected as the current architecture, because they rely on swapped data (see gdbarch.c). We should get rid of that swapped data. */ core_gdbarch = gdbarch_from_bfd (core_bfd); /* Find a suitable core file handler to munch on core_bfd */ core_vec = sniff_core_bfd (core_bfd); validate_files (); core_data = XZALLOC (struct target_section_table); /* Find the data section */ if (build_section_table (core_bfd, &core_data->sections, &core_data->sections_end)) error (_("\"%s\": Can't find sections: %s"), bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); /* If we have no exec file, try to set the architecture from the core file. We don't do this unconditionally since an exec file typically contains more information that helps us determine the architecture than a core file. */ if (!exec_bfd) set_gdbarch_from_file (core_bfd); push_target (&core_ops); discard_cleanups (old_chain); /* Do this before acknowledging the inferior, so if post_create_inferior throws (can happen easilly if you're loading a core file with the wrong exec), we aren't left with threads from the previous inferior. */ init_thread_list (); inferior_ptid = null_ptid; /* Need to flush the register cache (and the frame cache) from a previous debug session. If inferior_ptid ends up the same as the last debug session --- e.g., b foo; run; gcore core1; step; gcore core2; core core1; core core2 --- then there's potential for get_current_regcache to return the cached regcache of the previous session, and the frame cache being stale. */ registers_changed (); /* Build up thread list from BFD sections, and possibly set the current thread to the .reg/NN section matching the .reg section. */ bfd_map_over_sections (core_bfd, add_to_thread_list, bfd_get_section_by_name (core_bfd, ".reg")); if (ptid_equal (inferior_ptid, null_ptid)) { /* Either we found no .reg/NN section, and hence we have a non-threaded core (single-threaded, from gdb's perspective), or for some reason add_to_thread_list couldn't determine which was the "main" thread. The latter case shouldn't usually happen, but we're dealing with input here, which can always be broken in different ways. */ struct thread_info *thread = first_thread_of_process (-1); if (thread == NULL) { inferior_appeared (current_inferior (), CORELOW_PID); inferior_ptid = pid_to_ptid (CORELOW_PID); add_thread_silent (inferior_ptid); } else switch_to_thread (thread->ptid); } post_create_inferior (&core_ops, from_tty); /* Now go through the target stack looking for threads since there may be a thread_stratum target loaded on top of target core by now. The layer above should claim threads found in the BFD sections. */ TRY_CATCH (except, RETURN_MASK_ERROR) { target_find_new_threads (); } if (except.reason < 0) exception_print (gdb_stderr, except); p = bfd_core_file_failing_command (core_bfd); if (p) printf_filtered (_("Core was generated by `%s'.\n"), p); siggy = bfd_core_file_failing_signal (core_bfd); if (siggy > 0) { /* If we don't have a CORE_GDBARCH to work with, assume a native core (map gdb_signal from host signals). If we do have CORE_GDBARCH to work with, but no gdb_signal_from_target implementation for that gdbarch, as a fallback measure, assume the host signal mapping. It'll be correct for native cores, but most likely incorrect for cross-cores. */ enum gdb_signal sig = (core_gdbarch != NULL && gdbarch_gdb_signal_from_target_p (core_gdbarch) ? gdbarch_gdb_signal_from_target (core_gdbarch, siggy) : gdb_signal_from_host (siggy)); printf_filtered (_("Program terminated with signal %d, %s.\n"), siggy, gdb_signal_to_string (sig)); } /* Fetch all registers from core file. */ target_fetch_registers (get_current_regcache (), -1); /* Now, set up the frame cache, and print the top of stack. */ reinit_frame_cache (); print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); }
static LONGEST ia64_hpux_xfer_memory (struct target_ops *ops, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, CORE_ADDR addr, LONGEST len) { CORE_ADDR bsp, bspstore; CORE_ADDR start_addr, short_len; int status = 0; /* The back-store region cannot be read/written by the standard memory read/write operations. So we handle the memory region piecemeal: (1) and (2) The regions before and after the backing-store region, which can be treated as normal memory; (3) The region inside the backing-store, which needs to be read/written specially. */ regcache_raw_read_unsigned (get_current_regcache (), IA64_BSP_REGNUM, &bsp); regcache_raw_read_unsigned (get_current_regcache (), IA64_BSPSTORE_REGNUM, &bspstore); /* 1. Memory region before BSPSTORE. */ if (addr < bspstore) { short_len = len; if (addr + len > bspstore) short_len = bspstore - addr; status = ia64_hpux_xfer_memory_no_bs (ops, annex, readbuf, writebuf, addr, short_len); if (status <= 0) return 0; } /* 2. Memory region after BSP. */ if (addr + len > bsp) { start_addr = addr; if (start_addr < bsp) start_addr = bsp; short_len = len + addr - start_addr; status = ia64_hpux_xfer_memory_no_bs (ops, annex, readbuf ? readbuf + (start_addr - addr) : NULL, writebuf ? writebuf + (start_addr - addr) : NULL, start_addr, short_len); if (status <= 0) return 0; } /* 3. Memory region between BSPSTORE and BSP. */ if (bspstore != bsp && ((addr < bspstore && addr + len > bspstore) || (addr + len <= bsp && addr + len > bsp))) { start_addr = addr; if (addr < bspstore) start_addr = bspstore; short_len = len + addr - start_addr; if (start_addr + short_len > bsp) short_len = bsp - start_addr; gdb_assert (short_len > 0); status = ia64_hpux_xfer_memory_bs (ops, annex, readbuf ? readbuf + (start_addr - addr) : NULL, writebuf ? writebuf + (start_addr - addr) : NULL, start_addr, short_len); if (status < 0) return 0; } return len; }
void core_target_open (const char *arg, int from_tty) { const char *p; int siggy; int scratch_chan; int flags; target_preopen (from_tty); if (!arg) { if (core_bfd) error (_("No core file specified. (Use `detach' " "to stop debugging a core file.)")); else error (_("No core file specified.")); } gdb::unique_xmalloc_ptr<char> filename (tilde_expand (arg)); if (!IS_ABSOLUTE_PATH (filename.get ())) filename.reset (concat (current_directory, "/", filename.get (), (char *) NULL)); flags = O_BINARY | O_LARGEFILE; if (write_files) flags |= O_RDWR; else flags |= O_RDONLY; scratch_chan = gdb_open_cloexec (filename.get (), flags, 0); if (scratch_chan < 0) perror_with_name (filename.get ()); gdb_bfd_ref_ptr temp_bfd (gdb_bfd_fopen (filename.get (), gnutarget, write_files ? FOPEN_RUB : FOPEN_RB, scratch_chan)); if (temp_bfd == NULL) perror_with_name (filename.get ()); if (!bfd_check_format (temp_bfd.get (), bfd_core) && !gdb_check_format (temp_bfd.get ())) { /* Do it after the err msg */ /* FIXME: should be checking for errors from bfd_close (for one thing, on error it does not free all the storage associated with the bfd). */ error (_("\"%s\" is not a core dump: %s"), filename.get (), bfd_errmsg (bfd_get_error ())); } current_program_space->cbfd = std::move (temp_bfd); core_target *target = new core_target (); /* Own the target until it is successfully pushed. */ target_ops_up target_holder (target); validate_files (); /* If we have no exec file, try to set the architecture from the core file. We don't do this unconditionally since an exec file typically contains more information that helps us determine the architecture than a core file. */ if (!exec_bfd) set_gdbarch_from_file (core_bfd); push_target (std::move (target_holder)); inferior_ptid = null_ptid; /* Need to flush the register cache (and the frame cache) from a previous debug session. If inferior_ptid ends up the same as the last debug session --- e.g., b foo; run; gcore core1; step; gcore core2; core core1; core core2 --- then there's potential for get_current_regcache to return the cached regcache of the previous session, and the frame cache being stale. */ registers_changed (); /* Build up thread list from BFD sections, and possibly set the current thread to the .reg/NN section matching the .reg section. */ bfd_map_over_sections (core_bfd, add_to_thread_list, bfd_get_section_by_name (core_bfd, ".reg")); if (inferior_ptid == null_ptid) { /* Either we found no .reg/NN section, and hence we have a non-threaded core (single-threaded, from gdb's perspective), or for some reason add_to_thread_list couldn't determine which was the "main" thread. The latter case shouldn't usually happen, but we're dealing with input here, which can always be broken in different ways. */ thread_info *thread = first_thread_of_inferior (current_inferior ()); if (thread == NULL) { inferior_appeared (current_inferior (), CORELOW_PID); inferior_ptid = ptid_t (CORELOW_PID); add_thread_silent (inferior_ptid); } else switch_to_thread (thread); } post_create_inferior (target, from_tty); /* Now go through the target stack looking for threads since there may be a thread_stratum target loaded on top of target core by now. The layer above should claim threads found in the BFD sections. */ try { target_update_thread_list (); } catch (const gdb_exception_error &except) { exception_print (gdb_stderr, except); } p = bfd_core_file_failing_command (core_bfd); if (p) printf_filtered (_("Core was generated by `%s'.\n"), p); /* Clearing any previous state of convenience variables. */ clear_exit_convenience_vars (); siggy = bfd_core_file_failing_signal (core_bfd); if (siggy > 0) { gdbarch *core_gdbarch = target->core_gdbarch (); /* If we don't have a CORE_GDBARCH to work with, assume a native core (map gdb_signal from host signals). If we do have CORE_GDBARCH to work with, but no gdb_signal_from_target implementation for that gdbarch, as a fallback measure, assume the host signal mapping. It'll be correct for native cores, but most likely incorrect for cross-cores. */ enum gdb_signal sig = (core_gdbarch != NULL && gdbarch_gdb_signal_from_target_p (core_gdbarch) ? gdbarch_gdb_signal_from_target (core_gdbarch, siggy) : gdb_signal_from_host (siggy)); printf_filtered (_("Program terminated with signal %s, %s.\n"), gdb_signal_to_name (sig), gdb_signal_to_string (sig)); /* Set the value of the internal variable $_exitsignal, which holds the signal uncaught by the inferior. */ set_internalvar_integer (lookup_internalvar ("_exitsignal"), siggy); } /* Fetch all registers from core file. */ target_fetch_registers (get_current_regcache (), -1); /* Now, set up the frame cache, and print the top of stack. */ reinit_frame_cache (); print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); /* Current thread should be NUM 1 but the user does not know that. If a program is single threaded gdb in general does not mention anything about threads. That is why the test is >= 2. */ if (thread_count () >= 2) { try { thread_command (NULL, from_tty); } catch (const gdb_exception_error &except) { exception_print (gdb_stderr, except); } } }
/* Write given values into registers. The registers and values are given as pairs. The corresponding MI command is -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/ enum mi_cmd_result mi_cmd_data_write_register_values (char *command, char **argv, int argc) { int numregs, i; char format; /* Note that the test for a valid register must include checking the gdbarch_register_name because gdbarch_num_regs may be allocated for the union of the register sets within a family of related processors. In this case, some entries of gdbarch_register_name will change depending upon the particular processor being debugged. */ numregs = gdbarch_num_regs (current_gdbarch) + gdbarch_num_pseudo_regs (current_gdbarch); if (argc == 0) { mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]"); return MI_CMD_ERROR; } format = (int) argv[0][0]; if (!target_has_registers) { mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No registers."); return MI_CMD_ERROR; } if (!(argc - 1)) { mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: No regs and values specified."); return MI_CMD_ERROR; } if ((argc - 1) % 2) { mi_error_message = xstrprintf ("mi_cmd_data_write_register_values: Regs and vals are not in pairs."); return MI_CMD_ERROR; } for (i = 1; i < argc; i = i + 2) { int regnum = atoi (argv[i]); if (regnum >= 0 && regnum < numregs && gdbarch_register_name (current_gdbarch, regnum) && *gdbarch_register_name (current_gdbarch, regnum)) { LONGEST value; /* Get the value as a number. */ value = parse_and_eval_address (argv[i + 1]); /* Write it down. */ regcache_cooked_write_signed (get_current_regcache (), regnum, value); } else { mi_error_message = xstrprintf ("bad register number"); return MI_CMD_ERROR; } } return MI_CMD_DONE; }