static struct disassemble_info gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file) { struct disassemble_info di; init_disassemble_info (&di, file, fprintf_disasm); di.flavour = bfd_target_unknown_flavour; di.memory_error_func = dis_asm_memory_error; di.print_address_func = dis_asm_print_address; /* NOTE: cagney/2003-04-28: The original code, from the old Insight disassembler had a local optomization here. By default it would access the executable file, instead of the target memory (there was a growing list of exceptions though). Unfortunately, the heuristic was flawed. Commands like "disassemble &variable" didn't work as they relied on the access going to the target. Further, it has been supperseeded by trust-read-only-sections (although that should be superseeded by target_trust..._p()). */ di.read_memory_func = dis_asm_read_memory; di.arch = gdbarch_bfd_arch_info (gdbarch)->arch; di.mach = gdbarch_bfd_arch_info (gdbarch)->mach; di.endian = gdbarch_byte_order (gdbarch); di.endian_code = gdbarch_byte_order_for_code (gdbarch); di.application_data = gdbarch; disassemble_init_for_target (&di); return di; }
/* Try to select a global architecture that matches "info". Return non-zero if the attempt succeeds. */ int gdbarch_update_p (struct gdbarch_info info) { struct gdbarch *new_gdbarch; /* Check for the current file. */ if (info.abfd == NULL) info.abfd = exec_bfd; if (info.abfd == NULL) info.abfd = core_bfd; /* Check for the current target description. */ if (info.target_desc == NULL) info.target_desc = target_current_description (); new_gdbarch = gdbarch_find_by_info (info); /* If there no architecture by that name, reject the request. */ if (new_gdbarch == NULL) { if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " "Architecture not found\n"); return 0; } /* If it is the same old architecture, accept the request (but don't swap anything). */ if (new_gdbarch == target_gdbarch ()) { if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " "Architecture %s (%s) unchanged\n", host_address_to_string (new_gdbarch), gdbarch_bfd_arch_info (new_gdbarch)->printable_name); return 1; } /* It's a new architecture, swap it in. */ if (gdbarch_debug) fprintf_unfiltered (gdb_stdlog, "gdbarch_update_p: " "New architecture %s (%s) selected\n", host_address_to_string (new_gdbarch), gdbarch_bfd_arch_info (new_gdbarch)->printable_name); set_target_gdbarch (new_gdbarch); return 1; }
void amd64_supply_native_gregset (struct regcache *regcache, const void *gregs, int regnum) { const char *regs = gregs; struct gdbarch *gdbarch = get_regcache_arch (regcache); int num_regs = amd64_native_gregset64_num_regs; int i; if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32) num_regs = amd64_native_gregset32_num_regs; if (num_regs > gdbarch_num_regs (gdbarch)) num_regs = gdbarch_num_regs (gdbarch); for (i = 0; i < num_regs; i++) { if (regnum == -1 || regnum == i) { int offset = amd64_native_gregset_reg_offset (gdbarch, i); if (offset != -1) regcache_raw_supply (regcache, i, regs + offset); } } }
static bfd * darwin_bfd_open (char *pathname) { char *found_pathname; int found_file; bfd *abfd; bfd *res; /* Search for shared library file. */ found_pathname = solib_find (pathname, &found_file); if (found_pathname == NULL) perror_with_name (pathname); /* Open bfd for shared library. */ abfd = solib_bfd_fopen (found_pathname, found_file); res = gdb_bfd_mach_o_fat_extract (abfd, bfd_object, gdbarch_bfd_arch_info (target_gdbarch ())); if (!res) { make_cleanup_bfd_unref (abfd); error (_("`%s': not a shared-library: %s"), bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ())); } /* The current filename for fat-binary BFDs is a name generated by BFD, usually a string containing the name of the architecture. Reset its value to the actual filename. */ xfree (bfd_get_filename (res)); res->filename = xstrdup (pathname); gdb_bfd_unref (abfd); return res; }
static int amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction) { struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); /* Is the inferior 32-bit? If so, then do fixup the siginfo object. */ if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32) { gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t)); if (direction == 0) compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native); else siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf); return 1; } /* No fixup for native x32 GDB. */ else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8) { gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t)); if (direction == 0) compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf, native); else siginfo_from_compat_x32_siginfo (native, (struct compat_x32_siginfo *) inf); return 1; } else 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 PyObject * archpy_name (PyObject *self, PyObject *args) { struct gdbarch *gdbarch = arch_object_to_gdbarch (self); const char *name = (gdbarch_bfd_arch_info (gdbarch))->printable_name; PyObject *py_name = PyString_FromString (name); return py_name; }
/* Override the to_fetch_registers routine. */ static void spu_fetch_registers (struct target_ops *ops, struct regcache *regcache, int regno) { struct gdbarch *gdbarch = get_regcache_arch(regcache); enum bfd_endian byte_order = (enum bfd_endian)gdbarch_byte_order(gdbarch); struct target_ops *ops_beneath = find_target_beneath(ops); int spufs_fd; CORE_ADDR spufs_addr; /* This version applies only if we're currently in spu_run. */ if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu) { while (ops_beneath && !ops_beneath->to_fetch_registers) ops_beneath = find_target_beneath (ops_beneath); gdb_assert (ops_beneath); ops_beneath->to_fetch_registers (ops_beneath, regcache, regno); return; } /* We must be stopped on a spu_run system call. */ if (!parse_spufs_run (inferior_ptid, &spufs_fd, &spufs_addr)) return; /* The ID register holds the spufs file handle. */ if (regno == -1 || regno == SPU_ID_REGNUM) { gdb_byte buf[4]; store_unsigned_integer_with_byte_order(buf, 4, spufs_fd, byte_order); regcache_raw_supply(regcache, SPU_ID_REGNUM, buf); } /* The NPC register is found in PPC memory at SPUFS_ADDR. */ if (regno == -1 || regno == SPU_PC_REGNUM) { gdb_byte buf[4]; if (target_read (ops_beneath, TARGET_OBJECT_MEMORY, NULL, buf, spufs_addr, sizeof buf) == sizeof buf) regcache_raw_supply (regcache, SPU_PC_REGNUM, buf); } /* The GPRs are found in the "regs" spufs file. */ if (regno == -1 || (regno >= 0 && regno < SPU_NUM_GPRS)) { gdb_byte buf[16 * SPU_NUM_GPRS]; char annex[32]; int i; xsnprintf (annex, sizeof annex, "%d/regs", spufs_fd); if (target_read (ops_beneath, TARGET_OBJECT_SPU, annex, buf, 0, sizeof buf) == sizeof buf) for (i = 0; i < SPU_NUM_GPRS; i++) regcache_raw_supply (regcache, i, buf + i*16); } }
static enum bfd_architecture default_gcore_arch (void) { const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (target_gdbarch ()); if (bfdarch != NULL) return bfdarch->arch; if (exec_bfd == NULL) error (_("Can't find bfd architecture for corefile (need execfile).")); return bfd_get_arch (exec_bfd); }
static void show_architecture (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { if (target_architecture_user == NULL) fprintf_filtered (file, _("The target architecture is set " "automatically (currently %s)\n"), gdbarch_bfd_arch_info (get_current_arch ())->printable_name); else fprintf_filtered (file, _("The target architecture is assumed to be %s\n"), set_architecture_string); }
static SCM gdbscm_arch_name (SCM self) { arch_smob *a_smob = arscm_get_arch_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME); struct gdbarch *gdbarch = a_smob->gdbarch; const char *name; name = (gdbarch_bfd_arch_info (gdbarch))->printable_name; return gdbscm_scm_from_c_string (name); }
static int gdbarch_instruction_length (struct gdbarch *gdbarch) { const struct bfd_arch_info *info = gdbarch_bfd_arch_info (gdbarch); switch (info->arch) { case bfd_arch_powerpc: return 4; default: return -1; } }
static void gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch, struct disassemble_info *di, const gdb_byte *insn, int max_len, CORE_ADDR addr) { init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf); /* init_disassemble_info installs buffer_read_memory, etc. so we don't need to do that here. The cast is necessary until disassemble_info is const-ified. */ di->buffer = (gdb_byte *) insn; di->buffer_length = max_len; di->buffer_vma = addr; di->arch = gdbarch_bfd_arch_info (gdbarch)->arch; di->mach = gdbarch_bfd_arch_info (gdbarch)->mach; di->endian = gdbarch_byte_order (gdbarch); di->endian_code = gdbarch_byte_order_for_code (gdbarch); disassemble_init_for_target (di); }
static PyObject * archpy_name (PyObject *self, PyObject *args) { struct gdbarch *gdbarch = NULL; const char *name; PyObject *py_name; ARCHPY_REQUIRE_VALID (self, gdbarch); name = (gdbarch_bfd_arch_info (gdbarch))->printable_name; py_name = PyString_FromString (name); return py_name; }
void sparc64_linux_handle_segmentation_fault (struct gdbarch *gdbarch, struct ui_out *uiout) { if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word != 64) return; CORE_ADDR addr = 0; long si_code = 0; try { /* Evaluate si_code to see if the segfault is ADI related. */ si_code = parse_and_eval_long ("$_siginfo.si_code\n"); if (si_code >= SEGV_ACCADI && si_code <= SEGV_ADIPERR) addr = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr"); } catch (const gdb_exception &exception) { return; } /* Print out ADI event based on sig_code value */ switch (si_code) { case SEGV_ACCADI: /* adi not enabled */ uiout->text ("\n"); uiout->field_string ("sigcode-meaning", _("ADI disabled")); uiout->text (_(" while accessing address ")); uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr)); break; case SEGV_ADIDERR: /* disrupting mismatch */ uiout->text ("\n"); uiout->field_string ("sigcode-meaning", _("ADI deferred mismatch")); uiout->text (_(" while accessing address ")); uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr)); break; case SEGV_ADIPERR: /* precise mismatch */ uiout->text ("\n"); uiout->field_string ("sigcode-meaning", _("ADI precise mismatch")); uiout->text (_(" while accessing address ")); uiout->field_fmt ("bound-access", "%s", paddress (gdbarch, addr)); break; default: break; } }
static int arscm_print_arch_smob (SCM self, SCM port, scm_print_state *pstate) { arch_smob *a_smob = (arch_smob *) SCM_SMOB_DATA (self); struct gdbarch *gdbarch = a_smob->gdbarch; gdbscm_printf (port, "#<%s", arch_smob_name); gdbscm_printf (port, " %s", gdbarch_bfd_arch_info (gdbarch)->printable_name); scm_puts (">", port); scm_remember_upto_here_1 (self); /* Non-zero means success. */ return 1; }
static unsigned long default_gcore_mach (void) { #if 1 /* See if this even matters... */ return 0; #else const struct bfd_arch_info *bfdarch = gdbarch_bfd_arch_info (current_gdbarch); if (bfdarch != NULL) return bfdarch->mach; if (exec_bfd == NULL) error (_("Can't find default bfd machine type (need execfile).")); return bfd_get_mach (exec_bfd); #endif /* 1 */ }
void amd64_collect_native_gregset (const struct regcache *regcache, void *gregs, int regnum) { char *regs = gregs; struct gdbarch *gdbarch = get_regcache_arch (regcache); int num_regs = amd64_native_gregset64_num_regs; int i; if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32) { num_regs = amd64_native_gregset32_num_regs; /* Make sure %eax, %ebx, %ecx, %edx, %esi, %edi, %ebp, %esp and %eip get zero-extended to 64 bits. */ for (i = 0; i <= I386_EIP_REGNUM; i++) { if (regnum == -1 || regnum == i) memset (regs + amd64_native_gregset_reg_offset (gdbarch, i), 0, 8); } /* Ditto for %cs, %ss, %ds, %es, %fs, and %gs. */ for (i = I386_CS_REGNUM; i <= I386_GS_REGNUM; i++) { if (regnum == -1 || regnum == i) memset (regs + amd64_native_gregset_reg_offset (gdbarch, i), 0, 8); } } if (num_regs > gdbarch_num_regs (gdbarch)) num_regs = gdbarch_num_regs (gdbarch); for (i = 0; i < num_regs; i++) { if (regnum == -1 || regnum == i) { int offset = amd64_native_gregset_reg_offset (gdbarch, i); if (offset != -1) regcache_raw_collect (regcache, i, regs + offset); } } }
static int amd64_native_gregset_reg_offset (struct gdbarch *gdbarch, int regnum) { int *reg_offset = amd64_native_gregset64_reg_offset; int num_regs = amd64_native_gregset64_num_regs; gdb_assert (regnum >= 0); if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32) { reg_offset = amd64_native_gregset32_reg_offset; num_regs = amd64_native_gregset32_num_regs; } if (num_regs > gdbarch_num_regs (gdbarch)) num_regs = gdbarch_num_regs (gdbarch); if (regnum < num_regs && regnum < gdbarch_num_regs (gdbarch)) return reg_offset[regnum]; return -1; }
void gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch, enum gdb_osabi osabi) { struct gdb_osabi_handler *handler; bfd *abfd = info.abfd; const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch); if (osabi == GDB_OSABI_UNKNOWN) { /* Don't complain about an unknown OSABI. Assume the user knows what they are doing. */ return; } for (handler = gdb_osabi_handler_list; handler != NULL; handler = handler->next) { if (handler->arch == bfd_get_arch (abfd) && handler->osabi == osabi) { (*handler->init_osabi) (info, gdbarch); return; } } /* We assume that if GDB_MULTI_ARCH is less than GDB_MULTI_ARCH_TM that an ABI variant can be supported by overriding definitions in the tm-file. */ if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL) fprintf_filtered (gdb_stderr, "A handler for the OS ABI \"%s\" is not built into this " "configuration of GDB. " "Attempting to continue with the default %s settings", gdbarch_osabi_name (osabi), bfd_printable_arch_mach (arch_info->arch, arch_info->mach)); }
/* If the PPU thread is currently stopped on a spu_run system call, return to FD and ADDR the file handle and NPC parameter address used with the system call. Return non-zero if successful. */ static int parse_spufs_run (ptid_t ptid, int *fd, CORE_ADDR *addr) { enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); struct gdbarch_tdep *tdep; struct regcache *regcache; gdb_byte buf[4]; #ifdef ALLOW_UNUSED_VARIABLES CORE_ADDR pc; #endif /* ALLOW_UNUSED_VARIABLES */ ULONGEST regval; /* If we're not on PPU, there's nothing to detect. */ if (gdbarch_bfd_arch_info (target_gdbarch)->arch != bfd_arch_powerpc) return 0; /* Get PPU-side registers. */ regcache = get_thread_arch_regcache (ptid, target_gdbarch); tdep = new_gdbarch_tdep(target_gdbarch); /* Fetch instruction preceding current NIP. */ if (target_read_memory (regcache_read_pc (regcache) - 4, buf, 4) != 0) return 0; /* It should be a "sc" instruction. */ if (extract_unsigned_integer_with_byte_order(buf, 4, byte_order) != INSTR_SC) return 0; /* System call number should be NR_spu_run. */ regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum, ®val); if (regval != NR_spu_run) return 0; /* Register 3 contains fd, register 4 the NPC param pointer. */ regcache_cooked_read_unsigned (regcache, PPC_ORIG_R3_REGNUM, ®val); *fd = (int) regval; regcache_cooked_read_unsigned (regcache, tdep->ppc_gp0_regnum + 4, ®val); *addr = (CORE_ADDR) regval; return 1; }
nbfd = bfd_open_from_target_memory (code_entry->symfile_addr, code_entry->symfile_size, gnutarget); old_cleanups = make_cleanup_bfd_close (nbfd); /* Check the format. NOTE: This initializes important data that GDB uses! We would segfault later without this line. */ if (!bfd_check_format (nbfd, bfd_object)) { printf_unfiltered (_("\ JITed symbol file is not an object file, ignoring it.\n")); do_cleanups (old_cleanups); return; } /* Check bfd arch. */ b = gdbarch_bfd_arch_info (gdbarch); if (b->compatible (b, bfd_get_arch_info (nbfd)) != b) warning (_("JITed object file architecture %s is not compatible " "with target architecture %s."), bfd_get_arch_info (nbfd)->printable_name, b->printable_name); /* Read the section address information out of the symbol file. Since the file is generated by the JIT at runtime, it should all of the absolute addresses that we care about. */ sai = alloc_section_addr_info (bfd_count_sections (nbfd)); make_cleanup_free_section_addr_info (sai); i = 0; for (sec = nbfd->sections; sec != NULL; sec = sec->next) if ((bfd_get_section_flags (nbfd, sec) & (SEC_ALLOC|SEC_LOAD)) != 0) { /* We assume that these virtual addresses are absolute, and do not
ps_err_e ps_get_thread_area (const struct ps_prochandle *ph, lwpid_t lwpid, int idx, void **base) { if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32) { /* The full structure is found in <asm-i386/ldt.h>. The second integer is the LDT's base_address and that is used to locate the thread's local storage. See i386-linux-nat.c more info. */ unsigned int desc[4]; /* This code assumes that "int" is 32 bits and that GET_THREAD_AREA returns no more than 4 int values. */ gdb_assert (sizeof (int) == 4); #ifndef PTRACE_GET_THREAD_AREA #define PTRACE_GET_THREAD_AREA 25 #endif if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, (void *) (long) idx, (unsigned long) &desc) < 0) return PS_ERR; /* Extend the value to 64 bits. Here it's assumed that a "long" and a "void *" are the same. */ (*base) = (void *) (long) desc[1]; return PS_OK; } else { /* This definition comes from prctl.h, but some kernels may not have it. */ #ifndef PTRACE_ARCH_PRCTL #define PTRACE_ARCH_PRCTL 30 #endif /* FIXME: ezannoni-2003-07-09 see comment above about include file order. We could be getting bogus values for these two. */ gdb_assert (FS < ELF_NGREG); gdb_assert (GS < ELF_NGREG); switch (idx) { case FS: #ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE { /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the fs_base and gs_base fields of user_regs_struct can be used directly. */ unsigned long fs; errno = 0; fs = ptrace (PTRACE_PEEKUSER, lwpid, offsetof (struct user_regs_struct, fs_base), 0); if (errno == 0) { *base = (void *) fs; return PS_OK; } } #endif if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0) return PS_OK; break; case GS: #ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE { unsigned long gs; errno = 0; gs = ptrace (PTRACE_PEEKUSER, lwpid, offsetof (struct user_regs_struct, gs_base), 0); if (errno == 0) { *base = (void *) gs; return PS_OK; } } #endif if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0) return PS_OK; break; default: /* Should not happen. */ return PS_BADADDR; } } return PS_ERR; /* ptrace failed. */ }
ps_err_e ps_get_thread_area (const struct ps_prochandle *ph, lwpid_t lwpid, int idx, void **base) { if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32) { unsigned int base_addr; ps_err_e result; result = x86_linux_get_thread_area (lwpid, (void *) (long) idx, &base_addr); if (result == PS_OK) { /* Extend the value to 64 bits. Here it's assumed that a "long" and a "void *" are the same. */ (*base) = (void *) (long) base_addr; } return result; } else { /* This definition comes from prctl.h, but some kernels may not have it. */ #ifndef PTRACE_ARCH_PRCTL #define PTRACE_ARCH_PRCTL 30 #endif /* FIXME: ezannoni-2003-07-09 see comment above about include file order. We could be getting bogus values for these two. */ gdb_assert (FS < ELF_NGREG); gdb_assert (GS < ELF_NGREG); switch (idx) { case FS: #ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE { /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the fs_base and gs_base fields of user_regs_struct can be used directly. */ unsigned long fs; errno = 0; fs = ptrace (PTRACE_PEEKUSER, lwpid, offsetof (struct user_regs_struct, fs_base), 0); if (errno == 0) { *base = (void *) fs; return PS_OK; } } #endif if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0) return PS_OK; break; case GS: #ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE { unsigned long gs; errno = 0; gs = ptrace (PTRACE_PEEKUSER, lwpid, offsetof (struct user_regs_struct, gs_base), 0); if (errno == 0) { *base = (void *) gs; return PS_OK; } } #endif if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0) return PS_OK; break; default: /* Should not happen. */ return PS_BADADDR; } } return PS_ERR; /* ptrace failed. */ }
const char * default_gnu_triplet_regexp (struct gdbarch *gdbarch) { return gdbarch_bfd_arch_info (gdbarch)->arch_name; }