static enum gdb_osabi
mips_sde_elf_osabi_sniffer (bfd *abfd)
{
enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
unsigned int elfosabi;
/* If the generic sniffer gets a hit, return and let other sniffers
get a crack at it. */
bfd_map_over_sections (abfd,
generic_elf_osabi_sniff_abi_tag_sections,
&osabi);
if (osabi != GDB_OSABI_UNKNOWN)
return GDB_OSABI_UNKNOWN;
elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
if (elfosabi == ELFOSABI_NONE)
{
/* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
file are conforming to the base specification for that machine
(there are no OS-specific extensions). In order to determine the
real OS in use we must look for OS notes that have been added.
For SDE, we simply look for sections named with .sde as prefixes. */
bfd_map_over_sections (abfd,
mips_sde_elf_osabi_sniff_abi_tag_sections,
&osabi);
}
return osabi;
}
void objdump(const char *path)
{
bfd_init();
bfd *abfd = bfd_openr(path, NULL);
if (abfd == NULL)
errx(1, bfd_errmsg(bfd_get_error()));
if (!bfd_check_format(abfd, bfd_object)) {
bfd_close_all_done(abfd);
errx(1, "File is not a valid object file.");
}
printf("%s: file format %s\n", path, bfd_get_target(abfd));
printf("architecture: %s, flags: 0x%08x\n", bfd_printable_arch_mach(bfd_get_arch(abfd), bfd_get_mach(abfd)), abfd->flags);
printf("start address 0x%016lx", bfd_get_start_address(abfd));
printf("\n");
printf("Sections:\n");
printf("Idx Name Size VMA LMA File off Algn\n");
printf(" Flags Content\n");
object_stats stats = { FALSE, FALSE };
bfd_map_over_sections(abfd, (void (*)(bfd *, asection *, void *))print_section, &stats);
if (stats.contains_hello && stats.contains_world)
printf("\nThis file might be a hello world program!\n");
bfd_close(abfd);
}
static
BOOL BfdGetSymFromAddr(bfd *abfd, asymbol **syms, long symcount, DWORD dwAddress, LPTSTR lpSymName, DWORD nSize)
{
HMODULE hModule;
struct find_handle info;
if(!(hModule = (HMODULE) GetModuleBase(dwAddress)))
return FALSE;
info.pc = dwAddress;
if(!(bfd_get_file_flags (abfd) & HAS_SYMS) || !symcount)
return FALSE;
info.syms = syms;
info.found = FALSE;
bfd_map_over_sections (abfd, find_address_in_section, (PTR) &info);
if (info.found == FALSE || info.line == 0)
return FALSE;
assert(lpSymName);
if(info.functionname == NULL && *info.functionname == '\0')
return FALSE;
lstrcpyn(lpSymName, info.functionname, nSize);
return TRUE;
}
static LONGEST
windows_core_xfer_shared_libraries (struct gdbarch *gdbarch,
gdb_byte *readbuf,
ULONGEST offset, LONGEST len)
{
struct obstack obstack;
const char *buf;
LONGEST len_avail;
struct cpms_data data = { gdbarch, &obstack, 0 };
obstack_init (&obstack);
obstack_grow_str (&obstack, "<library-list>\n");
bfd_map_over_sections (core_bfd,
core_process_module_section,
&data);
obstack_grow_str0 (&obstack, "</library-list>\n");
buf = obstack_finish (&obstack);
len_avail = strlen (buf);
if (offset >= len_avail)
return 0;
if (len > len_avail - offset)
len = len_avail - offset;
memcpy (readbuf, buf + offset, len);
obstack_free (&obstack, NULL);
return len;
}
extern bool getResourceFromFile(const char *filename, MemoryBuffer &data, const char * type, unsigned id)
{
#ifdef _WIN32
HINSTANCE dllHandle = LoadLibraryEx(filename, NULL, LOAD_LIBRARY_AS_DATAFILE|LOAD_LIBRARY_AS_IMAGE_RESOURCE);
if (dllHandle == NULL)
dllHandle = LoadLibraryEx(filename, NULL, LOAD_LIBRARY_AS_DATAFILE); // the LOAD_LIBRARY_AS_IMAGE_RESOURCE flag is not supported on all versions of Windows
if (dllHandle == NULL)
{
DBGLOG("Failed to load library %s: %d", filename, GetLastError());
return false;
}
HRSRC hrsrc = FindResource(dllHandle, MAKEINTRESOURCE(id), type);
if (!hrsrc)
return false;
size32_t len = SizeofResource(dllHandle, hrsrc);
const void *rdata = (const void *) LoadResource(dllHandle, hrsrc);
data.append(len, rdata);
FreeLibrary(dllHandle);
return true;
#else
bfd_init ();
bfd *file = bfd_openr(filename, NULL);
if (file)
{
StringBuffer sectionName;
sectionName.append(type).append("_").append(id).append(".data");
SecScanParam param(data, sectionName.str());
if (bfd_check_format (file, bfd_object))
bfd_map_over_sections (file, secscan, ¶m);
bfd_close (file);
}
return data.length() != 0;
#endif
}
static void
hw_binary_init_data_callback(device *me)
{
/* get the file name */
const char *file_name = device_find_string_property(me, "file-name");
bfd *image;
/* open the file */
image = bfd_openr(file_name, NULL);
if (image == NULL) {
bfd_perror("binary");
device_error(me, "Failed to open file %s\n", file_name);
}
/* check it is valid */
if (!bfd_check_format(image, bfd_object)) {
bfd_close(image);
device_error(me, "The file %s has an invalid binary format\n", file_name);
}
/* and the data sections */
bfd_map_over_sections(image,
update_for_binary_section,
(PTR)me);
bfd_close(image);
}
stacktrace::frame
stacktrace::translate_addresses (bfd* abfd, bfd_vma* addr, int naddr)
{
pc = addr[naddr - 1];
found = false;
bfd_map_over_sections (abfd, find_address_in_section, this);
if (!found)
{
char addrstr[ptrstr_len + 3];
snprintf (addrstr, sizeof addrstr, "0x%llx", (unsigned long long)addr[naddr - 1]);
return { addrstr, "???", 0 };
}
else
{
std::string func;
if (funcname == NULL || *funcname == '\0')
func = "???";
else
{
int status;
char* realname = abi::__cxa_demangle (funcname, 0, 0, &status);
func = status == 0 ? realname : funcname;
if (realname)
free (realname);
}
if (filename == NULL)
filename = "???";
else
if (char const* h = strrchr (filename, '/'))
filename = h + 1;
return { func.c_str (), filename, line };
}
}
static
BOOL BfdGetLineFromAddr(bfd *abfd, asymbol **syms, long symcount, DWORD dwAddress, LPTSTR lpFileName, DWORD nSize, LPDWORD lpLineNumber)
{
HMODULE hModule;
struct find_handle info;
if(!(hModule = (HMODULE) GetModuleBase(dwAddress)))
return FALSE;
info.pc = dwAddress;
if(!(bfd_get_file_flags (abfd) & HAS_SYMS) || !symcount)
return FALSE;
info.syms = syms;
info.found = FALSE;
bfd_map_over_sections (abfd, find_address_in_section, (PTR) &info);
if (info.found == FALSE || info.line == 0)
return FALSE;
assert(lpFileName && lpLineNumber);
lstrcpyn(lpFileName, info.filename, nSize);
*lpLineNumber = info.line;
return TRUE;
}
static int addr2line(const char *dso_name, u64 addr,
char **file, unsigned int *line, struct dso *dso)
{
int ret = 0;
struct a2l_data *a2l = dso->a2l;
if (!a2l) {
dso->a2l = addr2line_init(dso_name);
a2l = dso->a2l;
}
if (a2l == NULL) {
pr_warning("addr2line_init failed for %s\n", dso_name);
return 0;
}
a2l->addr = addr;
a2l->found = false;
bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l);
if (a2l->found && a2l->filename) {
*file = strdup(a2l->filename);
*line = a2l->line;
if (*file)
ret = 1;
}
return ret;
}
void
prg_write (int portfd, bfd * abfd)
{
bfd_map_over_sections (abfd, prg_write_section, &portfd);
}
extern bool getResourceFromFile(const char *filename, MemoryBuffer &data, const char * type, unsigned id)
{
#ifdef _WIN32
HINSTANCE dllHandle = LoadLibraryEx(filename, NULL, LOAD_LIBRARY_AS_DATAFILE|LOAD_LIBRARY_AS_IMAGE_RESOURCE);
if (dllHandle == NULL)
dllHandle = LoadLibraryEx(filename, NULL, LOAD_LIBRARY_AS_DATAFILE); // the LOAD_LIBRARY_AS_IMAGE_RESOURCE flag is not supported on all versions of Windows
if (dllHandle == NULL)
{
DBGLOG("Failed to load library %s: %d", filename, GetLastError());
return false;
}
HRSRC hrsrc = FindResource(dllHandle, MAKEINTRESOURCE(id), type);
if (!hrsrc)
return false;
size32_t len = SizeofResource(dllHandle, hrsrc);
const void *rdata = (const void *) LoadResource(dllHandle, hrsrc);
data.append(len, rdata);
FreeLibrary(dllHandle);
return true;
#elif defined (_USE_BINUTILS)
CriticalBlock block(bfdCs);
bfd_init ();
bfd *file = bfd_openr(filename, NULL);
if (file)
{
StringBuffer sectionName;
sectionName.append(type).append("_").append(id).append(".data");
SecScanParam param(data, sectionName.str());
if (bfd_check_format (file, bfd_object))
bfd_map_over_sections (file, secscan, ¶m);
bfd_close (file);
}
return data.length() != 0;
#else
struct stat stat_buf;
VStringBuffer sectname("%s_%u", type, id);
int fd = open(filename, O_RDONLY);
if (fd == -1 || fstat(fd, &stat_buf) == -1)
{
DBGLOG("Failed to load library %s: %d", filename, errno);
return false;
}
bool ok = false;
__uint64 size = stat_buf.st_size;
const byte *start_addr = (const byte *) mmap(0, size, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0);
if (start_addr == MAP_FAILED)
{
DBGLOG("Failed to load library %s: %d", filename, errno);
}
else
{
ok = getResourceFromMappedFile(filename, start_addr, data, type, id);
munmap((void *)start_addr, size);
}
close(fd);
return ok;
#endif
}
static int addr2line(const char *dso_name, u64 addr,
char **file, unsigned int *line, struct dso *dso,
bool unwind_inlines, struct inline_node *node,
struct symbol *sym)
{
int ret = 0;
struct a2l_data *a2l = dso->a2l;
if (!a2l) {
dso->a2l = addr2line_init(dso_name);
a2l = dso->a2l;
}
if (a2l == NULL) {
pr_warning("addr2line_init failed for %s\n", dso_name);
return 0;
}
a2l->addr = addr;
a2l->found = false;
bfd_map_over_sections(a2l->abfd, find_address_in_section, a2l);
if (!a2l->found)
return 0;
if (unwind_inlines) {
int cnt = 0;
if (node && inline_list__append_dso_a2l(dso, node, sym))
return 0;
while (bfd_find_inliner_info(a2l->abfd, &a2l->filename,
&a2l->funcname, &a2l->line) &&
cnt++ < MAX_INLINE_NEST) {
if (a2l->filename && !strlen(a2l->filename))
a2l->filename = NULL;
if (node != NULL) {
if (inline_list__append_dso_a2l(dso, node, sym))
return 0;
// found at least one inline frame
ret = 1;
}
}
}
if (file) {
*file = a2l->filename ? strdup(a2l->filename) : NULL;
ret = *file ? 1 : 0;
}
if (line)
*line = a2l->line;
return ret;
}
static int
write_hex_file (char *name, bfd *abfd)
{
FILE *fp;
int rc = 0;
fp = fopen (name, "w");
if (!fp)
{
printf ("Error: could not open file %s for writing!\n", name);
return 1;
}
if (verbose)
{
printf ("writing %s\n\n", name);
printf ("section byte address length (dec)\n");
printf ("--------------------------------------------------------------\n");
}
actual_prog_used = 0;
/* write each section */
if (sort_by_address)
{
init_section_list (&outputs);
bfd_map_over_sections (abfd, &build_section_list, outputs);
write_section_list (abfd, fp, outputs);
free_section_list (&outputs);
}
else
bfd_map_over_sections (abfd, &write_section, fp);
/* write the end of file marker */
fprintf (fp, ":00000001FF\n");
fclose (fp);
/* write summary info */
if (verbose)
printf ("\nTotal program memory used (bytes): %#18lx (%ld)\n",
actual_prog_used, actual_prog_used);
return rc;
}
/**
* Locate a symbol at the given addres.
*
* @param bc the BFD context retrieved by bfd_util_get_context()
* @param addr the address of the symbol
* @param loc where location information is returned
*
* @return TRUE if the symbol address was located.
*/
bool
bfd_util_locate(bfd_ctx_t *bc, const void *addr, struct symbol_loc *loc)
{
struct symbol_ctx sc;
const void *lookaddr;
const char *name;
g_assert(loc != NULL);
if G_UNLIKELY(NULL == bc)
return FALSE;
bfd_ctx_check(bc);
mutex_lock_fast(&bc->lock);
ZERO(&sc);
lookaddr = const_ptr_add_offset(addr, bc->offset);
sc.addr = pointer_to_ulong(lookaddr);
sc.symbols = bc->symbols;
bfd_map_over_sections(bc->handle, bfd_util_lookup_section, &sc);
if (sc.location.function != NULL) {
*loc = sc.location; /* Struct copy */
mutex_unlock_fast(&bc->lock);
return TRUE;
}
/*
* For some reason the BFD library successfully loads symbols but is not
* able to locate them through bfd_map_over_sections().
*
* Load the symbol table ourselves and perform the lookup then. We will
* only be able to fill the routine name, and not the source code
* information but that is better than nothing.
*/
if (NULL == bc->text_symbols) {
bc->text_symbols = symbols_make(bc->count, FALSE);
bfd_util_load_text(bc, bc->text_symbols);
symbols_sort(bc->text_symbols);
}
name = symbols_name_only(bc->text_symbols, lookaddr, FALSE);
if (name != NULL) {
ZERO(loc);
loc->function = name;
mutex_unlock_fast(&bc->lock);
return TRUE;
}
mutex_unlock_fast(&bc->lock);
return FALSE;
}
API bool buGetFileLine(BuFile* file, uint64_t address, const char** filename, unsigned int* line)
{
GetFileLineContext context = {false, address, nullptr, nullptr, 0, pbegin(file->symtab)};
bfd_map_over_sections(file->abfd.get(), GetFileLineContext::find_address_in_section, &context);
*filename = CoTaskStrDup(context.filename);
*line = context.line;
return context.found;
}
static bool translate_addresses(bfd *abfd, const char *addr,
addr2line_data *adata) {
adata->pc = bfd_scan_vma(addr, NULL, 16);
adata->found = FALSE;
bfd_map_over_sections(abfd, find_address_in_section, adata);
if (!adata->found || !adata->functionname || !*adata->functionname) {
return false;
}
return true;
}
static int
fbsd_thread_alive (ptid_t ptid)
{
td_thrhandle_t th;
td_thrinfo_t ti;
td_err_e err;
gregset_t gregs;
lwpid_t lwp;
if (IS_THREAD (ptid))
{
err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
if (err != TD_OK)
return 0;
err = td_thr_get_info_p (&th, &ti);
if (err != TD_OK)
return 0;
/* A zombie thread. */
if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
return 0;
return 1;
}
else if (GET_LWP (ptid) == 0)
{
/* we sometimes are called with lwp == 0 */
return 1;
}
if (fbsd_thread_active)
{
err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
/*
* if the lwp was already mapped to user thread, don't use it
* directly, please use user thread id instead.
*/
if (err == TD_OK)
return 0;
}
if (!target_has_execution)
{
lwp = GET_LWP (ptid);
bfd_map_over_sections (core_bfd, fbsd_core_check_lwp, &lwp);
return (lwp == 0);
}
/* check lwp in kernel */
return ptrace (PT_GETREGS, GET_LWP (ptid), (caddr_t)&gregs, 0) == 0;
}
bfd_boolean
pex64_bfd_print_pdata (bfd *abfd, void *vfile)
{
asection *pdata_section = bfd_get_section_by_name (abfd, ".pdata");
if (pdata_section)
return pex64_bfd_print_pdata_section (abfd, vfile, pdata_section);
pdata_count = 0;
bfd_map_over_sections (abfd, pex64_print_all_pdata_sections, vfile);
return (pdata_count > 0);
}
static enum gdb_osabi
generic_elf_osabi_sniffer (bfd *abfd)
{
unsigned int elfosabi;
enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
switch (elfosabi)
{
case ELFOSABI_NONE:
/* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
file are conforming to the base specification for that machine
(there are no OS-specific extensions). In order to determine the
real OS in use we must look for OS notes that have been added. */
bfd_map_over_sections (abfd,
generic_elf_osabi_sniff_abi_tag_sections,
&osabi);
break;
case ELFOSABI_FREEBSD:
osabi = GDB_OSABI_FREEBSD_ELF;
break;
case ELFOSABI_NETBSD:
osabi = GDB_OSABI_NETBSD_ELF;
break;
case ELFOSABI_LINUX:
osabi = GDB_OSABI_LINUX;
break;
case ELFOSABI_HURD:
osabi = GDB_OSABI_HURD;
break;
case ELFOSABI_SOLARIS:
osabi = GDB_OSABI_SOLARIS;
break;
}
if (osabi == GDB_OSABI_UNKNOWN)
{
/* The FreeBSD folks have been naughty; they stored the string
"FreeBSD" in the padding of the e_ident field of the ELF
header to "brand" their ELF binaries in FreeBSD 3.x. */
if (strcmp (&elf_elfheader (abfd)->e_ident[8], "FreeBSD") == 0)
osabi = GDB_OSABI_FREEBSD_ELF;
}
return osabi;
}
void
build_target_sections_from_bfd (struct target_ops *targ, struct bfd *abfd)
{
unsigned count;
struct section_table *start;
struct section_closure cl;
count = bfd_count_sections (abfd);
target_resize_to_sections (targ, count);
start = targ->to_sections;
cl.end = targ->to_sections;
bfd_map_over_sections (abfd, add_to_section_table, &cl);
gdb_assert (cl.end - start <= count);
}
static void add_bfd(bfd *Bfd) {
if (bfd_check_format(Bfd, bfd_object)) {
bfd_info_t *BfdInfo = new(bfd_info_t);
BfdInfo->FileName = Bfd->filename;
memset(BfdInfo->LocalTable, 0, sizeof(BfdInfo->LocalTable));
BfdInfo->Symbols = (asymbol **)malloc(bfd_get_symtab_upper_bound(Bfd));
int NoOfSymbols = bfd_canonicalize_symtab(Bfd, BfdInfo->Symbols);
bfd_map_over_sections(Bfd, (bfd_map)add_bfd_section, BfdInfo);
for (int I = NoOfSymbols - 1; I >= 0; --I) {
asymbol *Sym = BfdInfo->Symbols[I];
if (Sym->flags & BSF_GLOBAL) {
const char *Name = strdup(Sym->name);
symbol_t *Symbol = new_symbol(Name, (section_t *)Sym->section->userdata, Sym->value);
stringtable_put(BfdInfo->LocalTable, Name, Symbol);
stringtable_put(GlobalTable, Name, Symbol);
} else if (Sym->section == bfd_com_section_ptr) {
symbol_t *Symbol = (symbol_t *)stringtable_get(GlobalTable, Sym->name);
bss_section_t *Section;
if (!Symbol) {
const char *Name = strdup(Sym->name);
Section = new_bss_section(0);
Symbol = new_symbol(Name, (section_t *)Section, 0);
stringtable_put(GlobalTable, Name, Symbol);
stringtable_put(BfdInfo->LocalTable, Name, Symbol);
} else {
Section = (bss_section_t *)Symbol->Section;
};
if (Sym->value > Section->Size) Section->Size = Sym->value;
} else if (Sym->flags & BSF_LOCAL) {
const char *Name = strdup(Sym->name);
symbol_t *Symbol = new_symbol(Name, (section_t *)Sym->section->userdata, Sym->value);
stringtable_put(BfdInfo->LocalTable, Name, Symbol);
} else if (Sym->flags & BSF_WEAK) {
const char *Name = strdup(Sym->name);
symbol_t *Symbol = new_symbol(Name, (section_t *)Sym->section->userdata, Sym->value);
stringtable_put(WeakTable, Name, Symbol);
} else if (Sym->section == bfd_und_section_ptr) {
} else if (Sym->flags & BSF_DEBUGGING) {
// This may be supported later
} else {
printf("%s: unknown symbol type: %8x.\n", Bfd->filename, Sym->flags);
exit(1);
};
};
} else if (bfd_check_format(Bfd, bfd_archive)) {
bfd *Bfd2 = 0;
while ((Bfd2 = bfd_openr_next_archived_file(Bfd, Bfd2))) add_bfd(Bfd2);
};
};
void find(bfd_ctx * b, DWORD offset, const char *& file, const char *& func, size_t & line)
{
LogTrace();
find_info data;
data.symbol = b->symbol;
data.counter = offset;
data.file = NULL;
data.func = NULL;
data.line = 0;
bfd_map_over_sections(b->handle, &lookup_section, &data);
file = data.file;
func = data.func;
line = data.line;
}
void traceback::Bfd::Context::find(const char*& file, const char*& func, size_t& line, void* address)
{
Bfd::Info data;
data.symbol = symbol;
data.counter = (size_t)address;
data.file = nullptr;
data.func = nullptr;
data.line = 0;
bfd_map_over_sections(handle, &lookup_section, &data);
file = data.file;
func = data.func;
line = data.line;
// displacement = 0; //data.displacement;
}
int
build_objfile_section_table (struct objfile *objfile)
{
/* objfile->sections can be already set when reading a mapped symbol
file. I believe that we do need to rebuild the section table in
this case (we rebuild other things derived from the bfd), but we
can't free the old one (it's in the objfile_obstack). So we just
waste some memory. */
objfile->sections_end = 0;
bfd_map_over_sections (objfile->obfd, add_to_objfile_sections, (char *) objfile);
objfile->sections = (struct obj_section *)
obstack_finish (&objfile->objfile_obstack);
objfile->sections_end = objfile->sections + (unsigned long) objfile->sections_end;
return (0);
}
int BFDmanager_translateAddress (bfd *bfdImage, asymbol **bfdSymbols,
void *address, char **function, char **file, int *line)
{
BFDmanager_symbolInfo_t syminfo;
char caddress[32];
#if defined(DEBUG)
printf ("DEBUG: BFDmanager_translateAddress (%p, %p, address = %p)\n", bfdImage, bfdSymbols, address);
#endif
syminfo.found = FALSE;
if (bfdImage && bfdSymbols)
{
/* Convert the address into hexadecimal string format */
sprintf (caddress, "%p", address);
/* Prepare the query for BFD */
syminfo.pc = bfd_scan_vma (caddress, NULL, 16);
syminfo.symbols = bfdSymbols;
/* Iterate through sections of the given bfd image */
bfd_map_over_sections (bfdImage, BFDmanager_findAddressInSection, &syminfo);
/* Found the symbol ? If so, copy the data */
if (syminfo.found)
{
char *demangled = NULL;
*file = (char*) syminfo.filename;
*line = syminfo.line;
#if defined(HAVE_BFD_DEMANGLE)
if (syminfo.function)
demangled = bfd_demangle (bfdImage, syminfo.function, 0);
if (demangled)
*function = demangled;
else
*function = (char*) syminfo.function;
#else
*function = (char*) syminfo.function;
#endif
}
}
return syminfo.found;
}
int
build_section_table (struct bfd *some_bfd, struct target_section **start,
struct target_section **end)
{
unsigned count;
count = bfd_count_sections (some_bfd);
if (*start)
xfree (* start);
*start = (struct target_section *) xmalloc (count * sizeof (**start));
*end = *start;
bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
if (*end > *start + count)
internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
/* We could realloc the table, but it probably loses for most files. */
return 0;
}
static long
get_current_lwp (int pid)
{
struct ptrace_lwpinfo pl;
lwpid_t lwpid;
if (!target_has_execution)
{
lwpid = 0;
bfd_map_over_sections (core_bfd, fbsd_core_get_first_lwp, &lwpid);
return lwpid;
}
if (ptrace (PT_LWPINFO, pid, (caddr_t)&pl, sizeof(pl)))
perror_with_name("PT_LWPINFO");
return (long)pl.pl_lwpid;
}
static const char * wpa_trace_bfd_addr2func(void *pc)
{
bfd *abfd = cached_abfd;
struct bfd_data data;
if (abfd == NULL)
return NULL;
data.pc = (bfd_vma) pc;
data.found = FALSE;
bfd_map_over_sections(abfd, find_addr_sect, &data);
if (!data.found)
return NULL;
return data.function;
}
static void
set_section_index (struct objfile *objfile, flagword invert, flagword flags,
int *index_ptr)
{
struct find_section_offset_arg info;
info.objfile = objfile;
info.best_section = NULL;
info.empty_section = NULL;
info.invert = invert;
info.flags = flags;
bfd_map_over_sections (objfile->obfd, find_section_offset, &info);
if (info.best_section)
*index_ptr = info.best_section->index;
else if (info.empty_section)
*index_ptr = info.empty_section->index;
}
static int c2_flash_file(struct c2tool_state *state, const char *filename, const char *target, unsigned int offset)
{
bfd *ibfd;
struct flash_section_data fsdata = { state, offset };
ibfd = bfd_openr(filename, target);
if (ibfd == NULL) {
fprintf(stderr, "%s\n", bfd_errmsg(bfd_get_error()));
return -EINVAL;
}
if (!bfd_check_format(ibfd, bfd_object)) {
fprintf(stderr, "%s\n", bfd_errmsg(bfd_get_error()));
return -EINVAL;
}
bfd_map_over_sections(ibfd, flash_section, &fsdata);
return 0;
}